C语言sizeof的用法及注意事项

求普通变量的大小

#include <stdio.h>
int main()
{
    int a = 5;
    printf ("%d\n", sizeof(a));		//4 计算a所占空间的大小，单位是字节
    printf ("%d\n", sizeof (int));	//4 计算int类型的大小
    printf ("%d\n", sizeof a);		//4 可以省略括号，说明sizeof是一个操作符，不是函数
    return 0;
}

求数组的大小

#include <stdio.h>
int main()
{
    int arr[10]= { 0 };
	printf ("%d\n" , sizeof(arr));			//40，单位是字节
	printf ("%d\n", sizeof(int[10]));		//40， int[10]是arr数组的类型
    return 0;
}

特殊例子：

#include <stdio.h>
int main()
{
    short s =5;
    int a = 10;
    printf ( "%d \n", sizeof(s = a + 2));		//结果为：2
    printf ( "%d \n", s);			//结果为：5
	return 0;
}

解释：因为sizeof括号中的表达式是不参与运算的! 源文件在变成可执行文件过程中，经过预处理，编译，汇编，链接，sizeof在编译中就判断了s的大小，给出值为2，并且表达式不参与运算，而printf函数是在运行的时候再执行的，所以直接打印出2，和下面s变量的值5

sizeof计算指针

#include <stdio.h>
void test1(int arr[])
{
	printf("%d\n",sizeof(arr));		//	4/8	->	指针的大小
}
void test2(char ch[])
{
	printf("%d\n",sizeof(ch));		//	4/8	->	指针的大小
}
int main()
{
	int arr[10] = {0};
	char ch[10] = {0};
	printf("%d\n", sizeof(arr));	//40
	printf("%d\n", sizeof(ch));		//10
	test1(arr);
	test2(ch);
	return 0;
}

用sizeof求数组大小时要注意，当数组被当作参数传递过去时，传过去的是数组的首元素的地址，因为是地址，所以用指针来接收，所以函数里面用sizeof求的都是指针的大小，不是数组，32位平台下都是4字节，64位平台下都是8字节

strlen与sizeof的区别

strlen -函数：求字符串长度的，找’\0’之前出现的字符个数

sizeof -操作符：算变量/类型所占内存大小，单位是字节

sizeof的返回类型

#include <stdio.h>
int i; 		//i是全局变量，不初始化，默认是0
int main ()
{
    i--;		//-1
    if (i > sizeof(i)) 
    {
    	printf ( "> \n" );
    }
    else
    {
    	printf ("<\n");
    }
    return 0;
}

这个例子的输出结果是>，sizeof这个操作符，算出的结果的类型是unsigned int，因为大小是没有负数的，当进行 i > sizeof(i) 比较时，会把有符号的 i 算术转换为无符号，因为-1在内存中全1存储，变为无符号后原码补码一样，将会是一个很大的数，肯定比4字节大，所以输出>

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

前言

提示：以下是本篇文章正文内容，下面案例可供参考

一、sizeof常见的使用方法：

示例：
int a=10;

int arr=[1,2,3,4,5];

char str[]=“hello,c”; //这里面还有‘/0’大家不要忘记！！！

printf(“a=%d,arr=%d,str=%d\n”,a,arr,str)

结果是：a=4，arr=24，str=8

二、sizeof在数组的使用详解：

代码如下（示例）：

#include <stdio.h>
int main()
{
	int a[] = { 1,2,3,4 };
	printf("%d\n", sizeof(a));//16
	
	printf("%d\n", sizeof(a+0));
	// 4/8  a+0是第一个元素的地址  sizeof(a+0)计算地址大小
	
	printf("%d\n", sizeof(*a));
	//4  *a是数组第一个元素的，sizeof(*a)计算第一个元素大小
	
	printf("%d\n", sizeof(a+1)); 
	//4/8 a+1是第二个元素的地址，sizof(a+1)计算的是地址的大小
	printf("%d\n", sizeof(a[1]));
	//4 计算的的是第二个元素的大小

	printf("%d\n", sizeof(&a));
	//4/8 &a虽然数组的地址，但是也是地址，所以计算的是地址的大小
	
	printf("%d\n", sizeof(*&a));
	//16 &a——int(*p)[4]=&a;数组指针   *&可以理解为相互抵消了  
	//a单独放在sizeof中计算的是数组的大小

	printf("%d\n", sizeof(&a+1));
	//4/8  &a+1是数组后面空间的地址  是地址那么就是4/8
	
	printf("%d\n", sizeof(&a[0]));
	//4/8  &a[0]第一个元素地址
	
	printf("%d\n", sizeof(&a[0]+1));
	// 4/8  &a[0]+1第二个元素的地址 
	return 0;
}

总结

1.sizeof（数组名）——数组名表示整个数组，计算的是整个数组的大小。
2.&数组名——数组名表示整个数组，取出的也是整个数组的大小。
（除此之外所有的数组名都是数组首元素的的地址）

C语言数据类型

C语言中在使用一个变量前需要对变量进行声明，声明的同时要确定变量的数据类型。C语言中的数据类型有：

1. char、 short、 int、 long、 long long
2. float、double、long double
3. bool
4. 指针
5. 自定义类型
   其中，整型变量在内存中以二进制（补码）的形式存储，浮点型以编码的形式存储。所以整型数据可以直接使用加法器进行运算，而浮点型不可以直接使用加法器进行运算。

sizeof运算

1 、sizeof是C语言中的一个运算符，用来计算某个数据类型或某个变量在内存中占用的字节数（byte），如：

• sizeof(int); //sizeof(数据类型)
• sizeof(price); //sizeof(变量)
  在C语言中，对sizeof()的处理是在编译阶段完成的，即在编译结束后sizeof()的结果就已经确定了。

