sizeof (1)

今天 帮一个同事调试他新写的一段代码， 说他只是正常的加了一个类。

然后对他进行初始化， 但是每次调用类的初始化之后，会发现原来的参数被变了，

而且程序老是crash.

 

一开始不知道 问题在哪里，请我帮忙 来看。

我先把类的初始化注释掉， 编译，执行没有问题， 正常。

 

那看起来应该是类的初始化有问题。

 

因为涉及到公司的保密， 所以简化如下，

class A { A(int a, int b):A_a(a),A_b(b) { load(); } public bool load() { //访问 数据库 ..... } private: int A_a, A_b; B b; }

 

因为 A的load里面， 他用了std::list的遍历， 但是是还是用的像原来的C语言的

std::list<>sl;

int len = sl.size();

std::list<>::iter bb=sl.begin;

for(int i=0;i<len;i++)

{

//其他的处理

....

  ++bb;

}

 

仔细看过，好像也没有问题啊。

 

再看这个类里面到底做了什么， 发现还有一个类B

 

简化如下　：

class B { B() { memset(weekly, 0,sizeof(weekly)*sizeof(int)); memset(weekly, 0,sizeof(monthly)*sizeof(int)); } private: int weekly[7]; int monthly[31]; }

 

当时只是简单看了一下，没有注意到

memset(weekly, 0,sizeof(weekly)*sizeof(int)); memset(monthly, 0,sizeof(monthly)*sizeof(int));

再仔细一下，发现好像不对， sizeof应该不是这样用的。

本身 sizeof已经代表了你所占用的空间大小了。

 

所以把再多乘的那个sizeof(int) 去掉， 再编译执行， 就没有问题了。

 

 

问题是解决了， 那就把 sizeof再复习一下吧：

 

sizeof有三种语法形式，如下：

　　1) sizeof( object ); // sizeof( 对象 ); 　　

      2) sizeof( type_name ); // sizeof( 类型 ); 　　

      3) sizeof object; // sizeof 对象;

 

sizeof也可以对一个函数调用求值，其结果是函数返回类型的大小，函数并不会被调用，我们来看一个完整的例子：

