sizeof

#include"iostream"
using namespace std;
//sizeof(foo(3)) 有参数时要有参数，否则不正确
char foo(int a)
{
    cout<<"这是一个foo函数。"<<endl;
    return 'a';
}

//sizeof p与sizeof(funn())与sizeof(funnn())有关指针类型的
void fun(int *p)
{

    cout<<"sizeof p="<<sizeof p<<endl;
}
char *funn()
{
    char k[10]="jjjjj";
    char *p="kfkkfkf";
    cout<<"char *funn()"<<endl;
    return p;
}
void *funnn()
{
    return NULL;
}


//有关数组参数的，就像指针一样
void foo3(char a3[3])
{
    int c3 = sizeof( a3 ); // c3 ==4
    cout<<"foo3(char a3[3])=sizeof(a3)="<<c3<<endl;

}
void foo4(char a4[])
{
    int c4 = sizeof( a4 ); // c4 ==4
    cout<<"foo4(char a4[])=sizeof(a4)="<<c4<<endl;
}
//char a[10]() char a[](){}都是不行的，没有这样的定义函数
//{
//    char b[10]="1212121"
    //return b;
//}

//有关结构体的
struct S1{
    
    int a;
    char c;

};
struct S2{
    char c;
    S1 s;
    char c2;
};
struct S3{

};
//联合体的
union U1{
    char a;
    int b;
};
union U2{
    char a;
    
};
union U3{
    char a;
    S1 s;
    int c;
    
};
union U4{

};
void main()
{

    /************************************************************************/
    /* (a++)-=(a++)
    带括号与不带括号是一样的*/
    /************************************************************************/
  //  int a=4;
//    cout<<((++a)-=(a++))<<endl;//0 ++a a-=a a++;
    //cout<<a;//1



/************************************************************************/
/* char int float long double 的sizeof(?)的大小                                                                    */
/************************************************************************/    
//    int a;
//    cout<<"sizeof(a)="<<sizeof(a)<<endl;//4
//    cout<<"sizeof(int)="<<sizeof(int)<<endl;//4
//    cout<<"sizeof(int b)="<<sizeof(int b)<<endl;//这样是不可以的
//    cout<<"sizeof(float,long,double,char)="<<sizeof(char)<<endl;//4,4,8,1



    /************************************************************************/
    /* 有关函数调用的sizeof(foo())的大小   sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用
    C99标准规定，函数、不能确定类型的表达式以及位域（bit-field）成员不能被计算sizeof值*/
    /************************************************************************/
//    size_t sz=sizeof(foo(3));
//    cout<<"sizeof(foo())="<<sz<<endl;//1但没有调用foo()函数
    //cout<<sizeof(void)<<endl;//这种是错误的


/************************************************************************/
/*有关函数参数指针时的sizeof及函数返回是指针类型的sizeof，还有void*funnn()的sizeof,其实都是数字的类型，结果是4                                                                      */
/************************************************************************/    
//    int a=10;
//    fun(&a);//4
//    cout<<"char *funn()=sizeof(funn())="<<sizeof(funn())<<endl;//4
//    cout<<"void *funnn()=sizeof(funnn())="<<sizeof(funnn())<<endl;//4



    /************************************************************************/
    /* 有关数组的sizeof   
    也许当你试图回答c4的值时已经意识到c3答错了，是的，c3!=3。这里函数参数a3已不再是数组类型，而是蜕变成指针，
    相当于char* a3，为什么仔细想想就不难明白，我们调用函数foo1时，程序会在栈上分配一个大小为3的数组吗不会！
    数组是“传址”的，调用者只需将实参的地址传递过去，所以a3自然为指针类型（char*），c3的值也就为4。*/
    /************************************************************************/
    //char a1[]="abc";
    //char a2[10]="abc";
    //int b1[3];
    //cout<<"a1[]=sizeof(a1)="<<sizeof a1<<endl;//4   字符末尾还存在一个NULL终止符
    //cout<<"a2[]=sizeof(a2)="<<sizeof a2<<endl;//10  最大只有10个，这个是包括了末尾的终止符
    //cout<<"b1[]=sizeof(b1)="<<sizeof b1<<endl;//12   （依赖于int）

    //foo3(a2);//4    
    //foo4(a2);//4



/************************************************************************/
/* 结构体的sizeof 
由于结构体的成员可以是复合类型，比如另外一个结构体，
所以在寻找最宽基本类型成员时，应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。
但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。     
 
   #pragma pack( n )，n为字节对齐数，其取值为1、2、4、8、16，默认是8，
如果这个值比结构体成员的sizeof值小，那么
该成员的偏移量应该以此值为准，即是说，结构体成员的偏移量应该取二者的最小值，
    
    还有一点要注意，“空结构体”（不含数据成员）的大小不为0，而是1。
    试想一个“不占空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢于是，
    “空结构体”变量也得被存储，这样编译器也就只能为其分配一个字节的空间用于占位了*/
/************************************************************************/
//S1 s;
//S1 ss={'a',4};
//cout<<"struct S1{}=sizeof(S1)="<<sizeof(S1)<<endl;//8 默认#pragma pack(n)n=8,由于int是4个字节，4<8，取最小=4,所以sizeof(S1)=4+4=8
//cout<<"struct S1{}=sizeof(S1)="<<sizeof(s)<<endl;//8 只与类型有关
//cout<<"struct S1{}=sizeof(S1)="<<sizeof(ss)<<endl;//8 只与类型有关
//cout<<"struct S2{}=sizeof(S2)="<<sizeof(S2)<<endl;//16 默认#pragma pack(n)n=8,由于S1中有个int int是4个字节，4<8，取最小=4,所以sizeof(S1)=4+8+4=16
//cout<<"struct S3{}=sizeof(S3)="<<sizeof(S3)<<endl;//1  还有一点要注意，“空结构体”（不含数据成员）的大小不为0，而是1。配一个字节的空间用于占位了
//cout<<sizeof(long double)<<endl;//8为了测试一下大于8的，但没有大于8.


/************************************************************************/
/*联合体的sizeof    
    结构体在内存组织上是顺序式的，联合体则是重叠式，各成员共享一段内存，所以整个联合体的sizeof也就是每个成员sizeof的最大值。
    结构体的成员也可以是复合类型，这里，复合类型成员是被作为整体考虑的。*/
/************************************************************************/
    cout<<"union U1=sizeof(U1)="<<sizeof U1<<endl;//4
    cout<<"union U2=sizeof(U2)="<<sizeof U2<<endl;//1
    cout<<"union U3=sizeof(U3)="<<sizeof U3<<endl;//8
    cout<<"union U4=sizeof(U4)="<<sizeof U4<<endl;//1

    //对\0 这个有点好奇。嘻嘻
    char p[]="a\n";
    cout<<sizeof p<<"  "<<strlen(p)<<endl;//3 2
    char p1[]="a\0n";
    cout<<sizeof p1<<"  "<<strlen(p1)<<endl;//4 1
    char p2[]="a+n";
    cout<<sizeof p2<<"  "<<strlen(p2)<<endl;//4 3

    char p3[]="a\\n";
    cout<<sizeof p3<<"  "<<strlen(p3)<<endl;//4 3
    char p4[]="a/n";
    cout<<sizeof p4<<"  "<<strlen(p4)<<endl;//4 3

}