编译时输出sizeof_C语言中 sizeof 运算的值是在编译时还是运

Ⅰ sizeof返回的值到底是什么

sizeof的用法是：sizeof(表达式)。

如果表达式是一个变量或常量，可以省略括号。否则，有括号、无括号的结果是不同的。作用是返回为表达式分配的字节数。

在本例中，s是字符数组，sizeof(s)返回6，说明为数组分配了6字节，你的理解是对的。

而在sizeof(s+2)中，s+2的结果是一个unsigned long long int类型的整数，sizeof返回的是为存储这种类型的整数需分配的字节数，在你的系统上，它就是8。

也就是说，sizeof(表达式)返回的值与表达式的结果的类型有关，另外唤岁sizeof返回的值本身的类型是unsigned long int的。

比如：

假设在一个系统上，int为4字节，long int为4字节，long long int为8字节，float为4字节，double为8字节。则，sizeof(1)返回4，sizeof(1L)返回8，sizeof(1LL)返回8。同时，sizeof(1+2)返回4，sizeof(1.0+2)返回8，而sizeof(1.0F+2)就会返回4。

下面是一个综合例子：

#include <stdio.h>

int main()

{

int a=1;

struct ss

{

int i;

char s[8];

}s1;

typedef ss s;

printf("%lu ",sizeof a);

printf("%lu "枝链衫,sizeof 1);

printf("%lu ",sizeof(a+1));

printf("%lu ",sizeof a+1);

printf("%lu ",sizeof(1+2));

printf("%lu ",sizeof 1+2);

printf("%lu ",sizeof(1));

printf("%lu ",sizeof s1);

printf("%lu ",sizeof(s));

printf("%lu ",sizeof((short)1));

printf("%lu ",sizeof(1L));

printf("猛腔%lu ",sizeof 1LL);

printf("%lu ",sizeof 1.0);

printf("%lu ",sizeof(1.0F));

printf("%lu ",sizeof 1.0d);

printf("%lu ",sizeof(1.0+2));

printf("%lu ",sizeof(1.0F+2));

printf("%lu ",sizeof(1.0d+2));

return 0;

}

Ⅱ c++中的sizeof是什么意思

sizeof()是C/C++中的一个操作符，其作用就是返厅冲回一个对象或者类型所占的内皮毁存字节数。

MSDN上的解释为：

The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type(including aggregate types). This keyword returns a value of type size_t.

其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一般定义为

typedefunsignedintsize_t;

在C99及以上标准中，sizeof(char)、sizeof(int)、sizeof(long)、sizeof(long long)、sizeof(float)、sizeof(double)、sizeof(long double)的值分别是1，4，4，8，4，8，16。

拓展资料：sizeof与strlen区别

strlen(char*)函数求的是字符串的实际长度，直到遇到第一个''，然后就返回计数值，且不包括''。

char aa[10];cout<<strlen(aa)<<endl; //结果是不定的，因为未初始化，''在内存中的位置不确定

char aa[10]={''}; 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为unsignedint类型。

该类型保证能容纳实现所建立的最大对象的字节大小。

2.sizeof是算符，strlen是函数。

3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''''结尾的。

sizeof还可以用函数做参数。

sizeof_网络

Ⅲ C语言中sizeof和strlen函式区别在哪

C语言中sizeof和strlen函式区别在哪？

一、sizeof
sizeof(...)是运算子，在标头档案中typedef为unsigned int，其值在编译时即计算好了，引数可以是阵列、指标、型别、物件、函式等。
它的功能是：获得保证能容纳实现所建立的最大物件的位元组大小。
由于在编译时计算，因此sizeof不能用来返回动态分配的记忆体空间的大小。实际上，用sizeof来返回型别以及静态分配的物件、结构或阵列所占的空间，返回值跟物件、结构、阵列所储存的内容没有关系。
具体而言，当引数分别如下时，sizeof返回的值表示的含义如下：
阵列——编译时分配的阵列空间大小；
指标——储存该指标所用的空间大小（储存该指标的地址的长度，是长整型，应该为4）；
型别——该型别所占的空间大小；
物件——物件的实际占用空间大小；
函式——函式的返回型别所占的空间大小。函式的返回型别不能是void。
二、strlen
strlen(...)是函式，要在执行时才能计算。引数必须是字符型指标（char*）。当阵列名作为引数传入时，实际上阵列就退化成指标了。
它的功能是：返回字串的长度。该字串可能是自己定义的，也可能是记忆体中随机的，该函式实际完成的功能是从代表该字串的第一个地址开始遍历，直到遇到结束符NULL。返回的长度大小不包括NULL；
1.sizeof操作符的结果型别是size_t，它在标头档案中typedef为unsigned int型别。
该型别保证能容纳实现所建立的最大物件的位元组大小。
2.sizeof是算符，猛毁strlen是函式。
3.sizeof可以用型别做引数，strlen只能用char*做引数，且必须是以''''结尾的。
sizeof还可以用函式做引数，比如：
short f();
printf("%d ", 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);
}

