C++类初始化的一些思考

我们都知道在计算类的大小的时候，函数是不被计算的，除非类里边有虚函数，这样的话计算类的大小的时候，为了寻找虚函数表，会加入虚函数指针，这样计算类的大小的时候就多了一个虚函数指针的大小。
通过一个类的指针，我们可以访问到他的public成员函数，即便是这个指针被赋值空（如果这个成员函数内部没有对于其他成员变量的操作）。

#include<iostream>using namespace std;class A｛public:    int a;    int b;    int c;    void print(){        cout<<"I am print"<<endl;    }   ｝;int main(){    A * a = NULL;    a->print();    return 0;}

运行结果： I am print
说明成员函数和类指针应该是有着另外一种方式联系起来了（本人水平有限，不知道是什么原因）。
那么在另外一种情况下，即A类的派生类，依然去重写print函数的时候，有另外一种现象。

#include<iostream>using namespace std;class A｛public:    int a;    int b;    int c;    void print(){        cout<<"I am print"<<endl;    }   ｝;class B :public A{public:        int a;        void print(){            cout<<"I am  B print"<<endl;        }};class C: public B{public:        int a;        void print(){            cout<<"I am C print"<<endl;        }};int main(){    A * a = NULL;    B b;    C c;    a->print();    a = &b;    a->print();    a = &c;    a->print();    return 0;}

运行结果：

我们可以看到执行的结果全是基类的函数，说明函数指针的类型可能决定了成员函数的寻找。

由此，联想到了函数初始化的一些问题，并且自己并不清楚其中发生了什么。仍然以上边的类A做例子

#include<iostream>using namespace std;class A｛public:    int a;    int b;    int c;    void print(){        cout<<"I am print"<<endl;    }   ｝;int main(){    A * a = NULL;    //在不通过new的方式下，给A的成员赋值看看会发生什么    a->a = 10;    a->b = 11;    a->c = 12;    cout<<a->a<<endl;    cout<<a->b<<endl;    cout<<a->c<<endl;    return 0;}

运行结果：

很显然，这是有问题的，因为这种操作是找不到值的存放的位置的。
那么再考虑另一种情况：我们通过一个空类，将空类指针强制转换成A

#include<iostream>using namespace std;class A｛public:    int a;    int b;    int c;    void print(){        cout<<"I am print"<<endl;    }   ｝;class T{};int main(){    A * a = (A*)new T();    //在不通过new的方式下，给A的成员赋值看看会发生什么    a->a = 10;    a->b = 11;    a->c = 12;    cout<<a->a<<endl;    cout<<a->b<<endl;    cout<<a->c<<endl;    //我们看一下a,b,c的地址在是不是连续的    cout<<&(a->b)-&(a->a)<<endl;    cout<<&(a->c)-&(a->b)<<endl;    return 0;}

运行结果：

这些操作彷佛A类已经完全存在了一样，上边的赋值过程好像做了构造函数初始化操作一样，一个空类的指针是一个字节，是有有效地址的，我们知道new操作的内存是分配在自由区的。那么我们考虑一下在栈上赋值地址会发生什么？

int main(){    int t = 0;    A * a = (A*)(&t);    //在不通过new的方式下，给A的成员赋值看看会发生什么    a->a = 10;    a->b = 11;    a->c = 12;    cout<<a->a<<endl;    cout<<a->b<<endl;    cout<<a->c<<endl;    //我们看一下a,b,c的地址在是不是连续的    cout<<&(a->b)-&(a->a)<<endl;    cout<<&(a->c)-&(a->b)<<endl;    return 0;}

运行结果：

这里也出现了段错误的现象，看来并不是随便给一个地址就可以的。那么我们继续考虑，如果我通过malloc的方式，随便分配一个内存呢，会怎么样。

//加上stdlib的引用#include<stdlib.h>int main(){    int * t = (int*)malloc(4);    A * a = (A*)(t);    //在不通过new的方式下，给A的成员赋值看看会发生什么    a->a = 10;    a->b = 11;    a->c = 12;    cout<<a->a<<endl;    cout<<a->b<<endl;    cout<<a->c<<endl;    //我们看一下a,b,c的地址在是不是连续的    cout<<&(a->b)-&(a->a)<<endl;    cout<<&(a->c)-&(a->b)<<endl;    return 0;}

运行结果：

看来通过malloc在堆上分配的内存通过强制转换达到了相同的效果。
成功的几个例子中，对于类成员都进行了赋值操作，那么不完全赋值的时候，又有什么特征呢，没有被赋值的成员是不是可以访问，访问后会得到什么值，下边再进行测试。

#include<iostream>using namespace std;class A｛public:    int a;    int b;    int c;    void print(){        cout<<"I am print"<<endl;    }   ｝;class T{};int main(){    A * a = (A*)new T();    //在不通过new的方式下，给A的成员赋值看看会发生什么    a->a = 10;    a->b = 11;    cout<<a->a<<endl;    cout<<a->b<<endl;    cout<<a->c<<endl;    //我们看一下a,b,c的地址在是不是连续的    cout<<&(a->b)-&(a->a)<<endl;    cout<<&(a->c)-&(a->b)<<endl;    return 0;}

运行结果：

我们发现c的值是0，依然可以访问，并不能算是垃圾值吧。这中间到底发生了什么，本人不太清楚，希望哪位高手能够给予本人一点提示，作为一个半路出家的程序员，没有进行过系统专业知识学习的问题也许就在这些细节上吧。