sizeof.cpp

#include<iostream>
#include <stdio.h>
#include <string.h>
using namespace  std;
struct 
{
short a1;
short a2;
short a3;
}A;
struct
{
long a1;
short a2;
}B;
class D
{


};
class A2
{
char d,e;
};
struct E
{


};
struct C
{
char b,c;
};
struct  f
{
int x,y;
};


int main()
{
char* ss1="0123456789";
char ss2[]="0123456789";
char ss3[100]="0123456789";
int ss4[100];
char q1[]="abc";
char q2[]="a\n";
char*  q3="a\n";
char* str1=(char*)malloc(100);
void* str2=(void*)malloc(100);
cout<<sizeof(ss1)<<endl;//ss1是一个指针  此时输出的应该是4个字节
cout<<sizeof(ss2)<<endl;//ss2是一个字符数组，这个数组最初未定大小，由具体填充值
//来确定。填充值为"0123456789".1个字符所占空间是1位，加上结束符“\0”，得出结果为11
    cout<<sizeof(ss3)<<endl;//是一个字符数组，这个数组开始预分配100，所以大小为100
cout<<sizeof(ss4)<<endl;//此时是一个int类型的数组，但每个int所占空间为4，大小为400
cout<<sizeof(q1)<<endl;//q1是一个字符数组，里面存有abc,所以大小为4
cout<<sizeof(q2)<<endl;//q2是一个字符数组，大小为3
cout<<sizeof(q3)<<endl;//q3是一个字符指针，大小为4
cout<<sizeof(A)<<endl;//A和B是两个结构体，在默认情况下，为了
//方便对结构体内元素的访问和管理，当结构体内的元素的长度都小于处理器的位数时候
//便以结构体内最长的数据元素为对齐单位，也就是说，结构体的长度一定是最长的数据元素
//的整数倍。如果结构体内存在长度大于处理器位数的元素
//那么就以处理器的位数为对齐单位，但是结构体内类型相同的连续元素
//将在连续的空间内，和数组一样，A中有3个short类型变量，各自以2字节对齐
//结构体对齐参数按默认的8字节对齐，则a1,a2,a3都取2字节对齐，sizeof(A)为6
//其也是2的倍数。
cout<<sizeof(B)<<endl;
//B中a1为4字节，a2为2字节对齐，结构体默认对齐参数为8，则a1取
//4字节，a2为2字节对齐，结构体大小6字节，6不为4的倍数，补空字节到8.
cout<<sizeof(str1)<<endl;//指针大小为4
cout<<sizeof(str2)<<endl;//指针大小为4
cout<<sizeof(D)<<endl;//空类的大小应该为1，作为标识一个类的作用
cout<<sizeof(A2)<<endl;//大小应该为2，里面存有两个字符
D *p1=new D();
D p2;
D* p3;
cout<<sizeof(p1)<<endl;//作为一个指针大小应该为4
cout<<sizeof(p2)<<endl;//作为一个对象，里面没有含有数据成员，大小为1
cout<<sizeof(p3)<<endl;//作为一个指针对象，大小应该为4
cout<<sizeof(E)<<endl;//1
cout<<sizeof(C)<<endl;//2
cout<<sizeof(f)<<endl;//8,里面还有两个int类型成员
return 0;
}

sizeof1.cpp

#include <iostream>
using namespace std;
//#pragma pack(8)
class A1//为8个字节，int 占4个字节，虚析构函数占4个字节
{
public:
int  a ;//在内存中占有4个字节
   static int b;//静态变量是存放在全局数据区中的
A1();
virtual ~A1();//虚函数在内存中是占有一个指针，指向虚函数表的
};
class A2//在内存中占有8个字节
{
public:
int a;
char c;
A2();
~A2();
};
class  A3//float是占有4个字节的，所以A3应该为4的整数倍，为8
{
public:
float a;

char c;
A3();
~A3();
};
class A4//应该也是12，补齐3个字节
{
public:
float a;
int b;
char c;
A4();
~A4();
};
class A5//24个字节，补齐7个字节
{
public:
double  d;
float a;
int  b;
char c;
A5();
~A5();
};
short   f();
int main()
{
cout<<sizeof(A1)<<endl;
cout<<sizeof(A2)<<endl;
cout<<sizeof(A3)<<endl;
cout<<sizeof(A4)<<endl;
cout<<sizeof(A5)<<endl;
cout<<sizeof(f())<<endl;//等价于sizeof(short)为2个字节
return 0;
}

sizeof3.cpp

#include <iostream>
#include <complex>
using namespace std;
class Base//字节数8个,一个是虚函数指针，指向虚函数表，占4个字节  函数是存放在代码段   不分配内存
{
public:
Base()
{
cout<<"Base-ctor"<<endl;
}
~Base()
{
cout<<"Base-dtor"<<endl;
}
virtual void f(int)
{
cout<<"fdfd"<<endl;
}
virtual  void f(double)
{
cout<<"dfdf"<<endl;
}
void g2(int i=10)
{
cout<<"fddf"<<i<<endl;
}
};
class  C//一个类标识   1个字节   函数分布在代码段  不占字节
{
public  :
int f();
};
class Derive:public Base//一个指针指向虚函数表  也为4个字节
{
public:
Derive()
{
cout<<"Derive"<<endl;
}
~Derive()
{
cout<<"Dtor"<<endl;
}
void f(complex<double>)
{
cout<<"hjk"<<endl;
}
virtual void g(int i=20)
{
cout<<"fdf"<<i<<endl;
}
};
char    buf[10];
int  f2(char buf[10])//退化为一个指针  为4个字节
{
return sizeof(buf);
}
int main()
{
//Base b;
//Derive d;
//Base* pb=new Derive;
int i=f2(buf);
cout<<sizeof(Base)<<endl;
cout<<sizeof(Derive)<<endl;
cout<<sizeof(C)<<endl;
cout<<i<<endl;
return 0;


}
//空类所占空间为1，单一继承的空类空间也为1，多重继承的空类空间还是1，但是虚继承涉及到虚表（虚指针），所以为4字节（如果虚继承一个空类）