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