　　char foo() 　　{ 　　 printf("foo() has been called./n"); 　　 return 'a'; 　　 } 　　 int main() 　　{ 　　 size_t sz = sizeof( foo() ); // foo() 的返回值类型为char，所以sz = sizeof(char )，foo()并不会被调用 　　 printf("sizeof( foo() ) = %d/n", sz); 　　 } 

 

C99标准规定，函数、不能确定类型的表达式以及位域（bit-field）成员不能被计算sizeof值，即下面这些写法都是错误的：

sizeof( foo );// error 　　 void foo2() { } 　　 sizeof( foo2() );// error 　　 struct S 　　{ 　　 unsigned int f1 : 1; 　　 unsigned int f2 : 5; 　　 unsigned int f3 : 12; 　　}; 　　 sizeof( S.f1 );// error 　　 　　

 

3. sizeof的常量性 　　sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用，如： 　　char ary[ sizeof( int ) * 10 ]; // ok 　　最新的C99标准规定sizeof也可以在运行时刻进行计算，如下面的程序在Dev-C++ 中可以正确执行： 　　int n; 　　n = 10; // n动态赋值 　　char ary[n]; // C99也支持数组的动态定义 　　printf("%d/n", sizeof(ary)); // ok. 输出10

 

4. 基本数据类型的sizeof

　　这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型，由于它们都是和系统相关的，所以在不同的系统下取值可能不同，这务必引起我们的注意，尽量不要在这方面给自己程序的移植造成麻烦。 　　一般的，在32位编译环境中，sizeof(int)的取值为4。

 

5. 指针 变量的sizeof

　　学过数据结构 的你应该知道指针是一个很重要的概念，它记录了另一个对象的地址。既然是来存放地址的，那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中，一个指针变量的返回值必定是4（注意结果是以字节为单位），可以预计，在将来的64位 系统中指针变量的sizeof结果为8。

 

6. 数组的sizeof

　　数组的sizeof值等于数组所占用的内存字节数，如： 　　

char a1[] = "abc"; 　　

int a2[3]; 　　

sizeof( a1 ); // 结果为4，字符 末尾还存在一个NULL终止符 　　

sizeof( a2 ); // 结果为3*4=12（依赖于int） 　　

一些朋友刚开始时把sizeof当作了求数组元素的个数，现在，你应该知道这是不对的，那么应该怎么求数组元素的个数呢Easy，通常有下面两种写法： 　　

int c1 = sizeof( a1 ) / sizeof( int ); // 总长度/单个元素的长度 　　

int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长度/第一个元素的长度

 

 

7. 结构体的sizeof

　　这是初学者问得最多的一个问题，所以这里有必要多费点笔墨。让我们先看一个结构体： 　　

struct S1 　　{ 　　

char c; 　　

int i; 　　

}; 　　

问sizeof(s1)等于多少聪明的你开始思考了，char占1个字节，int占4个字节，那么加起来就应该是5。

是这样吗你在你机器上试过了吗也许你是对的，但很可能你是错的！VC6中按默认设置得到的结果为8。

 

 

与strlen区别
　　strlen(char*)函数求的是字符串的实际长度，它求得方法是从开始到遇到第一个'/0',如果你只定义没有给它赋初值，这个结果是不定的，它会从aa首地址一直找下去，直到遇到'/0'停止。 　　
char aa[10];cout<<strlen(aa)<<endl; //结果是不定的 　　
char aa[10]={'/0'};
cout<<strlen(aa)<<endl; //结果为0 　　
char aa[10]="jun";
cout<<strlen(aa)<<endl; //结果为3 　　
而sizeof()函数返回的是变量声明后所占的内存数，不是实际长度。 　　
sizeof(aa) 返回10 　　
int a[10];
sizeof(a) 返回40 　　
1.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned　int类型。 　　该类型保证能容纳实现所建立的最大对象的字节大小。 2.sizeof是算符，strlen是函数。 　　
3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''/0''结尾的。 　　
sizeof还可以用函数做参数，比如： 　　short f(); 　　
printf("%d/n", sizeof(f())); 　　输出的结果是sizeof(short)，即2。 　　
4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。 　　
5.大部分编译程序 在编译的时候就把sizeof计算过了是类型或是变量的长度这就是sizeof(x)可以用来定义数组维数的原因 　　char str[20]="0123456789"; 　　int a=strlen(str); //a=10; 　　int b=sizeof(str); //而b=20; 6.strlen的结果要在运行的时候才能计算出来，时用来计算字符串的长度，不是类型占内存的大小。 7.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。 　　
8.当适用于一个结构类型时或变量， sizeof 返回实际的大小， 　　当适用于静态的空间数组， sizeof 归还全部数组的尺寸。 　　
sizeof 操作符不能返回被动态分派的数组或外部数组的尺寸 　　
9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址， 　　
如： 　　fun(char [8]) 　　fun(char []) 　　都等价于 fun(char *) 　
　在C++里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小 　　
如果想在函数内知道数组的大小， 需要这样做： 　　
进入函数后用memcpy拷贝出来，长度由另一个形参传进去 　　
fun(unsiged char *p1, int len) 　　{ 　　
unsigned char* buf = new unsigned char[len+1] 　　
memcpy(buf, p1, len); 　　
} 　　

我们经常使用 sizeof 和 strlen 的场合，通常是计算字符串数组的长度 　　
看了上面的详细解释，发现两者的使用还是有区别的，从这个例子可以看得很清楚： 　　
char str[20]="0123456789"; 　　
int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度，以结束符 0x00 为字符串结束。 　
int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的数组 str[20] 所占的内存空间的大小，不受里面存储的内容改变。
　　上面是对静态数组处理的结果，如果是对指针，结果就不一样了 　　
char* ss = "0123456789"; 　　sizeof(ss) 结果 4 ===》ss是指向字符串常量的字符指针，sizeof 获得的是一个指针的之所占的空间,应该是 　　长整型的，所以是4 　　
sizeof(*ss) 结果 1 ===》*ss是第一个字符 其实就是获得了字符串的第一位'0' 所占的内存空间，是char类 　　型的，占了 1 位 　　
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度，则一定要使用 strlen 　　
sizeof返回对象所占用的字节大小. //正确 　　
strlen返回字符个数. //正确 　　
在使用sizeof时，有一个很特别的情况，就是数组名到指针蜕变， 　　
char Array[3] = {'0'}; 　　
sizeof(Array) == 3; 　　
char *p = Array; 　　
strlen(p) == 1;//sizeof(p)结果为4 　　

在传递一个数组名到一个函数中时，它会完全退化为一个指针 　　---------------------------------------------------------- 　　

看完以上你是否很清楚sizeof和strlen的区别了呢？还不明白的话，我们看下面几个例子： 　

　第一个例子 　
char* ss = "0123456789"; 　　
sizeof(ss) 结果 4 ===》ss是指向字符串常量的字符指针 　　
sizeof(*ss) 结果 1 ===》*ss是第一个字符 　　

大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度 　　
这就是sizeof(x)可以用来定义数组维数的原因 　　
char str[20]="0123456789"; 　　
int a=strlen(str); //a=10; 　　
int b=sizeof(str); //而b=20; 　　

大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度 　　
这就是sizeof(x)可以用来定义数组维数的原因 　

第二个例子
char str[20]="0123456789"; 　　
int a=strlen(str); //a=10; 　　
int b=sizeof(str); //而b=20; 　　
char ss[] = "0123456789"; 　　
sizeof(ss) 结果 11 ===》ss是数组，计算到/0位置，因此是10+1 　　
sizeof(*ss) 结果 1 ===》*ss是第一个字符 　　
char ss[100] = "0123456789"; 　　
sizeof(ss) 结果是100 ===》ss表示在内存中的大小 100×1 　　
strlen(ss) 结果是10 ===》strlen是个函数内部实现是用一个循环计算到/0为止之前 　　
int ss[100] = "0123456789"; 　　
sizeof(ss) 结果 400 ===》ss表示在内存中的大小 100×4 　　
strlen(ss) 错误 ===》strlen的参数只能是char* 且必须是以'/0'结尾的 　　
char q[]="abc"; 　　char p[]="a/n"; 　　
sizeof(q),sizeof(p),strlen(q),strlen(p); 　　结果是 4 3 3 2 　　

第三个例子 　　
char szPath[MAX_PATH] 　　
如果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，
但是将szPath作为虚参声明时（void fun(char szPath[MAX_PATH])）,sizeof(szPath)却会是4(指针大小) 　　
char szPath[MAX_PATH] 　　
如果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，
但是将szPath作为虚参声明时（void fun(char szPath[MAX_PATH])）,sizeof(szPath)却会是4(指针大小) 　　

还有一位网友的说明也很好： 　　其实理解 sizeof 只需要抓住一个要点：栈 　　程序存储分布有三个区域：栈、静态和动态。能够从代码直接操作的对象，包括任何类型的变量、指针，都是在栈上的；
动态和静态存储区是靠栈上的指所有针间接操作的。

sizeof 操作符，计算的是对象在栈上的投影体积；记住这个就很多东西都很清楚了。 　　

char const * static_string = "Hello"; 　　
sizeof(static_string) 是 sizeof 一个指针，所以在 32bit system 是 4 　　

char stack_string[] = "Hello"; 　　sizeof(stack_string) 是 sizeof 一个数组，所以是 6 * sizeof(char) 　　

char * string = new char[6]; 　　strncpy(string, "Hello", 6"); 　　sizeof(string) 是 sizeof 一个指针，所以还是 4。

和第一个不同的是，这个指针指向了动态存储区而不是静态存储区。 　

　不管指针指向的内容在什么地方，sizeof 得到的都是指针的栈大小 　　

C++ 中对引用的处理比较特殊；sizeof 一个引用得到的结果是 sizeof 一个被引用的对象的大小；

所以 　　
struct O 　　{ 　　
int a, b, c, d, e, f, g, h; 　　
}; 　　
int main() 　　{ 　　
O & r = *new O; 　　
cout << sizeof(O) << endl; // 32 　　
cout << sizeof r << endl; // 也是 32 　　
system("PAUSE"); 　　} 　　
r 引用的是整个的 O 对象而不是指向 O 的指针，所以 sizeof r 的结果和 sizeof O 完全相同。