C语言中关于sizeof 和 strlen的区别分析

sizeof获得是所占的位元组数，所分配的空间的位元组数。
strlen获得是长度（实际字符的个数）。
例如： char a[5]="abc";
sizeof(a) 等于5，因为分配了5个位元组的空间。
而strlen(a)等于3，这是其实际字符的个数

c语言中lei与lei区别在哪?

你题目两个都是lei
没有区别的。
完全相同。

c语言中的sizeof和strenl的区别

sizeof 是占用实际空间的大小。这个对一个变数来说是固定不变的。
strlen 仅可以用在字串上，是统计到结束符的长度。
一般情况下 strlen必然会比sizeof小。不过这个也不是绝对的。

C语言中 memcmp 和 strcmp 函式有哪些区别

1、cmp 是 pare，比较的缩写。
2、strcmp是C语言中标头档案<string.h>（字串函式）中定义的一个用于对两组字串进行比较的函式，它的返回值是int型别。
假设有两组字串cs和ct，当cs<ct时，函式返回一个负数；当cs==ct时，函式返回0；当cs>ct时，函式返回一个正数。
即：两个字串自左向右逐个字符相比（按ASCII值大小相比较），直到出现不同的字符或遇''为止。如:"A"<"B" ，"a">"A" ，"puter">"pare" ，"put">"p"
strcmp函式原型为：int strcmp(const char *s1,const char * s2);

C语言中的sizeof和length怎么区别？

sizeof可以计算一个型别乃至一个结构的大小空间
length只是针对字串而言的
而且标准c里没有length这个函式
只有在C++中的string类中才有length这个函式

求C语言中strlen（）函式的原始码

unsigned int strlen(const char *s)
{
int len = 0;
while(*s++)
len++;
return len;
}

请问c语言中malloc函式和realloc的区别

1.malloc(n*sizeof(int)) /* 请求n个连续的、每个长度为整型的空间，若成功返回这些空间的首地址，失败返回0 */
2.realloc(p,sizeof(int)*n) /* 给一个已经分配了地址的指标重新分配空间,引数p为原有的空间地址*/

c语言中,void在函式括号内和在函式前面的区别.

void在函式括号内：该函式的引数为空，或者说该函式不带引数
void在函式前面：该函式返回值为空

Ⅳ C语言中sizeof的用法

sizeof是C/C++中的一个操作符（operator），作用就是返回一个对象或者类型所占的内存字节数。返回值类型为size_t，在头文件stddef.h中定义

这是一个依赖于编译系统的值，一般定义为typedef unsigned int size_t；编译器林林总总，但作为一个规范，都会保证char、signed

char和unsigned char的sizeof值为1，毕竟char是编程能用的最小数据类型。

MSDN上的解释为：

The sizeof keyword gives the amount of storage, in bytes, associated with avariable or a

type （including aggregate types）. This keyword returns a value of type

size_t.

2、语法：

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

1） sizeof（ object ）； // sizeof（对象）；

2） sizeof（ type_name ）； // sizeof（类型）；

3） sizeof object； // sizeof 对象；

所以一下三种sizeof的使用都是对的

复制代码代码如下:

#include

main（）

{

int b；

printf（"%dn",sizeof b）；

printf（"%dn",sizeof（b））；

printf（"%dn",sizeof（int））；

}

4、基本数据类型的sizeof

这里的基本数据类型指short、int、long、磨唯float、double这样的简单内置数据类型，由于它们都是和系

