sizeof 是判断数据类型长度符(字节数)的关键字。是一个操作符不是函数。
sizeof的用法:
sizeof(类型说明符,数组名或表达式);
或sizeof 变量名
sizeof定义
sizeof是C/C++中的一个操作符(operator),简单的说其作用就是返回一个对象或者类型所占的内存字节数。
基本数据类型的sizeof
这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型,由于它们都是和系统相关的,所以在不同的系统下取值可能不同,这务必引起我们的注意,尽量不要在这方面给自己程序的移植造成麻烦。
一般的,在32位编译环境中,sizeof(int)的取值为4。
指针变量的sizeof
学过数据结构的你应该知道指针是一个很重要的概念,它记录了另一个对象的地址。既然是来存放地址的,那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中,一个指针变量的返回值必定是4(注意结果是以字节为单位),但是,在64位系统中指针变量的sizeof结果为8。
char
*pc=
"abc"
;
int
*pi;
string *ps;
char
**ppc=&pc;
void
(*pf)();
//函数指针
sizeof
(pc);
//结果为4
sizeof
(pi);
//结果为4
sizeof
(ps);
//结果为4
sizeof
(ppc);
//结果为4
sizeof
(pf);
//结果为4
指针变量的sizeof值与指针所指的对象没有任何关系,正是由于所有的指针变量所占内存大小相等,所以MFC消息处理函数使用两个参数WPARAM、LPARAM就能传递各种复杂的消息结构(使用指向结构体的指针)。
数组的sizeof
数组的sizeof值等于数组所占用的内存字节数,如:
char a1[] = "abc"; int a2[3]; sizeof( a1 ); // 结果为4,字符末尾还存在一个NULL终止符 sizeof( a2 ); // 结果为3*4=12(依赖于int)
一些朋友刚开始时把sizeof当作了求数组元素的个数,如今你应该知道这是不对的,那么应该怎么求数组元素的个数呢Easy,通常有下面两种写法:
1
2
|
intc1= sizeof (a1)/ sizeof ( char ); //总长度/单个元素的长度
intc2= sizeof (a1)/ sizeof (a1[0]); //总长度/第一个元素的长度
|
写到这里,提一问,下面的c3,c4值应该是多少呢
1
2
3
4
5
6
7
8
|
voidfoo3(char a3[3])
{
int c3= sizeof (a3); //c3==
}
voidfoo4(char a4[])
{
int c4= sizeof (a4); //c4==
}
|
也许当你试图回答c4的值时已经意识到c3答错了,是的,c3!=3。这里函数参数a3已不再是数组类型,而是蜕变成指针,相当于char* a3,为什么仔细想想就不难明白,我们调用函数foo3时,程序会在栈上分配一个大小为3的数组吗不会!数组是“传址”的,调用者只需将实参的地址传递过去,所以a3自然为指针类型(char*),c3的值也就为4。
sizeof与strlen的区别
与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还可以用函数做参数,比如:
1
2
|
shortf();
printf ( "%d\n" , sizeof (f()));
|
输出的结果是sizeof(short),即2。
1
2
3
|
charstr[20]= "0123456789" ;
inta= strlen (str); //a=10;
intb= sizeof (str); //而b=20;
|
6.strlen的结果要在运行的时候才能计算出来,是用来计算字符串的长度,不是类型占内存的大小。
7.sizeof后如果是类型必须加括弧,如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
如:
1
|
fun( char [8])fun( char [])
|
都等价于 fun(char *)
特别注意:
1.sizeof是运算符,strlen是函数,具体如下:
sizeof
strlen
头文件:stddef.h格式:1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象
功能:一个对象或者类型所占的内存字节数;
说明:sizeof操作符的结果类型是size_t,typedef unsigned int size_t;
原型:extern unsigned int strlen(char *s);头文件:string.h
格式:strlen (字符数组名)
功能:计算字符串s的(unsigned int型)长度,不包括'\0'在内
说明:返回s的长度,不包括结束符NULL。
2.strlen只能用char*做参数,且必须是以''\0''结尾的,而sizeof可用类型做参数,还可用函数做参数,如:
1
2
|
intsum();
printf ( "%d\n" , sizeof (sum())); //输出的结果是sizeof(int),即4。
|
3.数组做sizeof的参数不退化,传递给strlen就退化为指针了。
4.大部分编译程序,sizeof在编译时确定,因此sizeof(x)可以用来定义数组维数;而strlen要在运行时才能计算出来,用来计算字符串的长度,而不是类型占内存的大小;
1
2
3
|
charstr[20]= "0123456789" ;
intlen1= strlen (str); //len1=10;
intlen2= sizeof (str); //len2=20;
|
5.sizeof后,若为类型必须加括弧,若为变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。
6.当适用于一个结构类型时或变量, sizeof 返回实际的大小;当适用一静态地空间数组,sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸;
7.数组作为参数传给函数时传的是指针而不是数组,传递的是数组的首地址,
如:
6.当适用于一个结构类型时或变量, sizeof 返回实际的大小;当适用一静态地空间数组,sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸;
7.数组作为参数传给函数时传的是指针而不是数组,传递的是数组的首地址,
如:
1
2
|
fun( char [8])
fun( char [])
|
都等价于 fun( char * )
在C++里参数传递数组永远都是传递指向数组首元素的指针,编译器不知道数组的大小,如果想在函数内知道数组的大小, 需要这样做:
进入函数后用memcpy拷贝出来,长度由另一个形参传进去
在C++里参数传递数组永远都是传递指向数组首元素的指针,编译器不知道数组的大小,如果想在函数内知道数组的大小, 需要这样做:
进入函数后用memcpy拷贝出来,长度由另一个形参传进去
1
2
3
4
5
|
fun(unsigedchar*p1,intlen)
{
unsignedchar*buf=newunsignedchar[len+1];
memcpy (buf,p1,len);
}
|
常在用到 sizeof 和 strlen 的时候,通常是计算字符串数组的长度,如果是对指针,结果则会不一样的:
char* str = "abacd";
sizeof(str) //结果 4 --->str是指向字符串常量的字符指针,sizeof 获得的是一个指针所占的空间,应该是长整型的,所以是4;
sizeof(*str) //结果 1 --->*str是第一个字符,其实就是字符串的第一位'a' 所占的内存空间,是char类型的,占了 1 位;
strlen(str)= 5 //--->若要获得这个字符串的长度,则一定要使用 strlen
char* str = "abacd";
sizeof(str) //结果 4 --->str是指向字符串常量的字符指针,sizeof 获得的是一个指针所占的空间,应该是长整型的,所以是4;
sizeof(*str) //结果 1 --->*str是第一个字符,其实就是字符串的第一位'a' 所占的内存空间,是char类型的,占了 1 位;
strlen(str)= 5 //--->若要获得这个字符串的长度,则一定要使用 strlen
如果想在函数内知道数组的大小, 需要这样做:
进入函数后用memcpy拷贝出来,长度由另一个形参传进去
1
2
3
4
5
|
fun(unsigedchar*p1,intlen)
{
unsignedchar*buf=newunsignedchar[len+1];
memcpy (buf,p1,len);
}
|
我们经常使用 sizeof 和 strlen 的场合,通常是计算字符串数组的长度
看了上面的详细解释,发现两者的使用还是有区别的,从这个例子可以看得很清楚:
1
|
charstr[20]= "0123456789" ;
|
int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度,以结束符 0x00 为字符串结束。
int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的数组str[20] 所占的内存空间的大小,不受里面存储的内容改变。
char* ss = "0123456789";
长整型的,所以是4
sizeof(*ss) 结果 1 ===》*ss是第一个字符其实就是获得了字符串的第一位'0' 所占的内存空间,是char类
型的,占了 1 个字节
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度,则一定要使用 strlen
sizeof返回对象所占用的字节大小. //正确
strlen返回字符个数. //正确
1
2
3
4
|
charArray[3]={ '0' };
sizeof (Array)==3;
char *p=Array;
strlen (p)==1; //sizeof(p)结果为4
|
----------------------------------------------------------
看完以上你是否很清楚sizeof和strlen的区别了呢?还不明白的话,我们看下面几个例子:
第一个例子
1
|
char *ss= "0123456789" ;
|
sizeof(ss) 结果 4 ===》ss是指向字符串常量的字符指针
sizeof(*ss) 结果 1 ===》*ss是第一个字符
大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度
这就是sizeof(x)可以用来定义数组维数的原因
1
2
3
|
charstr[20]= "0123456789" ;
inta= strlen (str); //a=10;
intb= sizeof (str); //而b=20;
|
大部分编译程序 在编译的时候就把sizeof计算过了 是类型或是变量的长度
这就是sizeof(x)可以用来定义数组维数的原因
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
charstr[20]= "0123456789" ;
inta= strlen (str); //a=10;
intb= sizeof (str); //而b=20;
charss[]= "0123456789" ;
sizeof (ss)结果11===》ss是数组,计算到\0位置,因此是10+1
sizeof (*ss)结果1===》*ss是第一个字符
charss[100]= "0123456789" ;
sizeof (ss)结果是100===》ss表示在内存中的大小100×1
strlen (ss)结果是10===》 strlen 是个函数内部实现是用一个循环计算到\0为止之前
intss[100]= "0123456789" ;
sizeof (ss)结果400===》ss表示在内存中的大小100×4
strlen (ss)错误===》 strlen 的参数只能是 char *且必须是以 '\0' 结尾的
charq[]= "abc" ;
charp[]= "a\n" ;
sizeof (q), sizeof (p), strlen (q), strlen (p);
|
结果是 4 3 3 2
第三个例子
1
|
charszPath[MAX_PATH]
|
如果在函数内这样定义,那么sizeof(szPath)将会是MAX_PATH,但是将szPath作为虚参声明时
1
|
(voidfun(charszPath[MAX_PATH]))
|
sizeof(szPath) 却会是4(指针大小)
还有一位网友的说明也很好:
其实理解 sizeof 只需要抓住一个要点:栈
程序存储分布有三个区域:栈、静态和动态。能够从代码直接操作的对象,包括任何类型的变量、指针,都是在栈上的;动态和静态存储区是靠栈上的所有指针间接操作的。 sizeof 操作符,计算的是对象在栈上的投影体积;记住这个就很多东西都很清楚了。
1
2
3
4
5
6
7
8
|
charconst*static_string= "Hello" ;
//sizeof(static_string)是sizeof一个指针,所以在32bitsystem是4
charstack_string[]= "Hello" ;
//sizeof(stack_string)是sizeof一个数组,所以是6*sizeof(char)
char *string=newchar[6];
strncpy (string, "Hello" ,6");
//sizeof(string)是sizeof一个指针,所以还是4。
//和第一个不同的是,这个指针指向了动态存储区而不是静态存储区。
|
不管指针指向的内容在什么地方,sizeof 得到的都是指针的栈大小
C++ 中对引用的处理比较特殊;sizeof 一个引用得到的结果是 sizeof 一个被引用的对象的大小;所以
1
2
3
4
5
6
7
8
9
10
11
|
structtest
{
inta,b,c,d,e,f,g,h;
};
intmain()
{
test&r=*newtest;
cout<< sizeof (test)<<endl; //32
cout<<sizeofr<<endl; //也是32
system ( "PAUSE" );
}
|
r 引用的是整个的 test 对象而不是指向 test 的指针,所以 sizeof r 的结果和 sizeof test 完全相同。