sizeof用法总结
sizeof 函数
sizeof 函数sizeof函数是C语言中的一个运算符，用于获取变量或数据类型所占用的内存空间大小。
在C语言中，sizeof函数的返回值是一个无符号整数，表示所占用的字节数。
本文将从sizeof函数的用法、计算方法、注意事项等方面进行详细介绍。
一、sizeof函数的用法sizeof函数的用法非常简单，可以用于获取变量或数据类型所占用的内存空间大小。
其语法格式如下：sizeof(表达式)其中，表达式可以是变量、常量、数据类型等。
二、sizeof函数的计算方法sizeof函数的计算方法是根据数据类型来确定所占用的字节数。
不同的数据类型在内存中占用的空间大小是固定的，因此sizeof函数可以根据数据类型来返回相应的字节数。
例如，sizeof(char)返回的是1，因为char类型占用1个字节；sizeof(int)返回的是4，因为int类型占用4个字节；sizeof(float)返回的是4，因为float类型占用4个字节；sizeof(double)返回的是8，因为double类型占用8个字节。
需要注意的是，sizeof函数返回的是字节数，而不是位数。
一个字节等于8个位，所以sizeof函数返回的结果可以用来判断数据类型的位数。
三、sizeof函数的注意事项1. sizeof函数只能用于静态类型，不能用于动态类型。
也就是说，sizeof函数不能用于动态分配的内存，比如指针指向的内存空间。
2. sizeof函数不能直接用于函数、数组和void类型。
对于函数和void类型，可以使用指针来获取其所占用的内存空间大小；对于数组，可以使用sizeof(数组名)来获取数组的总大小。
3. sizeof函数的结果是一个常量表达式，在编译时就能得到结果，因此sizeof函数的参数不会被执行。
4. sizeof函数返回的结果是一个无符号整数，可以用%lu或%zu格式输出。
四、sizeof函数的应用举例1. 获取变量的大小```cint num;size_t size = sizeof(num);printf("变量num的大小为：%zu\n", size);```2. 获取数据类型的大小```csize_t size1 = sizeof(char);size_t size2 = sizeof(int);size_t size3 = sizeof(float);size_t size4 = sizeof(double);printf("char类型的大小为：%zu\n", size1);printf("int类型的大小为：%zu\n", size2);printf("float类型的大小为：%zu\n", size3);printf("double类型的大小为：%zu\n", size4);```3. 获取数组的大小```cint arr[10];size_t size = sizeof(arr);printf("数组arr的大小为：%zu\n", size);```5. 获取指针所指向的类型的大小```cint* ptr;size_t size = sizeof(*ptr);printf("指针ptr所指向的类型的大小为：%zu\n", size);```五、总结sizeof函数是C语言中用于获取变量或数据类型所占用的内存空间大小的一个非常实用的运算符。
sizeof的用法
sizeof的用法在C语言中，sizeof是一种用于计算数据类型或变量所占用空间大小的运算符。
它可以用于计算任何数据类型或变量的大小，包括基本数据类型、数组、结构体等。
sizeof的用法非常灵活，下面我们将详细介绍它的用法和注意事项。
1. 基本数据类型的大小首先，我们来看一下基本数据类型的大小。
在C语言中，基本数据类型有char、int、float、double等。
我们可以使用sizeof运算符来计算它们的大小，例如：```printf('char类型的大小为：%d', sizeof(char));printf('int类型的大小为：%d', sizeof(int));printf('float类型的大小为：%d', sizeof(float));printf('double类型的大小为：%d', sizeof(double));```输出结果为：```char类型的大小为：1int类型的大小为：4float类型的大小为：4double类型的大小为：8```从输出结果可以看出，char类型占用1个字节，int和float类型占用4个字节，而double类型占用8个字节。
这是因为不同的数据类型在内存中占用的空间大小是不同的。
需要注意的是，sizeof返回的是一个无符号整数，因此在使用printf函数输出时需要使用%u格式符，而不是%d格式符。
2. 数组的大小接下来，我们来看一下数组的大小。
在C语言中，数组的大小等于数组元素的个数乘以每个元素的大小。
我们可以使用sizeof运算符来计算数组的大小，例如：```int a[5] = {1, 2, 3, 4, 5};printf('数组a的大小为：%u', sizeof(a));```输出结果为：```数组a的大小为：20```从输出结果可以看出，数组a的大小为20个字节，即5个int 类型的元素，每个元素占用4个字节。
sizeof用法
sizeof用法sizeof是C/C++语言中非常常用的一个操作符，用于计算数据类型或变量在内存中所占的字节数。
本文将从使用方法、注意事项、应用场景等方面进行详细讲解。
1.使用方法sizeof操作符有两种用法：（1）计算数据类型在内存中所占的字节数语法：sizeof(数据类型)例子：sizeof(int)（2）计算变量在内存中所占的字节数语法：sizeof(变量名)例子：int a; sizeof(a)2.注意事项（1）sizeof操作符计算的字节数只与数据类型相关，与具体的实现相关性较小。
（2）对于数组，sizeof计算的是整个数组所占的字节数，而不是指向数组首元素的指针所占的字节数。
（3）对于指针，sizeof计算的是指针本身所占的字节数，而不是指针指向对象所占的字节数。
（4）通过结构体、共用体等数据类型可以自定义复合类型，sizeof计算的是整个数据类型所占的字节数。
（5）sizeof操作符是在编译时计算，不会对程序运行造成任何影响。
3.应用场景（1）动态内存分配在进行动态内存分配时，需要根据数据类型的大小决定分配的内存空间大小。
使用sizeof操作符可以方便地获取数据类型的大小，从而确定需要分配的内存大小。
（2）指针运算对指针进行加减运算时需要知道指针指向对象的大小，从而确定加减的偏移量。
使用sizeof操作符可以获取指针指向对象的大小。
（3）复合类型处理在处理复合类型数据时，需要知道整个数据类型所占的字节数，从而方便进行内存分配、指针运算等操作。
使用sizeof操作符可以获取复合类型数据的大小。
（4）调试和分析在进行程序调试和性能分析时，需要了解数据类型在内存中的存储情况，使用sizeof操作符可以获取数据类型在内存中所占的字节数，进而方便进行调试和分析。
总之，sizeof操作符是C/C++语言中非常重要的操作符，在程序开发、调试和分析中都具有重要作用。
需要注意的是，在使用sizeof操作符时需要注意相关的注意事项，才能正确无误地进行操作。
c语言的sizeof函数
c语言的sizeof函数sizeof函数是C语言中常用的一个操作符，用于返回一些变量或类型的大小，单位为字节。
它是一个编译时运算符，返回值是一个常量表达式，不需要运行时计算。
sizeof操作符可以用于任何数据类型，并且也可以用于结构体、联合体、数组等复杂类型。
本文将详细介绍sizeof函数的功能、用法和实例，以帮助读者更好地理解和使用它。
1. sizeof函数的功能sizeof函数的主要功能是返回操作数的大小，即占用的字节数。
它可以用于以下方面：a) 检查变量的大小：可以用sizeof函数来检查不同类型的变量所占用的内存大小。
例如，可以使用sizeof(int)来获取int类型变量的大小。
b) 计算数组的大小：可以使用sizeof函数来计算数组的大小。
例如，可以使用sizeof(array)来获取array数组的大小。
c) 计算结构体、联合体的大小：可以使用sizeof函数来计算结构体或联合体所占用的内存大小。
例如，可以使用sizeof(struct MyStruct)来获取MyStruct结构体的大小。
d) 动态内存分配：可以使用sizeof函数来确定在动态内存分配中所需的内存大小。
例如，可以使用sizeof(int) * n来为n个整数分配内存。
2. sizeof函数的用法sizeof函数的基本用法为sizeof(操作数)。
其中，操作数可以是以下类型：a) 数据类型：可以直接使用sizeof(数据类型)来获取该类型变量的大小。
例如，sizeof(int)。
b) 变量名：可以使用sizeof(变量名)来获取该变量所占用的内存大小。
例如，sizeof(num)。
c) 表达式：可以使用sizeof(表达式)来获取表达式的结果所占用的内存大小。
例如，sizeof(a + b)。
d) 指针：可以使用sizeof(指针变量)来获取指针变量所占用的内存大小，而不是它指向的对象的大小。
例如，sizeof(ptr)。
sizeof函数用法
sizeof函数用法sizeof是C语言中的一个运算符，用来计算一个类型或变量的字节大小。
它的运算结果是一个整数值，表示给定类型或变量所占的字节数。
sizeof有两种常见的使用方式：作用于数据类型和作用于变量。
一、作用于数据类型：sizeof可以用于返回指定数据类型所占的字节数。
通过这种方式，可以在编程中动态地获取类型的大小，避免了手动计算的错误。
sizeof的语法如下：sizeof(type)其中，type表示要计算大小的数据类型。
例如，以下代码可以计算int类型的字节大小：```#include <stdio.h>int main() {int size = sizeof(int);printf("int类型的字节大小为：%d\n", size);return 0;}```运行结果：```int类型的字节大小为：4```在不同的编译环境下，相同的数据类型的大小可能会有所不同。
在C语言中，使用sizeof运算符来动态地获取类型的大小可以提高代码的可移植性。
二、作用于变量：sizeof也可以用于返回给定变量所占的字节数。
通过这种方式，可以在运行时获取变量所占的内存空间大小。
sizeof的语法如下：sizeof(variable)其中，variable表示要计算大小的变量。
例如，以下代码可以计算数组和结构体实例的字节大小：```#include <stdio.h>int main() {int array[10];int size = sizeof(array);printf("数组array的字节大小为：%d\n", size);struct {int a;char b;double c;} s;size = sizeof(s);printf("结构体s的字节大小为：%d\n", size);return 0;}```运行结果：```数组array的字节大小为：40结构体s的字节大小为：24```可以看到，sizeof还可以用来计算数组和结构体的字节大小。
sizeof（）的用法
sizeof（）的⽤法1. 定义sizeof 是⼀个操作符 operator，不是⼀个函数，其作⽤是返回⼀个对象或类型所占的内存字节数---------------------------------------------------------------------------------------------------------2. 语法sizeof object; //sizeof 对象sizeof(object);sizeof(type_name); // 例如 sizeof(int)对象 object 可以是各种类型的变量，以及表达式（⼀般sizeof不会对表达式进⾏计算）；sizeof对对象求内存⼤⼩，最终都是转化为对对象的数据类型进⾏求值；sizeof(表达式) 值为表达式的最终结果的数据类型的⼤⼩int i;sizeof(int); //值为4sizeof(i); //值为4，等价于sizeof(int)sizeof i; //值为4sizeof(2); //值为4，等价于sizeof(int)，因为2的类型为intsizeof(2 + 3.14); //值为8，等价于sizeof(double)，因为此表达式的结果的类型为doublechar ary[sizeof(int) * 10]; //OK，编译⽆误---------------------------------------------------------------------------------------------------------3. 基本数据类型的sizeof基本数据类型如int short long char double等，其内存⼤⼩与系统有关。
32位系统的int(4 Bytes), short(2 Bytes), long(4 Bytes), char(1 Bytes), double(8 Bytes), float(4 Bytes)4. 结构体的sizeof结构体的sizeof涉及到字节对齐问题，字节对齐有助于加快计算机的存取速度，减⼩指令周期。
sizeof在c语言中的用法 (2)
sizeof在c语言中的用法一、sizeof在C语言中的用法简介在C语言中，sizeof是一个用来获取数据类型或变量在内存中所占字节数的运算符。
它返回一个无符号整数值，表示所给参数的大小。
sizeof可以用于各种数据类型，包括基本数据类型（如int、float等）、指针、数组和结构体等。
二、sizeof用法详解1. 获取基本数据类型的大小使用sizeof运算符可以获取C语言中各种基本数据类型的大小。
例如，sizeof(int)将返回该机器上int类型所占的字节数。
这对于编写可移植性强的代码非常有用。
2. 获取数组大小通过使用sizeof运算符，可以获取数组在内存中所占空间的大小。
例如，如果有一个整型数组arr，则sizeof(arr)将返回该数组所占的总字节数。
3. 获取指针变量的大小当使用sizeof运算符计算指针变量时，它将返回指针变量本身所占空间的大小，并不会计算指针所引用对象的大小。
这是因为指针只是一个地址值，在32位操作系统上通常占用4个字节，在64位操作系统上通常占用8个字节。
4. 获取结构体大小通过使用sizeof运算符，可以获取结构体在内存中所占空间的大小。
结构体由多个字段组成，而每个字段又可以是不同的数据类型。
sizeof(struct_name)将返回该结构体所占的总字节数。
5. 计算变量的大小sizeof运算符可以用于计算变量在内存中所占空间的大小。
例如，sizeof(variable)将返回变量所占的字节数。
这在动态分配内存或者进行数据传输时非常有用。
6. 获取字符串长度使用sizeof运算符可以获取字符串（字符数组）在内存中所占空间的大小，包括末尾的空字符'\0'。
例如，如果有一个字符数组str，则sizeof(str)将返回该数组所占空间的总字节数。
7. 特殊情况注意事项在使用sizeof运算符时需要特别注意一些情况。
首先，在计算指针变量时，需要明确指针类型，因为不同类型的指针在不同平台上可能占用不同大小的空间。
sizeof（）的使用及各种数据类型的字节大小
sizeof（）的使⽤及各种数据类型的字节⼤⼩1、什么是sizeof ⾸先看⼀下sizeof在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. 看到return这个字眼，是不是想到了函数？错了，sizeof不是⼀个函数，你见过给⼀个函数传参数，⽽不加括号的吗？sizeof可以，所以sizeof不是函数。
⽹上有⼈说sizeof是⼀元操作符，但是我并不这么认为，因为sizeof更像⼀个特殊的宏，它是在编译阶段求值的。
举个例⼦：cout<<sizeof(int)<<endl; // 32位机上int长度为4cout<<sizeof(1==2)<<endl; // == 操作符返回bool类型，相当于 cout<<sizeof(bool)<<endl; 在编译阶段已经被翻译为：cout<<4<<endl;cout<<1<<endl; 这⾥有个陷阱，看下⾯的程序：int a = 0;cout<<sizeof(a=3)<<endl;cout<<a<<endl; 输出为什么是4，0⽽不是期望中的4，3？？？就在于sizeof在编译阶段处理的特性。
由于sizeof不能被编译成机器码，所以sizeof作⽤范围内，也就是()⾥⾯的内容也不能被编译，⽽是被替换成类型。
=操作符返回左操作数的类型，所以a=3相当于int，⽽代码也被替换为：int a = 0;cout<<4<<endl;cout<<a<<endl; 所以，sizeof是不可能⽀持链式表达式的，这也是和⼀元操作符不⼀样的地⽅。
sizeof函数用法
sizeof函数用法摘要：一、sizeof 函数简介1.sizeof 函数的作用2.数据类型长度3.函数原型二、sizeof 函数用法1.用法一：计算数组大小2.用法二：计算字符串长度3.用法三：计算结构体大小4.用法四：计算联合体大小5.用法五：计算枚举类型大小三、sizeof 函数注意事项1.不可用于判断数组越界2.不可用于判断字符串结束符3.结果与编译器相关正文：sizeof 函数是C 语言中一个非常常用的函数，它的主要作用是计算数据类型的大小。
在计算机中，每个数据类型都有其固定的长度，比如int 类型通常是4 字节，char 类型通常是1 字节。
sizeof 函数就是用来获取这些数据类型的大小的。
sizeof 函数的原型为：`size_t sizeof(类型名)`。
其中，`size_t`是一个与平台相关的类型，表示数据类型的大小。
在32 位系统中，`size_t`通常是`int`类型，而在64 位系统中，`size_t`通常是`long`类型。
sizeof 函数的用法有很多，下面我们来详细了解一下：1.用法一：计算数组大小当我们需要知道数组的大小时，可以使用sizeof 函数。
比如，有一个字符数组`char arr[10]`，我们可以使用`sizeof(arr)`来计算数组的大小。
需要注意的是，这里计算的是数组本身的大小，而不是数组中元素的大小。
2.用法二：计算字符串长度在C 语言中，字符串是以字符数组的形式存储的，通常会在字符串的结尾加上一个空字符（"0"）作为字符串的结束标志。
当我们需要知道字符串的长度时，可以使用sizeof 函数。
比如，有一个字符串`char str[] = "hello"`，我们可以使用`sizeof(str) - 1`来计算字符串的长度。
注意要减去1，因为空字符不计入字符串长度。
3.用法三：计算结构体大小当我们需要知道结构体的大小时，可以使用sizeof 函数。
详细解析sizeof()
一、sizeof的概念sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等。
它并不是函数。
sizeof操作符以字节形式给出了其操作数的存储大小。
操作数可以是一个表达式或括在括号内的类型名。
操作数的存储大小由操作数的类型决定。
二、sizeof的使用方法1、用于数据类型sizeof使用形式：sizeof（type）数据类型必须用括号括住。
如sizeof（int）。
2、用于变量sizeof使用形式：sizeof（var_name）或sizeof var_name变量名可以不用括号括住。
如sizeof (var_name)，sizeof var_name等都是正确形式。
带括号的用法更普遍，大多数程序员采用这种形式。
注意：sizeof操作符不能用于函数类型，不完全类型或位字段。
不完全类型指具有未知存储大小的数据类型，如未知存储大小的数组类型、未知内容的结构或联合类型、void类型等。
如sizeof(max)若此时变量max定义为int max(),sizeof(char_v) 若此时char_v定义为char char_v [MAX]且MAX未知，sizeof(void)都不是正确形式。
三、sizeof的结果sizeof操作符的结果类型是size_t，它在头文件中typedef为unsignedint类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
1、若操作数具有类型char、unsigned char或signed char，其结果等于1。
ANSI C正式规定字符类型为1字节。
2、int、unsigned int 、short int、unsigned short 、long int 、unsigned long 、float、double、long double类型的sizeof 在ANSI C中没有具体规定，大小依赖于实现，一般可能分别为2、2、2、2、4、4、4、8、10。
sizeof在c++中用法
sizeof在c++中用法
（实用版）
目录
1.sizeof 的定义与作用
2.sizeof 的基本语法
3.sizeof 的运算规则
4.sizeof 的应用示例
正文
【1.sizeof 的定义与作用】
sizeof 是 C++语言中用于获取数据类型或变量大小的关键字，它返回的是一个整数值，表示数据类型或变量在内存中所占用的字节数。
在程序设计中，了解数据类型或变量的大小对于优化程序性能、避免内存浪费和处理数据时非常必要的。
【2.sizeof 的基本语法】
sizeof 的基本语法如下：
```
sizeof(数据类型或变量);
```
其中，数据类型或变量可以是基本数据类型如 int、float，也可以是复合数据类型如数组、结构体、联合体等。
【3.sizeof 的运算规则】
1.对于基本数据类型，sizeof 返回的值等于该数据类型的大小，如int 为 4，float 为 4，double 为 8。
2.对于复合数据类型，sizeof 返回的值等于该数据类型所占用的最大内存空间。
例如，数组返回的是数组所占用的总空间大小，结构体返回的是结构体所占用的最大空间大小。
3.对于指针类型，sizeof 返回的值等于指针的大小，通常为 4（32 位系统）或 8（64 位系统）。
4.对于数组，sizeof 返回的是数组所占用的总空间大小，而不是数组中元素的大小。
5.对于函数返回值类型，sizeof 返回的是函数返回值所占用的字节数。
sizeof的使用方法
学过数据结构的你应该知道指针是一个很重要的概念，它记录了另一个对象的地址。既
然是来存放地址的，那么它当然等于计算机内部地址总线的宽度。所以在32位计算机中
，一个指针变量的返回值必定是4（注意结果是以字节为单位），可以预计，在将来的6
4位系统中指针变量的sizeof结果为8。
性强些。
4. 基本数据类型的sizeof
这里的基本数据类型指short、int、long、float、double这样的简单内置数据类型，
由于它们都是和系统相关的，所以在不同的系统下取值可能不同，这务必引起我们的注
意，尽量不要在这方面给自己程序的移植造成麻烦。
一般的，在32位编译环境中，sizeof(int)的取值为4。
sizeof是C语言的一种单目操作符，如C语言的其他操作符++、--等。它并不是函数。sizeof操作符以字节形式给出了其操作数的存储大小。操作数可以是一个表达式或括在括号内的类型名。操作数的存储大小由操作数的类型决定。
二、sizeof的使用方法
1、用于数据类型
sizeof使用形式：sizeof（type）
2、int、unsigned int 、short int、unsigned short 、long int 、unsigned long 、float、double、long double 类型的sizeof 在ANSI C中没有具体规定，大小依赖于实现，一般可能分别为2、2、2、2、4、4、4、8、10。
};
sizeof( S.f1 );// error
3. sizeof的常量性
sizeof的计算发生在编译时刻，所以它可以被当作常量表达式使用，如：
c语言中sizeof的用法
c语言中sizeof的用法1. sizeof（）函数是C语言中最常用的一个内置（built-in）函数，它可以获取指定变量或者类型的大小，单位是字节（byte）。
这个函数可以用在任何表达式中，可以通过把函数放入括号中可以获得其结果，比如：a = sizeof (int);2. sizeof()函数可以获取宏定义（macro definition）、数据类型、结构体（struct）和数组的大小，比如：#define MAXSIZE 100 //宏定义变量struct student {char name[20];int grade;};char c[] = "hello world";3. sizeof()函数的两种用法：（1）通过变量作为参数：int a = 10;b = sizeof (a); //b = 4;（2）通过数据类型作为参数：4. 在C语言中，sizeof()函数不管参数是什么，结果都是字节（byte）为单位，这也就是说如果变量数据类型为int时，sizeof()函数获取的结果就是4字节；而char型变量，sizeof()函数获取的结果就是1字节。
5. C语言中sizeof()函数的使用场景有：（1）在函数中，使用sizeof()函数把一个数组里的元素个数和每个元素的大小结合起来，就可以确定数组的总大小。
（2）当构造一个动态分配的数组时，由于动态分配的变量的类型不一定，因此可以使用sizeof()函数获取分配的数组大小，以便保证空间的足够分配。
（3）sizeof()函数还可以用来作类型转换，通过它可以把一个原始类型转换成另一种类型，例如将char型变量转换成int型变量。
6.总结sizeof()函数是C语言中最常用的内置函数，可以获取指定变量或者类型的大小，用于数组大小的计算，动态内存空间的分配，以及一些类型转换。
sizeof用法 c语言
sizeof用法 c语言在C语言中，sizeof是一个非常有用的运算符，它可以用于获取数据类型或对象的大小，以字节为单位。
这对于内存管理、动态分配和大小调整等方面非常重要。
本文将介绍sizeof在C语言中的用法。
一、基本概念sizeof运算符返回一个类型或对象所占的字节大小。
它只能用于数据类型（如int、float、char等）或对象（如数组、结构体等）。
sizeof的结果是一个整数，表示所求对象的大小（以字节为单位）。
二、用法示例1.获取数据类型的大小可以使用sizeof运算符来获取常见数据类型的大小，例如：```cinti=10;printf("%lu\n",sizeof(i));//输出4，表示int类型占4个字节```2.获取数组的大小可以通过sizeof运算符获取数组的大小，例如：```cintarr[5]={1,2,3,4,5};printf("%lu\n",sizeof(arr));//输出20，表示arr数组占20个字节（4个字节的指针+5个元素的*3个字节+一个结尾标志）```3.获取结构体的大小可以为一个结构体分配内存，并使用sizeof运算符获取其大小。
例如：```cstructMyStruct{inti;charc;};structMyStructs;printf("%lu\n",sizeof(s));//输出8，表示MyStruct结构体占8个字节（包括成员变量i和c所占的字节）```三、注意事项sizeof运算符返回的是对象或类型在内存中的大小，而不是其在磁盘上的大小。
它不考虑对齐和填充字节。
此外，sizeof的结果是编译时常量，可以在代码中直接使用。
四、应用场景sizeof运算符在C语言中应用非常广泛，例如：1.动态内存分配：在使用malloc()或calloc()函数分配内存时，可以使用sizeof运算符确定分配的大小。
sizeof用法示例
1、空类的sizeof是1。
空类是指没有成员的类，类中的函数不占空间，除非是虚函数。
如： class A{public:A(){}~A(){}void fun(){}};sizeof(A)是1.注： class A1{public:A1(){}~A1(){}void fun(){}char a[0];};sizeof(A1)也是1.（VC6.0下编译）2、若类中包含成员，则类对象的大小只包括其中非静态成员经过对齐所占的空间，对齐方式和结构体相同。
如：class A{public:int b;float c;char d;sizeof(A)是12.class A{public:static int a;int b;float c;char d;};sizeof(A)是12.class A{public:static int a;int b;float c;char d;int add(int x,int y){return x+y;}};sizeof(A)也是12.3、若类中包含虚函数，则无论有几个虚函数，sizeof类都等于sizeof(数据成员)的和+sizeof(V表指针，为4)，如：class Base{public:Base(){cout<<"Base-ctor"<<endl;}~Base(){cout<<"Base-dtor"<<endl;}int a;virtual void f(int) {cout<<"Base::f(int)"<<endl;}virtual void f(double){cout<<"Base::f(double)"<<endl;}};sizeof(Base)为8.4、对于子类，它的sizeof是它父类成员（无论成员是public或private)，再加上它自己的成员，对齐后的sizeof，如：class A2{public:int a;private:char b;};class A3:public A2{public:char b;short a;};sizeof(A3)是8. 但如果A3如下：class A3:public A2{public:short a;char b;};sizeof(A3)是12.5、对于子类和父类中都有虚函数的情况，子类的sizeof是它父类成员（无论成员是public或private)，再加上它自己的成员，对齐后的sizeof，再加4（虚表指针）。
C语言：sizeof用法
C语言：sizeof用法
sizeof是C语言中一个很重要的操作符，用来计算数据类型或变量所占内存大小，获取数据类型或变量的字节数。
sizeof操作符是在编译期计算运行的，返回的结果是一个整数常量。
1. 计算数据类型的大小，语法形式为：sizeof(数据类型)
例如，计算int类型的大小：
int size = sizeof(int);
sizeof操作符的返回值：
sizeof的一些注意事项：
2. sizeof返回的值是一个无符号整数，因此需要注意类型转换。
3. 在声明数组时，可以使用sizeof操作符来确定数组长度，如：
int arr[] = {1, 2, 3, 4};
int n = sizeof(arr)/sizeof(int);
这里使用sizeof(arr)计算数组arr的大小，再除以sizeof(int)来得到数组的长度。
这里使用sizeof(struct student)来计算结构体student的大小。
5. 对于指针类型的变量，sizeof操作符计算的是指针变量所占的内存空间大小，而
不是指针所指向的内存空间大小。
如：
int* p;
int size = sizeof(p); //返回值为4或8，与指针占用的内存空间大小有关，而不是指针所指向的内存空间大小。
总之，sizeof操作符在C语言中是一个非常重要的操作符，可以用于计算各种数据类型或变量在内存中占用的字节数，具有很高的实用价值。
因此，在编写C程序时，要充分
利用sizeof操作符，合理使用其功能，以提高程序的效率。
sizeof在c语言中的用法
sizeof在c语言中的用法一级标题：C语言中的sizeof用法介绍：在C语言中，sizeof是一种用于确定数据类型大小的运算符。
它可以用来获取变量、数据类型或表达式所占用的内存空间大小。
本文将详细介绍C语言中sizeof 的用法，并阐述其在不同情况下的应用。
二级标题一：sizeof基本用法在C语言中，sizeof运算符通常与变量、数据类型和表达式一起使用。
其基本语法如下：sizeof(operand)其中，operand可以是以下几种形式之一：1. 单个变量2. 数据类型3. 表达式当operand为单个变量时，sizeof将返回该变量所占用的字节数。
例如，对于整型变量x，可以使用以下代码查看其所占空间大小：```int x;int size = sizeof(x);```此时，size将被赋值为x所占内存空间的字节数。
当operand为数据类型时，sizeof将返回该数据类型所占用的字节数。
例如，我们可以通过以下方式获得字符型所占内存空间大小：```int size = sizeof(char);```此时，size将被赋值为字符型数据类型所占字节数。
如果operand为表达式，则表达式会先被求解，然后根据求解结果返回相应字节数。
例如，在如下代码片段中：```int x = 5;int size = sizeof(x + 3);```表达式x + 3将先求解为8，然后sizeof运算符返回这个结果所占字节数。
二级标题二：特殊情况下的sizeof用法除了上述基本用法外，sizeof在某些特殊情况下还有其他用途。
1. 数组名作为操作数当数组名作为sizeof的操作数时，sizeof将返回整个数组所占空间大小，而不是指向数组的指针类型所占字节数。
例如：```int arr[5];int size = sizeof(arr); // 返回整个数组arr的大小```此时，size将被赋值为整个数组arr所占空间的字节数。
c语言sizeof函数用法
c语言sizeof函数用法
sizeof函数是C语言中的一个重要运算符，它的作用是获取某一变量或数据类型所占的内存空间，具体用法如下：
一、语法格式：
sizeof(变量名) 或者 sizeof(数据类型)
二、用法介绍：
1. size语句用于获得变量或数据类型的内存空间大小，且返回值类型均为整数；
2. 对于整型变量，sizeof返回值为4；
3. 对于字符型变量，sizeof返回值为1；
4. 对于双精度型变量，sizeof返回值为8；
5. 对于字符串，sizeof返回结果为字符串的长度，实质上是一个字节的基本单位；
6. 对于数组，sizeof返回结果为整个数组的内存大小，实质上是一个字节的基本单位；
7. 对于结构体变量，sizeof返回结果为结构体变量的内存大小，实质上是一个字节的基本单位；
8. 对于结构体指针，sizeof返回结果为该指针变量的内存大小，实质上是一个字节的基本单位。
三、使用示例：
1. 对单誓变量：
int num=10;
int result = sizeof(num); //结果为4 2. 对数组变量：
int arr[20];
int result = sizeof(arr); //结果为80 3. 对字符串变量：
char str[20]="hello";
int result = sizeof(str); //结果为20。
sizeof的用法
sizeof()用法汇总sizeof()功能：计算数据空间的字节数1.与strlen()比较strlen()计算字符数组的字符数，以"\0"为结束判断，不计算为'\0'的数组元素。
而sizeof计算数据（包括数组、变量、类型、结构体等）所占内存空间，用字节数表示。
2.指针与静态数组的sizeof操作指针均可看为变量类型的一种。
所有指针变量的sizeof 操作结果均为4。
注意：int *p; sizeof(p)=4;但sizeof(*p)相当于sizeof(int);对于静态数组，sizeof可直接计算数组大小；例：int a[10];char b[]="hello";sizeof(a)等于4*10=40;sizeof(b)等于6;注意：数组做型参时，数组名称当作指针使用！！void fun(char p[]){sizeof(p)等于4}经典问题：double* (*a)[3][6];cout<<sizeof(a)<<endl; // 4 a为指针cout<<sizeof(*a)<<endl; // 72 *a为一个有3*6个指针元素的数组 cout<<sizeof(**a)<<endl; // 24 **a为数组一维的6个指针cout<<sizeof(***a)<<endl; // 4 ***a为一维的第一个指针cout<<sizeof(****a)<<endl; // 8 ****a为一个double变量问题解析：a是一个很奇怪的定义，他表示一个指向double*[3][6]类型数组的指针。
既然是指针，所以sizeof(a)就是4。
既然a是执行double*[3][6]类型的指针，*a就表示一个double*[3][6]的多维数组类型，因此sizeof(*a)=3*6*sizeof(double*)=72。
sizeof用法
一.基本数据的长度char:1(有符号无符号同)short:2(有符号无符号同)int:4(有符号无符号同)long:4(有符号无符号同)float:4double:8二.对齐的作用和原因：各个硬件平台对存储空间的处理上有很大的不同。
一些平台对某些特定类型的数据只能从某些特定地址开始存取。
比如有些架构的CPU在访问一个没有进行对齐的变量的时候会发生错误,那么在这种架构下编程必须保证字节对齐.其他平台可能没有这种情况，但是最常见的是如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。
比如有些平台每次读都是从偶地址开始，如果一个int型（假设为32位系统）如果存放在偶地址开始的地方，那么一个读周期就可以读出这32bit，而如果存放在奇地址开始的地方，就需要2个读周期，并对两次读出的结果的高低字节进行拼凑才能得到该32bit数据。
显然在读取效率上下降很多。
三.一些常见的和需要注意的sizeofchar* a= "abc"; //sizeof(a)=4==============================================char b[100]; //sizeof(b)=100;==============================================char* c=(char*)malloc(100); //sizeof(c)=100==============================================char d[] = "abc"; //sizeof(d)=4==============================================int e[100]; //求数组的元素个数int c2 = sizeof( e ) / sizeof( e[0] ); // 总长度/第一个元素的长度==============================================void foo3(char f[3]){int c3 = sizeof( f); // c3 =4}==============================================void foo4(char g[]){int c4 = sizeof( g); // c4 =4}==============================================int a = 1, b =2; 执行sizeof (a = b)之后为什么a=1, 而不是2. 为什么没有执行赋值操作? （淘宝笔试题）（1）sizeof (type-name) 是求变量类型的大小，在编译期执行，因为sizeof 是在编译期内执行而不是在运行期所以 sizeof (a = b) 是不会运行a = b 这个操作的。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
sizeof用法总结
本文主要包括二个部分，第一部分重点介绍在VC中，怎么样采用sizeof来求结构的大小，以及容易出现的问题，并给出解决问题的方法，第二部分总结出VC中sizeof的主要用法。
1、sizeof应用在结构上的情况
请看下面的结构：
struct MyStruct
{
double dda1;
char dda;
int type
};
对结构MyStruct采用sizeof会出现什么结果呢？sizeof(MyStruct)为多少呢？也许你会这样求：
sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13
但是当在VC中测试上面结构的大小时，你会发现sizeof(MyStruct)为16。
你知道为什么在VC中会得出这样一个结果吗？
其实，这是VC对变量存储的一个特殊处理。
为了提高CPU的存储速度，VC对一些变量的起始地址做了“对齐”处理。
在默认情况下，VC规定各成员变量存放的起始地址相对于结构的起始地址的偏移量必须为该变量的类型所占用的字节数的倍数。
下面列出常用类型的对齐方式(vc6.0,32位系统)。
类型
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）
Char
偏移量必须为sizeof(char)即1的倍数
int
偏移量必须为sizeof(int)即4的倍数
float
偏移量必须为sizeof(float)即4的倍数
double
偏移量必须为sizeof(double)即8的倍数
Short
偏移量必须为sizeof(short)即2的倍数
各成员变量在存放的时候根据在结构中出现的顺序依次申请空间，同时按照上面的对齐方式调整位置，空缺的字节VC会自动填充。
同时VC为了确保结构的大小为结构的字节边界数（即该结构中占用最大空间的类型所占用的字节数）的倍数，所以在为最后一个成员变量申请空间后，还会根据需要自动填充空缺的字节。
下面用前面的例子来说明VC到底怎么样来存放结构的。
struct MyStruct
{
double dda1;
char dda;
int type
}；
为上面的结构分配空间的时候，VC根据成员变量出现的顺序和对齐方式，先为第一个成员dda1分配空间，其起始地址跟结构的起始地址相同（刚好偏移量0刚好为sizeof(double)的倍数），该成员变量占用sizeof(double)=8个字节；接下来为第二个成员dda分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为8，是sizeof(char)的倍数，所以把dda存放在偏移量为8的地方满足对齐方式，该成员变量占用sizeof(char)=1个字节；接下来为第三个成员type分配空间，这时下一个可以分配的地址对于结构的起始地址的偏移量为9，不是sizeof(int)=4的倍数，为了满足对齐方式对偏移量的约束问题，VC自动填充3个字节（这三个字节没有放什么东西），这时下一个可以分配的地址对于结构的起始地址的偏移量为12，刚好是sizeof(int)=4的倍数，所以把type存放在偏移量为12的地方，该成员变量占用sizeof(int)=4个字节；这时整个结构的成员变量已经都分配了空间，总的占用的空间大小为：8+1+3+4=16，刚好为结构的字节边界数（即结构中占用最大空间的类型所占用的字节数sizeof(double)=8）的倍数，所以没有空缺的字节需要填充。
所以整个结构的大小为：
sizeof(MyStruct)=8+1+3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。
下面再举个例子，交换一下上面的MyStruct的成员变量的位置，使它变成下面的情况：
struct MyStruct
{
char dda;
double dda1;
int type
}；
这个结构占用的空间为多大呢？在VC6.0环境下，可以得到sizeof(MyStruc)为24。
结合上面提到的分配空间的一些原则，分析下VC怎么样为上面的结构分配空间的。
（简单说明）
struct MyStruct
{
char dda;//偏移量为0，满足对齐方式，dda占用1个字节；
double dda1;//下一个可用的地址的偏移量为1，不是sizeof(double)=8
//的倍数，需要补足7个字节才能使偏移量变为8（满足对齐
//方式），因此VC自动填充7个字节，dda1存放在偏移量为8
//的地址上，它占用8个字节。
int type；//下一个可用的地址的偏移量为16，是sizeof(int)=4的倍
//数，满足int的对齐方式，所以不需要VC自动填充，type存
//放在偏移量为16的地址上，它占用4个字节。
}；//所有成员变量都分配了空间，空间总的大小为1+7+8+4=20，不是结构//的节边界数（即结构中占用最大空间的类型所占用的字节数sizeof
//(double)=8）的倍数，所以需要填充4个字节，以满足结构的大小为
//sizeof(double)=8的倍数。
所以该结构总的大小为：sizeof(MyStruc)为1+7+8+4+4=24。
其中总的有7+4=11个字节是VC自动填充的，没有放任何有意义的东西。
VC对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。
VC中提供了#pragma pack(n)来设定变量以n字节对齐方式。
n字节对齐就是说变量存放的起始地址的偏移量有两种情况：第一、如果n大于等于该变量所占用的字节数，那么偏移量必须满足默认的对齐方式，第二、如果n小于该变量的类型所占用的字节数，那么偏移量为n的倍数，不用满足默认的对齐方式。
结构的总大小也有个约束条件，分下面两种情况：如果n大于所有成员变量类型所占用的字节数，那么结构的总大小必须为占用空间最大的变量占用的空间数的倍数；否则必须为n的倍数。
下面举例说明其用法。
#pragma pack(push)//保存对齐状态
#pragma pack(4)//设定为4字节对齐，这个好像是linux下默认的对齐模数struct test
{
char m1;
double m4;
int m3;
};
#pragma pack(pop)//恢复对齐状态
以上结构的大小为16，下面分析其存储情况，首先为m1分配空间，其偏移量为0，满足我们自己设定的对齐方式（4字节对齐），m1占用1个字节。
接着开始为m4分配空间，这时其偏移量为1，需要补足3个字节，这样使偏移量满足为n=4的倍数（因为sizeof(double)大于n）,m4占用8个字节。
接着为m3分配空间，这时其偏移量为12，满足为4的倍数，m3占用4个字节。
这时已经为所有成员变量分配了空间，共分配了16个字节，满足为n的倍数。
如果把上面的#pragma pack(4)改为#pragma pack(16)，那么我们可以得到结构的大小为24。
（请读者自己分析）
2、sizeof用法总结
在VC中，sizeof有着许多的用法，而且很容易引起一些错误。
下面根据sizeof 后面的参数对sizeof的用法做个总结。
A．参数为数据类型或者为一般变量。
例如sizeof(int),sizeof(long)等等。
这种情况要注意的是不同系统系统或者不同编译器得到的结果可能是不同的。
例如int 类型在16位系统中占2个字节，在32位系统中占4个字节。
B．参数为数组或指针。
下面举例说明.
int a[50];//sizeof(a)=4*50=200;求数组所占的空间大小
int*a=new int[50];//sizeof(a)=4;a为一个指针，sizeof(a)是求指针
//的大小,在32位系统中，当然是占4个字节。
C．参数为结构或类。
Sizeof应用在类和结构的处理情况是相同的。
但有两点需要注意，第一、结构或者类中的静态成员不对结构或者类的大小产生影响，因为静态变量的存储位置与结构或者类的实例地址无关。
第二、没有成员变量的结构或类的大小为1，因为必须保证结构或类的每一
个实例在内存中都有唯一的地址。
下面举例说明，
Class Test{int a;static double c};//sizeof(Test)=4.
Test*s;//sizeof(s)=4,s为一个指针。
Class test1{};//sizeof(test1)=1;
D．参数为其他。
下面举例说明。
int func(char s[5]);
{
cout<<sizeof(s)<<endl;//数组的参数在传递的时候系统处理为一个指针，所
//以sizeof(s)实际上为求指针的大小。
return1;
}
sizeof(func(“1234”))=4//因为func的返回类型为int，所以相当于
//求sizeof(int).
以上为sizeof的基本用法，在实际的使用中要注意分析VC的分配变量的分配策略，这样的话可以避免一些错误。