我们都知道在计算类的大小的时候,函数是不被计算的,除非类里边有虚函数,这样的话计算类的大小的时候,为了寻找虚函数表,会加入虚函数指针,这样计算类的大小的时候就多了一个虚函数指针的大小。
通过一个类的指针,我们可以访问到他的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,依然可以访问,并不能算是垃圾值吧。这中间到底发生了什么,本人不太清楚,希望哪位高手能够给予本人一点提示,作为一个半路出家的程序员,没有进行过系统专业知识学习的问题也许就在这些细节上吧。