int a;
a = 6;
printf("sizeof(a) = %ld\n", sizeof(a++));
printf("sizeof(int) = %ld\n", sizeof(int));
printf("a = %ld\n", a);

运行结果：

sizeof(a) = 4
sizeof(int) = 4
a = 6

变量a的值并没有加1，那是因为sizeof(a++)在编译阶段就已经确定结果了，a++根本就没有执行。

2 、sizeof计算变量占用内存的大小其实是计算该变量数据类型的大小。即同种数据类型的不同变量，它们的sizeof值都是一致的。

int a,b;
a = 6;
b = 18;
printf("sizeof(a) = %ld\n", sizeof(a));
printf("sizeof(b) = %ld\n", sizeof(b));

运行结果：

sizeof(a) = 4
sizeof(b) = 4

3 、sizeof对一个表达式求值，编译器根据表达式的最终结果的数据类型来确定大小，但是一般不会对表达式进行计算。如：

printf("sizeof(a) = %ld\n", sizeof(a));
printf("sizeof(b + 0.3) = %ld\n", sizeof(b + 0.3));

运行结果：

sizeof(a) = 4
sizeof(b + 0.3) = 8

因为b + 0.3之后变成一个double数据类型，所以其大小为8个字节。

4 、sizeof也可以对一个被调函数求值，其结果是函数返回类型的大小，但函数并不会被真正调用，即函数不会被执行。

double add(int *temp)
{
    (*temp)++;
    return 0.5;
}

int main()
{
    int a,b;
    a = 6;
    b = 18;
    printf("sizeof(a) = %ld\n", sizeof(add(&a)));
    printf("a = %ld\n", a);
}

运行结果：

sizeof(a) = 8
a = 6

变量a的值并没有加1，那是因为函数根本就没有执行。且sizeof的计算大小是8，它是根据函数返回值类型double来计算大小的。

5 、sizeof()计算指针类型时，与指针所指向的对象没有关系，所有指针变量的大小都是一样的，所以很多形参都使用指针类型。

char*pc="abc";
int *pi;
double *ps;
char **ppc = &pc;
void(*pf)();//函数指针
printf("%ld\n", sizeof(pc));
printf("%ld\n", sizeof(pi));
printf("%ld\n", sizeof(ps));
printf("%ld\n", sizeof(ppc));
printf("%ld\n", sizeof(pf));

运行结果：

4
4
4
4
4

从结果可以看出指针变量占用内存都是一样的，与指向对象没有关系。

6 、sizeof()计算数组内存时，计算的是整个数组所占用的内存大小，与数组类型和数据长度等相关。

char a[] = "abc"; 
int  b[3]; 
printf("sizeof(a) = %ld\n", sizeof(a));
printf("sizeof(b) = %ld\n", sizeof(b));

运行结果：

sizeof(a) = 4
sizeof(b) = 12

字符数组a的大小之所以是4而不是3，原因在于数组末尾有个隐藏的停止符。数组b为整型数组，一个组员是4个字节，3个组员共占12个字节。

7、当数组作为函数形参时，数组会退化为指针，其占用的内存大小为一个指针的大小。

void foo3(char a3[])
{
printf("sizeof(a3) = %ld\n", sizeof(a3));
}
void foo4(int a4[])
{
printf("sizeof(a4) = %ld\n", sizeof(a4));
}

int main()
{
    char a[] = "abc"; 
    int  b[] = {1, 2, 3, 4}; 
    foo3(a);
    foo4(b);
}

运行结果：

sizeof(a3) = 4
sizeof(a4) = 4

8 、sizeof()计算结构体变量或类型的大小时，因为结构体存在数据对齐，所以其大小会因为结构体成员的顺序不同而不同。

typedef struct 
{
    char a[2]; 
    int  b[4];
    char c; 
} Data;

int main()
{
    Data test1;
    printf("sizeof(test1) = %ld\n", sizeof(test1)); 
}

运行结果：

sizeof(test1) = 24

因为结构体要以最宽的数据类型来对齐内存，结构体Data中，最宽的数据类型是int，所以所有数据都要按照int类型对齐。字符数组不足4个字节就按4个字节算，字符c不足4个字节也按4个字节算。所以总大小是6*4=24个字节。

当把字符变量c放到整型数组b上面时，结果又不相同，如下所示：

#include <stdio.h>
typedef struct 
{
    char a[2]; 
    char c; 
    int  b[4];
} Data;

int main()
{
    Data test1;
    printf("sizeof(test1) = %ld\n", sizeof(test1)); 
}

运行结果：

sizeof(test1) = 20

因为字符数组a和字符c总和都不到一个字节，所以两个变量作为一个整型来对齐，占4个字节。

9 、sizeof()计算共用体变量或类型的大小时，其大小与共用体变量宽度最大的成员的大小一致。

typedef union 
{
    char a[2]; 
    char c; 
    int  b[4];
} Data;

int main()
{
    Data test1;
    printf("sizeof(test1) = %ld\n", sizeof(test1)); 
}

运行结果：

sizeof(test1) = 16

在共用体Data中，宽度最宽的成员变量是整型数组a，占16个字节，所以共用体的占用内存也是16个字节。

10 、sizeof()表达式可以作为常量使用，以下语句是合法的：

char ary[sizeof(int)*10];

11 、sizeof()计算的是变量的实际内存大小而不是变量的长度，但是常被用来计算数组变量的长度，如下所示：

int a[] = {4, 6, 9, 19, 20};
printf("length of a is = %ld\n", sizeof(a) / sizeof(a[0])); 

运行结果：

length of a is = 5