统相关的，所以在不同的系统下取值可能不同，这务必引起我们的注意，尽量不要在

这方面给自己程序的移植造成麻烦。一般的，在32位编译环境中，sizeof（int）的取值为4。

5、指针变量的sizeof

等于计算机内部地址总线的宽度。所以在32位计算机中，一个指针变量的返回值必定是4（注意结果是以

字节为单位），可以预计，在将来的64位系统中指针变量的sizeof结果为8。

指针变量的sizeof值与指针所指的对象没有任何关系，正是由于所有的指针变量所占内存大小相等，所以

MFC消息处理函数使用两个参数WPARAM、LPARAM就能传递各种复杂的消息结构（使用

指向结构体的指针）。

6、数组的sizeof

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

char a1[] = "abc"；

int a2[3]；

sizeof（ a1 ）； // 结果为4，字符末尾还存在瞎纤培一个NULL终止符

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

sizeof当作了求数组元素的个竖银数是不对的，求数组元素的个数有下面两种写法：int c1 = sizeof（ a1 ）

/ sizeof（ char ）； // 总长度/单个元素的长度

int c2 = sizeof（ a1 ） / sizeof（ a1[0] ）； // 总长度/第一个元素的长度。注意数组名做函数参数传递

时退化为指针。

7、结构体的sizeof

struct S1

{

char c；

int i；

}；

sizeof的结果等于对象或者类型所占的内存字节数，好吧，那就让我们来看看S1的内存分配情况：S1 s1

= { 'a', 0xFFFFFFFF }；s1的地址为0x0012FF78，其数据内容如下：

0012FF78: 61 CC CC CC FF FF FF FF中间夹杂了3个字节的CC看看MSDN上的说明：When applied to a

structure type or variable, sizeof returns the actual size, which may

include padding bytes ed for alignment.

这就是字节对齐！为什么需要字节对齐计算机组成原理教导我们这样有助于加快计算机的取数速度，否则

就得多花指令周期了。为此，编译器默认会对结构体进行处理（实际上其它地方的数

