类对象的sizeof

类的sizeof

类的sizeof值等于类中成员变量所占用的内存字节数。如：

****************************************************************

class A
{
public:
  int b;
  float c;
  char d;
};

int main(void)
{
A object;
cout < < "sizeof(object) is " < < sizeof(object) < < endl;
return 0 ;
}

************************************************************


输出结果为12（我的机器上sizeof(float)值为4，字节对其前面已经讲过）。

不过需要注意的是，如果类中存在静态成员变量，结果又会是什么样子呢？

************************************************************

class A
{
public:
  static int a;
  int b;
  float c;
  char d;
};

int main()
{
A object;
cout < < "sizeof(object) is " < < sizeof(object) < < endl;
return 0 ;
}

************************************************************


16？不对。结果仍然是12.

因为在程序编译期间，就已经为static变量在静态存储区域分配了内存空间，并且这块内存在程序的整个运行期间都存在。

而每次声明了类A的一个对象的时候，为该对象在堆上，根据对象的大小分配内存。

如果类A中包含成员函数，那么又会是怎样的情况呢？看下面的例子

************************************************************

class A
{
public:
  static int a;
  int b;
  float c;
  char d;
  int add(int x,int y)
  {
    return x+y;
  }
};

int main()
{
A object;
cout < < "sizeof(object) is " < < sizeof(object) < < endl;
b = object.add(3,4);
cout < < "sizeof(object) is " < < sizeof(object) < < endl;
return 0 ;
}

************************************************************

结果仍为12。

因为只有非静态类成员变量在新生成一个object的时候才需要自己的副本。
所以每个非静态成员变量在生成新object需要内存，而function是不需要的。


注：C++中的多态和虚继承也是非常重要的东西，不过比较复杂，编译器不同，细节也有所不同。（以后慢慢研究，哈哈）

 

 

不同对象的地址要保证不相同，所以即使是个空类，编译器也会填充一个字节的大小
C/C++ code

#include <iostream>
using namespace std;

class A
{

};

int main()
{
    cout<<sizeof(A)<<endl;//输出1
    return 0;
}

 

 

以下内容来自

http://hi.baidu.com/gaomanyi/blog/item/91258e820f8f6cb96d8119bd.html

 

类的内存布局-sizeof(类对象)

一、简单对象
#include<iostream.h>
class A
{
public:
int a;
char b;
static int c;
virtual ~A(){};
};

int A::c=123;

int main()
{
A asimple;
cout<<sizeof(asimple)<<endl;
return 0;
} //result=4+4+1+3=12即字节对齐(虚指针+非静态数据成员)

二、单继承

#include<iostream.h>
class A
{
public:
int a;
char b;
static int c;
virtual ~A(){};
};

int A::c=123;

class B:public A
{
public:
int d;
virtual void foob(){};
};

int main()
{
// A asimple;
B bsimple;
cout<<sizeof(bsimple)<<endl;
return 0;
} //result=(4+4+1+3)+4=16即字节对齐(基类size+B自己的非静态数据成员)

三、多继承

#include<iostream.h>
class A
{
public:
int a;
char b;
static int c;
virtual ~A(){};
};

int A::c=123;

class B
{
public:
int d;
virtual void foob(){};
};
class C:public A,public B
{
public:
int e;
};


int main()
{
A asimple;
B bsimple;
        C csimple;
cout<<sizeof(asimple)<<endl; //12
cout<<sizeof(bsimple)<<endl; //8
cout<<sizeof(csimple)<<endl;
       //12+8+4=24 即字节对齐(基类A大小+基类B大小+C自己的非静态数据成员)
return 0;
}

四、菱形继承
1.非虚拟继承方式
#include<iostream.h>
class A
{
public:
int a;
char b;
static int c;
virtual ~A(){};
virtual void fooa(){};
};

int A::c=123;

class B:public A
{
public:
int d;
virtual void foob(){};
};
class C:public A
{
public:
int e;
};

class D:public B,public C
{
public:
char f;
};


int main()
{
A asimple;
B bsimple;
    C csimple;
D dsimple;
cout<<sizeof(asimple)<<endl;//12
cout<<sizeof(bsimple)<<endl;//16
cout<<sizeof(csimple)<<endl;//16
cout<<sizeof(dsimple)<<endl;//16+16+4=36 同多继承方式
return 0;
}
2.虚拟继承
(1)B中重写fooa(),但不定义新的虚函数
#include<iostream.h>
class A
{
public:
int a;
char b;
static int c;
virtual ~A(){};
virtual void fooa(){};
};

int A::c=123;

class B:virtual public A
{
public:
int d;
// virtual void foob(){};
virtual void fooa(){cout<<"fooa in B"<<endl;};
};
class C:virtual public A
{
public:
int e;
};

class D:public B,public C
{
public:
char f;
};


int main()
{
A asimple;
B bsimple;
        C csimple;
D dsimple;
cout<<sizeof(asimple)<<endl;//12
cout<<sizeof(bsimple)<<endl;//20
cout<<sizeof(csimple)<<endl;//20
cout<<sizeof(dsimple)<<endl;//32
return 0;
}

(2)B定义新的虚函数
#include<iostream.h>
class A
{
public:
int a;
char b;
static int c;
virtual ~A(){};
virtual void fooa(){};
};

int A::c=123;

class B:virtual public A
{
public:
int d;
virtual void foob(){cout<<"foob in B"<<endl;};
// virtual void fooa(){cout<<"fooa in B"<<endl;};
};
class C:virtual public A
{
public:
int e;
};

class D:public B,public C
{
public:
char f;
};


int main()
{
A asimple;
B bsimple;
    C csimple;
D dsimple;
cout<<sizeof(asimple)<<endl;//12
cout<<sizeof(bsimple)<<endl;//24
cout<<sizeof(csimple)<<endl;//20
cout<<sizeof(dsimple)<<endl;//36
return 0;
}

综合1，2，可见
1.非虚拟继承时，无论派生类是否定义新的虚函数，基类和派生类总是共享一个虚函数表，不需要另加指向虚函数的指针。
2.虚拟继承时，若是派生类只是继承或重写基类中虚函数，则基类和派生类是共享一个虚函数表；若派生类新定义了虚函数，则需要新加一个虚指针指向新的虚函数表。