据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的`地址上，让宽度为4的基本

数据类型（int等）都位于能被4整除的地址上，以此类推。这样，两个数中间就可能

需要加入填充字节，所以整个结构体的sizeof值就增长了。

1、sizeof是运算符，跟加减乘除的性质其实是一样的，在编译的时候进行执行，而不是在运行时才执行。

那么如果编程中验证这一点呢?

复制代码代码如下:

#include

using namespace std；

int main（）

{

int i=1；

cout<

sizeof（++i）；

cout<

return 1；

}

输入结果为 1

1

sizeof 中的++i 的副作用并没有显示出来，原因只可能有一个，在编译的时候sizeof执行以后将++i 处理了，++i 的副作用因此被消除了。如果sizeof 是在运行时进行的话，则肯定要注意++i 。实际上sizeof的实现应该是用宏来做的，宏在编译时进行执行。具体实现可以参考下面。

2、sizeof（'a'）在C语言中的结果是4，在C++中结果是1，看过某篇文章说C中sizeof侧重于“数”，而C++中sizeof更侧重于“字符”。

3、文章中讲了两个用宏实现sizeof的经典应用

复制代码代码如下:

//适用于非数组

#define _sizeof（T）（（size_t）（（T*）0 + 1））

//适用于数组

#define array_sizeof（T）（（size_t）（&T+1）-（size_t）（&T））

先举两个小例子说明两个宏的应用，对于第一个如 _sizeof（int）；的结果就是4；对于第二个先声明一个大小为4的数组int a[4]；那么array_sizeof（a）结果为16.

对于非数组的宏定义，先是将0转换为T*类型的指针所指向的地址（此时地址为0）。然后对T类型的地址加1，相当于加上了T类型的大小（即得到了非数组T的大小）。前面的size_t只是将地址转化为int型的整数返回。

一个简单的例子：int* p； p=p+1； ——p是一个int*类型的指针， p+1在地址空间上相当于加上了4个字节。

对于数组的宏定义，类似于非数组的宏定义，为了方便理解，这里可以把数组T看成一个用户自定义的类型，&T表示数组类型的指针，对于数组类型指针加 1相当于在地址上加上了该数组大小。由于是用户自定义的类型所以不能强制将0转化为数组类型的地址，只能用加1后的地址减去之前的地址，得到的差值就是数组本身所占的字节大小。

拓展阅读：C语言变量理解

一、变量的概念

程序设计就是让计算机按照一定的指令来进行工作，可以说数据的处理是程序设计的主要任务。那么数据是怎么加入到计算机的内存中呢？计算机最初的功能就是能够存储数据并处理数据的机器。那么数据是怎么加入到计算机的内存中呢？在学习程序设计之前，很多学生对计算机的硬件设施都大概已经很熟悉了。计算机的硬件设施中有一个区域是用来存储数据的，计算机在工作的过程中会频繁的从这个区域读入和读出数据。要想让计算机按照某些指令（程序）自动工作，首先必须把数据存储到计算机的存储空间中。在某种计算机语言中实现这种数据存储功能的就是变量。变量就是计算机内存中的某一个存储单元。

二、变量的定义

C语言中变量在使用之前必须先对其进行定义，变量的定义的一般形式如下：【存储类别】数据类型变量名；其中存储类别是可以省略的。

1、存储类别计算机的内存一般分为三个部分：1）程序区；2）静态存储区；3）动态存储区；为了高效的发挥计算机的功能，不同类型的变量存放在不同的内存区域。变量的存储类别决定了变量中的数据在计算机内存中的存储位置。C语言中局部变量存放在动态存储区，全局变量或者静态变量存放在静态存储区。

2、数据类型在用程序处理问题之前，首先必须确定用何种方式描述问题中所涉及到的数据。这个问题在C语言中是由数据类型来决定的。变量的本质表现为在计算机中的存在时间和存储空间。变量的数据类型是用来决定变量在计算机中占用内存空间的大小。比如：整型数据在TC编译系统中占用两个字节的存储空间。C语言变量的类型不仅确定了数据在计算机内存中的存储区域的大小，同时确定了该数据能够参与的各种运算。任何一个C语言的变量必须有确定的数据类型，不管这个变量如何变化，变量的值都必须符合该变量数据类型的规定。

3、变量的名字通过以上介绍我们知道C语言中的变量就是计算机的某个存储单元，假设你给某个变量赋予了一个数值，对变量的处理其实就是对这个数据的处理。那么计算机是如何快速准确的找到这个数据呢？计算机的内存是以字节为单位进行划分的。每个存储单元都有自己的地址编号，就向宾馆中房间的房间号一样。计算机就是通过地址来准确的确定数据的存储位置。但是对于程序员特别是非专业计算机人士，如果用计算机内存地址记录数据是非常难操作的。

为了更好的掌控变量，C语言规定可以给每个变量其一个容易识别的名字。这个名字的命名规则遵循C语言的标识符命名规则。C语言的变量名的命名在遵循C语言标识符规则的前提下，原则上可以是任意长度字符的组合。但是目前很多的C语言编译系统只能识别前31个字符，如果两个变量的前31个字符相同，则编译系统会认为这两个变量时同一个变量。为了避免这种混淆的出现最好避免使用多余31个字符的变量名。变量的理解变量就是计算机中的某个存储单元。定义某个变量本质上就是向计算机申请一些存储区域。这个存储区域的大小由变量的数据类型决定，这个存储区域的位置有变量的存储类类别决定。给变量赋予某个数值，其实就是向该变量对应的存储单元读入数据，对变量的处理就是对这个存储单元中的数据的处理。并且这个存储单元中的数据在程序的运行期间是可以发生变化的。

Ⅳ c语言里：sizeof怎样用法

1、首先打开VS，新建一个使用sizeof求出数组的大小 project。

Ⅵ c语言sizeof函数

（1）sizeof不是函数，它只是一个操作符（operator）。

（2）sizeof的作用是返回一个对象或者类型所占的内存字节数，它的返回值的类型是size_t类型，而size_t是在头文件stddef.h中定义的。size_t 这是一个依赖于编译系统的值，一般定义为
“typedef unsigned int size_t;”，也就是无符余誉号整型。

（3）sizeof有三种语法形式，如下：
1) sizeof( object ); // sizeof( 对象 );
2) sizeof( type_name ); // sizeof( 类型 );
3) sizeof object; // sizeof 对象;
所以，

inti;
sizeof(i);//ok
sizeofi;//ok
sizeof(int);//ok
sizeofint;//error

既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，只用写法1就行了！

（4）说回你的提问，既然sizeof的返回值是unsigned int型，那么很明显可以用 %u 、%o 、%x 来输出，这三个都是无符号整型的格式符，分别对应十进制、八进制、十六进制。

（5）而%zd是修饰符z与有符号十进制整型格式符%d组合而成的格式符，表示按 size_t 的类型来输出。那么，肯定，%zd 可以用来输出 sizeof 的返回值。

（6）而%d是按有符号整型来输宏毁并出蔽迹数值，所以与unsigned int的表示范围是不一样的，如果 sizeof 的返回值超出了 %d 的表示范围的话，是会输出一个不正确的数值的。

总结一下：sizeof 的返回值可以用 %u 、 %o 、 %x 、 %zd 来正常输出，而用 %d 的时候需要注意返回值是否会超出 %d （即 signed int 型）的表示范围。

另外，有的操作系统或编译器里，size_t 的类型可能是 long unsigned int 型，所以输出 sizeof 的返回值的时候，应该用 %lu 等。

以上，如有帮助，烦请点采纳，谢谢！

Ⅶ C语言中 sizeof 运算的值是在编译时还是运

一、在 Pascal 语言中，sizeof() 是一种内存容量度量函数，功能是返回一个变量或者类型的大小（以字节为单位）；在 C 语言中，sizeof() 是一个判断数据类型或者表达式长度的运算符。在Pascal 语言与C语言中，对 sizeof() 的处理都是在编译阶段进行。

二、C语言中

判断数据类型长度符的关键字
用法
sizeof(类型说明符，数组名或表达式);
或sizeof (变量名);
定义
sizeof是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。
MSDN上的解释为：
The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type(including aggregate types). This keyword returns a value of type size_t.
其返回值类型为size_t，在头文件stddef.h中定义。这是一个依赖于编译系统的值，一般定义为
typedefunsignedintsize_t;
在C99及以上标准中，sizeof(char)、sizeof(int)、sizeof(long)、sizeof(long long)、sizeof(float)、sizeof(double)、sizeof(long double)的值分别是1，4，4，8，4，8，16。[1]
语法
sizeof有三种语法形式，如下：

sizeof(object);//sizeof(对象);
sizeof(type_name);//sizeof(类型);
sizeofobject;//sizeof对象;

所以，

```
inti;
sizeof(i);//ok
sizeofi;//ok
sizeof(int);//ok
sizeofint;//error
```
既然写法3可以用写法1代替，为求形式统一以及减少我们大脑的负担，第3种写法，忘掉它吧！实际上，sizeof计算对象的大小也是转换成对对象类型的计算，也就是说，同种类型的不同对象其sizeof值都是一致的。这里，对象可以进一步延伸至表达式，即sizeof可以对一个表达式求值，编译器根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。如：

sizeof(2);//2的类型为int，所以等价于sizeof(int);
sizeof(2+3.14);//3.14的类型为double，2也会被提升成double类型，所以等价于sizeof(double);

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

charfoo()
{
printf("foo()hasbeencalled.
");
return'a';
}
intmain()
{
size_tsz=sizeof(foo());
//foo()的返回值类型为char，所以sz=sizeof(char)，foo()并不会被调用
printf("sizeof(foo())=%d
",sz);
}

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

sizeof(foo);//error
voidfoo2(){}
sizeof(foo2());//error
structS
{
unsignedintf1:1;
unsignedintf2:5;
unsignedintf3:12;
};
sizeof(S.f1);//error

sizeof的常量性
sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用，如：
charary[sizeof(int)*10];//ok
最新的C99标准规定sizeof也可以在运行时刻进行计算，如下面的程序在Dev-C++中可以正确执行：[1]

intn;
n=10;//n动态赋值
charary[n];//C99也支持数组的动态定义
printf("%d
",sizeof(ary));//ok.输出10

但在没有完全实现C99标准的编译器中就行不通了，上面的代码在VC6中就通不过编译。所以我们最好还是认为sizeof是在编译期执行的，这样不会带来错误，让程序的可移植性强些。
基本数据类型的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，通常有下面两种写法：

intc1=sizeof(a1)/sizeof(char);//总长度/单个元素的长度char型
intc2=sizeof(a2)/sizeof(a2[0]);//总长度/第一个元素的长度int型

写到这里，提一问，下面的c3，c4值应该是多少呢

```
voidfoo3(chara3[3])
{
intc3=sizeof(a3);//c3==
}
voidfoo4(chara4[])
{
intc4=sizeof(a4);//c4==
}
```
也许当你试图回答c4的值时已经意识到c3答错了，是的，c3!=3。这里函数参数a3已不再是数组类型，而是蜕变成指针，相当于char* a3，为什么仔细想想就不难明白，我们调用函数foo3时，程序会在栈上分配一个大小为3的数组吗不会！数组是“传址”的，调用者只需将实参的地址传递过去，所以a3自然为指针类型（char*），c3的值也就为4。
结构体的sizeof
这是初学者问得最多的一个问题，所以这里有必要多费点笔墨。让我们先看一个结构体：
structS1{charc;inti;};
问sizeof(s1)等于多少聪明的你开始思考了，char占1个字节，int占4个字节，那么加起来就应该是5。是这样吗？你在你机器上试过了吗？也许你是对的，但很可能你是错的！VC6中按默认设置得到的结果为8。
我们来好好琢磨一下sizeof的定义——sizeof的结果等于对象或者类型所占的内存字节数，好吧，那就让我们来看看S1的内存分配情况：
S1 s1={'a',0xFFFFFFFF};
定义上面的变量后，加上断点，运行程序，观察s1所在的内存，你发现了什么
以我的VC6.0为例，s1的地址为0x0012FF78，其数据内容如下：
0012FF78: 61 CC CC CC FF FF FF FF
发现了什么怎么中间夹杂了3个字节的CC看看MSDN上的说明：
When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.
原来如此，这就是传说中的字节对齐啊！一个重要的话题出现了。
为什么需要字节对齐计算机组成原理教导我们这样有助于加快计算机的取数速度，否则就得多花指令周期了。为此，编译器默认会对结构体进行处理（实际上其它地方的数据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上，以此类推。这样，两个数中间就可能需要加入填充字节，所以整个结构体的sizeof值就增长了。
让我们交换一下S1中char与int的位置：
struct S2{inti;charc;};
看看sizeof(S2)的结果为多少，怎么还是8再看看内存，原来成员c后面仍然有3个填充字节，这又是为什么啊别着急，下面总结规律。
字节对齐的细节和编译器实现相关，但一般而言，满足三个准则：
1)结构体变量的首地址能够被其最宽基本类型成员的大小所整除；
2)结构体每个成员相对于结构体首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal padding）；
3)结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。
对于上面的准则，有几点需要说明：
1) 前面不是说结构体成员的地址是其大小的整数倍，怎么又说到偏移量了呢因为有了第1点存在，所以我们就可以只考虑成员的偏移量，这样思考起来简单。想想为什么。
结构体某个成员相对于结构体首地址的偏移量可以通过宏offsetof()来获得，这个宏也在stddef.h中定义，如下：
#define offsetof(s,m)(size_t)&(((s*)0)->m)
例如，想要获得S2中c的偏移量，方法为
size_tpos=offsetof(S2,c);//pos等于4
2) 基本类型是指前面提到的像char、short、int、float、double这样的内置数据类型，这里所说的“数据宽度”就是指其sizeof的大小。由于结构体的成员可以是复合类型，比如另外一个结构体，所以在寻找最宽基本类型成员时，应当包括复合类型成员的子成员，而不是把复合成员看成是一个整体。但在确定复合类型成员的偏移位置时则是将复合类型作为整体看待。
这里叙述起来有点拗口，思考起来也有点挠头，还是让我们看看例子吧（具体数值仍以VC6为例，以后不再说明）：
struct S3{charc1;S1s;charc2;};
S1的最宽简单成员的类型为int，S3在考虑最宽简单类型成员时是将S1“打散”看的，所以S3的最宽简单类型为int，这样，通过S3定义的变量，其存储空间首地址需要被4整除，整个sizeof(S3)的值也应该被4整除。
c1的偏移量为0，s的偏移量呢这时s是一个整体，它作为结构体变量也满足前面三个准则，所以其大小为8，偏移量为4，c1与s之间便需要3个填充字节，而c2与s之间就不需要了，所以c2的偏移量为12，算上c2的大小为13，13是不能被4整除的，这样末尾还得补上3个填充字节。最后得到sizeof(S3)的值为16。
通过上面的叙述，我们可以得到一个公式：
结构体的大小等于最后一个成员的偏移量加上其大小再加上末尾的填充字节数目，即：
```
sizeof(struct)=offsetof(lastitem)+sizeof(lastitem)+sizeof(trailingpadding);
```
到这里，朋友们应该对结构体的sizeof有了一个全新的认识，但不要高兴得太早，有一个影响sizeof的重要参量还未被提及，那便是编译器的pack指令。它是用来调整结构体对齐方式的，不同编译器名称和用法略有不同，VC6中通过#pragmapack实现，也可以直接修改/Zp编译开关。#pragma pack的基本用法为：
#pragmapack(n)，n为字节对齐数，其取值为1、2、4、8、16，默认是8，如果这个值比结构体成员的sizeof值小，那么，该成员的偏移量应该以此值为准，即是说，结构体成员的偏移量应该取二者的最小值，
公式如下：
offsetof(item)=min(n,sizeof(item))
再看示例：
```
#pragmapack(push)//将当前pack设置压栈保存
#pragmapack(2)//必须在结构体定义之前使用
structS1{charc;inti;};
structS3{charc1;S1s;charc2;};
#pragmapack(pop)//恢复先前的pack设置
```
计算sizeof(S1)时，min(2, sizeof(i))的值为2，所以i的偏移量为2，加上sizeof(i)等于6，能够被2整除，所以整个S1的大小为6。
同样，对于sizeof(S3)，s的偏移量为2，c2的偏移量为8，加上sizeof(c2)等于9，不能被2整除，添加一个填充字节，所以sizeof(S3)等于10。
如今，朋友们可以轻松的出一口气了，:)
还有一点要注意，“空结构体”（不含数据成员）的大小不为0，而是1。试想一个“不占空间”的变量如何被取地址、两个不同的“空结构体”变量又如何得以区分呢于是，“空结构体”变量也得被存储，这样编译器也就只能为其分配一个字节的空间用于占位了。如下：
struct S5 { }; sizeof( S5 ); // 结果为1含位域结构体的sizeof
前面已经说过，位域成员不能单独被取sizeof值，我们这里要讨论的是含有位域的结构体的sizeof，只是考虑到其特殊性而将其专门列了出来。
C99规定int、unsigned int和bool可以作为位域类型，但编译器几乎都对此作了扩展，允许其它类型类型的存在。使用位域的主要目的是压缩存储，其大致规则为：
1) 如果相邻位域字段的类型相同，且其位宽之和小于类型的sizeof大小，则后面的字段将紧邻前一个字段存储，直到不能容纳为止；
2) 如果相邻位域字段的类型相同，但其位宽之和大于类型的sizeof大小，则后面的字段将从新的存储单元开始，其偏移量为其类型大小的整数倍；
3) 如果相邻的位域字段的类型不同，则各编译器的具体实现有差异，VC6采取不压缩方式，Dev-C++采取压缩方式；
4) 如果位域字段之间穿插着非位域字段，则不进行压缩；
5) 整个结构体的总大小为最宽基本类型成员大小的整数倍。
还是让我们来看看例子。
示例1：
struct BF1{charf1:3;charf2:4;charf3:5;};
其内存布局为：
|_f1__|__f2__|_|____f3___|____|
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
0 3 7 8 1316
位域类型为char，第1个字节仅能容纳下f1和f2，所以f2被压缩到第1个字节中，而f3只
能从下一个字节开始。因此sizeof(BF1)的结果为2。
示例2：
structBF2{charf1:3;shortf2:4;charf3:5;};
由于相邻位域类型不同，在VC6中其sizeof为3，在Dev-C++中为2。
示例3：
structBF3{charf1:3;charf2;charf3:5;};
非位域字段穿插在其中，不会产生压缩，在VC6和Dev-C++中得到的大小均为3。
9.联合体的sizeof
结构体在内存组织上是顺序式的，联合体则是重叠式，各成员共享一段内存，所以整个联合体的sizeof也就是每个成员sizeof的最大值。结构体的成员也可以是复合类型，这里，复合类型成员是被作为整体考虑的。
所以，下面例子中，U的sizeof值等于sizeof(s)。
```
unionU
{
inti;
charc;
S1s;
};
```

sizeof还可以用函数做参数，比如：

shortf();
printf("%d
",sizeof(f()));

输出的结果是sizeof(short)，即2。

数组做sizeof的参数不退化，传递给strlen就退化为指针了。

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

charstr[20]="0123456789";
inta=strlen(str);//a=10;
intb=sizeof(str);//而b=20;

7.sizeof后如果是类型必须加括号，如果是变量名可以不加括号。这是因为sizeof是个操作符不是个函数。

8.当适用于一个结构类型时或变量， sizeof 返回实际的大小，当适用于静态的空间数组， sizeof 归还全部数组的尺寸。

sizeof 操作符不能返回被动态分派的数组或外部数组的尺寸

9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，

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型)长度,不包括''在内
说明：返回s的长度，不包括结束符NULL。
2.strlen只能用char*做参数，且必须是以''''结尾的，而sizeof可用类型做参数，还可用函数做参数，如：
int sum();
printf("%d ",sizeof(sum()));//输出的结果是sizeof(int)，即4。
数组做sizeof的参数不退化，传递给strlen就退化为指针了。
大部分编译程序,sizeof在编译时确定，因此sizeof(x)可以用来定义数组维数；而strlen要在运行时才能计算出来，用来计算字符串的长度，而不是类型占内存的大小；
char str[20]="0123456789";
int len1=strlen(str);//len1=10;
int len2=sizeof(str);//len2=20;
sizeof后，若为类型必须加括号，若为变量名可以不加括号。这是因为sizeof是个操作符不是个函数。
当适用于一个结构类型时或变量， sizeof 返回实际的大小；当适用一静态地空间数组，sizeof 归还全部数组的尺寸。
sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸；
数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，
如：
fun(char[8])
fun(char[])
都等价于 fun( char * )
在C++里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小，如果想在函数内知道数组的大小，需要这样做：
进入函数后用memcpy拷贝出来，长度由另一个形参传进去

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[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时，有一个很特别的情况，就是数组名到指针蜕变，
charArray[3]={'0'};
sizeof(Array)==3;
char*p=Array;
strlen(p)==1;//sizeof(p)结果为4
在传递一个数组名到一个函数中时，它会完全退化为一个指针
大部分编译程序在编译的时候就把sizeof计算过了是类型或是变量的长度
这就是sizeof(x)可以用来定义数组维数的原因

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

结果是 4 3 3 2

第三个例子
charszPath[MAX_PATH]
如果在函数内这样定义，那么sizeof(szPath)将会是MAX_PATH，但是将szPath作为虚参声明时
（voidfun(charszPath[MAX_PATH]))
sizeof(szPath) 却会是4(指针大小)
还有一位网友的说明也很好：
其实理解 sizeof 只需要抓住一个要点：栈
程序存储分布有三个区域：栈、静态和动态。能够从代码直接操作的对象，包括任何类型的变量、指针，都是在栈上的；动态和静态存储区是靠栈上的所有指针间接操作的。 sizeof 操作符，计算的是对象在栈上的投影体积；记住这个就很多东西都很清楚了。

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 一个被引用的对象的大小；所以

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 完全相同。

Ⅷ C语言中“SIZEOF（INT）“是什么意思有什么作用

sizeof()()顾名思义size
of
...某某的大小长度。如果是sizeof(int)那就意味着一个int型的长度。8位代表一个字节棚型长度，所以如果是一般使纤衫用的tc编译器(16位链竖猜的)那么sizeof(int)就等于2。

Ⅸ C语言中sizeof和strlen函数区别在哪

size of求变量占用的字节差雀返数，包括结束符\0
strlen求变量的长度但是不岁拍包虚饥括\0

导航:首页 > 源码编译 > 编译时输出sizeof

编译时输出sizeof