C语言中sizeof()的用法
sizeof结构体类型
sizeof结构体类型sizeof是C语言中的一个运算符，用于计算变量或数据类型的大小。
在C语言中，每个数据类型都有一个固定的大小，sizeof运算符可以返回该数据类型的字节数。
sizeof运算符可以用于计算各种数据类型的大小，包括基本数据类型（如int、float等）和自定义数据类型（如结构体和联合体）。
对于基本数据类型，sizeof运算符返回的是该数据类型的字节数。
例如，sizeof(int)返回的是4，表示int类型占用4个字节。
对于结构体类型，sizeof运算符返回的是该结构体的字节数。
结构体可以由多个不同类型的成员变量组成，sizeof运算符会计算出所有成员变量的大小，并将它们相加得到结构体的大小。
下面以一个例子来说明sizeof运算符的使用：```#include <stdio.h>struct Student {int id;char name[20];float score;};int main() {struct Student stu;printf("sizeof(int) = %lu\n", sizeof(int));printf("sizeof(char) = %lu\n", sizeof(char));printf("sizeof(float) = %lu\n", sizeof(float));printf("sizeof(struct Student) = %lu\n", sizeof(struct Student));printf("sizeof(stu) = %lu\n", sizeof(stu));return 0;}```运行上面的代码，输出结果如下：```sizeof(int) = 4sizeof(char) = 1sizeof(float) = 4sizeof(struct Student) = 28sizeof(stu) = 28```从输出结果可以看出，int类型占用4个字节，char类型占用1个字节，float类型占用4个字节，而结构体Student占用28个字节。
C语言--sizeof总结
C语⾔--sizeof总结sizeof的语法1：sizeof是C语⾔的关键字，⽤来计算变量、常量或数据类型在当前系统中占⽤内存的字节数。
…2：sizeof不是函数，产⽣这样的疑问是因为sizeof的书写确实有点像函数。
在程序中，sizeof有两种写法：1）⽤于数据类型：sizeof(数据类型)2）⽤于变量名：sizeof(变量名)；sizeof变置名 //不建议这样使⽤代码⽰例：#include<stdio.h>int main() {int i;char str[20];printf("sizeof(i) is %d\n", sizeof(i));printf("sizeof i is %d\n", sizeof i);printf("sizeof int is %d\n", sizeof(int));//printf("sizeof int is %d\n", sizeof int);错误写法printf("sizeof(str) is %d\n", sizeof(str));printf("sizeof str is %d\n", sizeof str);printf("sizeof str is %d\n", sizeof (char[20]));//printf("sizeof str is %d\n", sizeof char[20]);错误写法printf("sizeof(365) is %d\n", sizeof(365));printf("sizeof(i love you) is %d\n", sizeof("i love you"));}结果：注：最后⼀个字符串之所以是11，是因为在C语⾔中字符串后边会默认添加⼀个结束符，也就是'\0'sizeof与strlensizeof是运算符，⽤来计算变量、常量或数据类型在当前系统中占⽤内存的字节数strlen是函数，⽤于计算字符串的实际长度代码⽰例：char ch[20];strcpy(ch, "i love you");printf("sizeof(ch) is %d\n", sizeof(ch));//地址长度20，不变printf("strlen(ch) is %d\n", strlen(ch));//字符串的实际长度，也就是i love you的长度，为10结构体内存对齐⾸先看⼀个例⼦：struct S{char a;int b;char c;};我们先来计算⼀下这个结构体的⼤⼩，如果不存在内存对齐这个问题，按理说这个结构体应该占（1+4+1）6个字节；然⽽事实上它占了12个字节，为什么？我们需要解决下⾯⼏个问题。
c语言 sizeof 结构体指针
c语言 sizeof 结构体指针
在C语言中，sizeof操作符用于获取数据类型或变量的大小，
而结构体指针是指向结构体变量的指针。
当我们使用sizeof操作符
来获取结构体指针的大小时，实际上是获取指针变量的大小，而不
是指向的结构体的大小。
在C语言中，结构体指针的大小与指针变量的大小相同，通常
是与系统的位数相关的固定大小。
例如，在32位系统中，指针的大
小通常是4个字节，在64位系统中，指针的大小通常是8个字节。
这意味着无论结构体的大小是多少，结构体指针的大小都是固定的。
结构体指针的大小并不取决于结构体本身的大小，而是取决于
系统架构和编译器的实现。
因此，无论结构体的大小如何，结构体
指针的大小都是固定的。
需要注意的是，结构体指针的大小与结构体本身的大小是不同
的概念。
结构体的大小取决于其成员变量的大小和对齐方式，而结
构体指针的大小只取决于系统架构和编译器的实现。
总之，当你使用sizeof操作符来获取结构体指针的大小时，你
实际上获取的是指针变量的大小，而不是指向的结构体的大小。
这一点在内存分配和指针运算时需要特别注意。
c语言sizeof的返回值类型
c语言sizeof的返回值类型C语言中的sizeof关键字是一个用来获取数据类型或变量字节大小的运算符。
它的返回值类型是一个无符号整数，通常用size_t表示，其实质是一个unsigned int类型。
sizeof操作符可以用于获取各种数据类型的字节大小，包括基本数据类型（如int、float、double等）、自定义数据类型（如结构体、联合体等）以及指针类型。
在C语言中，每种数据类型都占用一定的内存空间，而sizeof可以帮助我们准确地获取到这个大小。
在使用sizeof时，可以使用两种形式。
一种是sizeof(类型)，用来获取指定类型的字节大小；另一种是sizeof(变量)，用来获取指定变量的字节大小。
例如，sizeof(int)可以获取int类型的字节大小，sizeof(float)可以获取float类型的字节大小，sizeof(struct Student)可以获取自定义结构体Student的字节大小。
需要注意的是，sizeof操作符并不会真正地计算变量或类型的字节大小，它在编译时就会被替换成一个常量。
这意味着sizeof操作符的计算结果是在编译时确定的，并不会因为程序运行时的实际数据而变化。
sizeof操作符的返回值类型是一个无符号整数，这是为了确保能够表示所有可能的字节大小。
无符号整数与有符号整数的区别在于，无符号整数只能表示非负数，而有符号整数可以表示正负数。
由于sizeof操作符获取的是字节大小，因此它的返回值类型必须是无符号整数，以确保能够表示所有可能的字节大小。
在实际编程中，sizeof操作符经常与其他运算符一起使用，例如在动态内存分配中，可以使用sizeof操作符来计算需要分配的内存空间大小。
另外，sizeof操作符还可以用来帮助判断数据类型的字节对齐方式，以及在处理网络通信或文件IO时，计算数据的字节大小。
需要注意的是，sizeof操作符不能直接用于获取动态分配的内存空间的大小。
SIZEOF函数使用
SIZEOF函数使用SIZEOF函数是一种在编程语言中常见的操作符，用于计算给定数据类型或对象的大小。
在不同的编程语言中，SIZEOF函数的具体用法和功能可能有所不同，但其基本目的都是为了测量特定类型或对象在内存中所占用的字节数。
在C语言中，SIZEOF函数是一个运算符而不是一个函数，用于计算给定类型的对象或表达式所占用的字节数。
这可以用来确定数据类型在内存中所占的空间，从而有效地进行内存管理。
例如，在声明数组时，可以使用SIZEOF函数计算数组的大小而不需要手动输入具体的字节数。
以下是一个示例：```c#include <stdio.h>int maiint arr[5];size_t size = sizeof(arr);printf("The size of the array is: %zu\n", size);return 0;```在上面的例子中，sizeof(arr)会返回整数数组arr所占用的字节数，然后将其打印到控制台。
在C++语言中，SIZEOF函数功能与C语言相同，但使用方式略有不同。
下面是一个使用SIZEOF函数的C++示例：```cpp#include <iostream>using namespace std;int maiint arr[5];size_t size = sizeof(arr);cout << "The size of the array is: " << size << endl;return 0;```在上面的示例中，SIZEOF函数用于计算整数数组arr的字节数，并将结果打印到控制台。
在其他编程语言中，如Java和Python，可能没有明确的SIZEOF函数，但可以使用其他方法来获取对象或类型的大小。
例如，在Java中，可以使用ng.instrument包中的Instrumentation类来测量对象的大小。
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语言中最常用的内置函数，可以获取指定变量或者类型的大小，用于数组大小的计算，动态内存空间的分配，以及一些类型转换。
C语言中sizeof的用法总结
C语言中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为unsigned int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
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如何计算数组大小原理
sizeof如何计算数组大小原理sizeof如何计算数组大小原理什么是sizeofsizeof是C语言中的一个操作符，用于计算数据类型或变量的大小（字节数）。
sizeof的基本用法int size = sizeof(int);上述代码将会得到一个整型变量的大小（字节数），并将其赋值给size。
sizeof和数组在C语言中，使用sizeof操作符计算数组的大小非常方便，可以用于静态数组和动态数组。
静态数组int arr[5];int size = sizeof(arr);上述代码将会得到整型数组arr的大小（字节数），并将其赋值给size。
动态数组int* arr = malloc(sizeof(int) * 5);int size = sizeof(arr);上述代码将会得到整型动态数组arr的大小（字节数），并将其赋值给size。
需要注意的是，sizeof(arr)返回的是指针arr的大小，而不是动态数组元素个数乘以每个元素所占的大小。
sizeof计算数组大小的原理静态数组静态数组在编译阶段就已经分配了内存空间，所以sizeof操作符直接返回数组的大小。
动态数组动态数组在运行时才能确定大小，所以sizeof操作符无法直接返回数组的大小，而是返回指针的大小。
为了获取动态数组的大小，我们可以通过以下方法：int* arr = malloc(sizeof(int) * 5);int num_elements = 5;int size = sizeof(int) * num_elements;上述代码中，我们通过变量num_elements保存动态数组元素的个数，然后使用sizeof操作符计算每个元素所占的大小，再将其与num_elements相乘，即可得到整个动态数组的大小。
注意，这种方法只适用于已知动态数组元素个数的情况。
另一种方法是使用sizeof操作符计算指针的大小，然后通过除法计算出元素个数：int* arr = malloc(sizeof(int) * 5);int size = sizeof(arr) / sizeof(int);上述代码中，sizeof(arr)返回的是指针arr的大小，sizeof(int)返回的是整型的大小，通过除法运算就可以得到动态数组的元素个数。
C语言sizeof（）用法介绍
C语⾔sizeof（）⽤法介绍1. 定义sizeof是⼀个操作符（operator）。
其作⽤是返回⼀个对象或类型所占的内存字节数。
2. 语法sizeof有三种语法形式：1） sizeof (object); //sizeof (对象)2） sizeof object; //sizeof 对象3） sizeof (type_name); //sizeof (类型)对象可以是各种类型的变量，以及表达式（⼀般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，编译⽆误1. 基本数据类型的sizeof这⾥的基本数据类型是指short、int、long、float、double这样的简单内置数据类型。
由于它们的内存⼤⼩是和系统相关的，所以在不同的系统下取值可能不同。
2. 结构体的sizeof结构体的sizeof涉及到字节对齐问题。
为什么需要字节对齐？计算机组成原理教导我们这样有助于加快计算机的取数速度，否则就得多花指令周期了。
为此，编译器默认会对结构体进⾏处理（实际上其它地⽅的数据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上，依次类推。
这样，两个数中间就可能需要加⼊填充字节，所以整个结构体的sizeof值就增长了。
sizeof详解
sizeof详解sizeof是C和C++中的一个运算符，用于获取数据类型或变量所占用的字节数。
它的作用是在编译时确定数据类型或变量的大小，以便在程序中进行内存分配和操作。
在C和C++中，使用sizeof运算符可以得到不同数据类型的大小。
sizeof运算符的语法格式为：sizeof(type) 或者sizeof expression。
其中，type是数据类型，expression是数据类型或者变量的表达式。
sizeof运算符返回一个size_t类型的值，表示操作数所占用的字节数。
sizeof运算符的结果与编译器和平台有关，不同的编译器和平台可能有不同的实现。
通常，sizeof(char)的结果是1，即字符类型占用1个字节。
sizeof(int)的结果通常是4或者8，即整型类型占用4个或者8个字节，具体取决于编译器和平台的位数。
sizeof运算符可以用于计算数组的大小。
例如，对于一个整型数组int arr[10]，可以使用sizeof(arr)来获取该数组占用的总字节数，即sizeof(int) * 10。
sizeof运算符还可以用于计算结构体、联合体和类的大小。
例如，对于一个结构体struct Person，可以使用sizeof(Person)来获取该结构体占用的总字节数，其中包括结构体内部的所有成员变量的大小。
在C++中，使用sizeof运算符还可以获取对象的大小。
例如，对于一个类的对象obj，可以使用sizeof(obj)来获取该对象占用的总字节数，其中包括对象内部的所有成员变量的大小。
需要注意的是，sizeof运算符只能用于静态类型，即在编译时已知的类型。
对于动态类型，如指针和引用，sizeof运算符只能返回它们本身的大小，而不是指向的对象的大小。
在使用sizeof运算符时，要注意避免出现歧义。
例如，对于一个指针，sizeof运算符返回的是指针本身的大小，而不是指针指向的对象的大小。
如果想要获取指针指向的对象的大小，可以通过解引用指针再使用sizeof运算符来实现。
c语言数组的sizeof
c语言数组的sizeof
C语言中的sizeof操作符用于获取数据类型或变量在内存中所
占的字节数。
对于数组而言，sizeof返回的是整个数组所占内存空
间的大小，而不是数组中元素的个数。
当我们使用sizeof操作符来获取数组的大小时，需要注意以下
几点：
1. 对于静态数组，可以使用sizeof来获取数组的大小。
例如，对于int类型的数组arr，可以使用sizeof(arr)来获取整个数组所
占的内存空间大小。
2. 对于动态数组，sizeof操作符不能直接获取数组的大小，
因为动态数组在内存中只是一个指针，sizeof操作符返回的是指针
变量本身所占的字节数，而不是指向的数组所占的空间大小。
3. 如果想要获取动态数组的大小，可以通过其他方式来实现，
例如通过在数组声明时记录数组的长度，或者通过传递数组长度作
为参数来获取数组的大小。
总之，sizeof操作符在获取数组大小时需要根据数组的类型和声明方式进行灵活使用，以确保能够准确获取数组所占的内存空间大小。
解析C语言的SIZEOF
解析C语言的SIZEOF（数据事业部软件开发一部刘文龙124725）最近从INTERNET上看到一个不错的介绍，自己再加上一个对STRUCT的介绍，特别张贴在这边，希望起到抛砖引玉的作用。
一、sizeof的概念sizeof是C语言的一种单目操作符，如C语言的其他操作符++、-- 等。
它并不是函数。
sizeof操作符以字节形式给出了其操作数的存储大小。
操作数可以是一个表达式或括在括号内的类型名。
操作数的存储大小由操作数的类型决定。
二、sizeof的使用方法1、用于数据类型sizeof使用形式：sizeof（type）数据类型必须用括号括住。
如sizeof（int）。
2、用于变量sizeof使用形式：sizeof（var_name）或sizeof var_name变量名可以不用括号括住。
如sizeof (var_name)，sizeofvar_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为unsigned int类型。
该类型保证能容纳实现所建立的最大对象的字节大小。
1、若操作数具有类型char、unsigned char或signed char，其结果等于1。
ANSI C正式规定字符类型为1字节。
2、int、unsigned int 、short int、unsigned short 、long int 、unsigned long 、float、double、longdouble类型的sizeof 在ANSI C中没有具体规定，大小依赖于实现，一般可能分别为2、2、2、2、4、4、4、8、10。
C语言里sizeof的用法
C语言里sizeof的用法在C语言中，sizeof是一个用于确定数据类型大小的运算符。
它可以用于所有的数据类型，包括基本数据类型（如char、int、float等）和复合数据类型（如结构体、联合体、数组等）。
sizeof能够准确地计算出一个变量或数据类型所占用的字节数。
sizeof的语法格式为：sizeof(表达式)表达式可以是变量、常量、数据类型等。
运算符sizeof将表达式作为参数，返回该表达式的字节数。
例如，sizeof(int)将返回4，因为在大多数机器上，int类型占用4个字节。
sizeof的主要作用是在程序中计算变量或数据类型的大小。
这对于内存管理和数据传输非常有用。
当我们从一个程序到另一个程序或从一个计算机到另一个计算机发送数据时，我们需要知道数据类型的大小，以确保数据能够准确地被接收和处理。
在C语言中，sizeof也可以用于确定数组元素的数量。
例如：int arr[10];printf("数组元素个数：%d\n", sizeof(arr)/sizeof(int));上面的代码将输出“数组元素个数：10”，因为sizeof(arr)返回整个数组的字节数，sizeof(int)返回一个整数的字节数，我们通过将数组字节数除以整数字节数，就可以得到数组元素的数量。
需要注意的是，sizeof计算的不是数组的内存大小，而是数组中每个元素的大小乘以数组元素的数量。
另外，当sizeof应用于指针时，它返回指针本身的大小而不是指向的内存块的大小。
总的来说，sizeof运算符是编写C程序时非常有用的一个工具，在内存管理、标准化和数据传输等方面，都可以提供便利和帮助。
因此，我们需要熟练掌握sizeof运算符的使用方法，以便更加高效和准确地编写C程序。
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函数
VC中的sizeof的用法总结（全）1. 定义：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 int; // errorsizeof可以对一个表达式求值，编译器根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。
如：sizeof( 2 );// 2的类型为int，所以等价于sizeof( int );sizeof( 2 + 3.14 ); // 3.14的类型为double，2也会被提升成double类型，所以等价于sizeof(double );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 );// errorvoid foo2() { }sizeof( foo2() );// errorstruct S{unsigned int f1 : 1;unsigned int f2 : 5;unsigned int f3 : 12;};sizeof( S.f1 );// error3. 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但在没有完全实现C99标准的编译器中就行不通了，上面的代码在VC6中就通不过编译。
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。
C语言中sizeof（）的用法
C语⾔中sizeof（）的⽤法语法sizeof有三种语法形式：1、sizeof(object); //sizeof(对象);2、sizeof(type_name); //sizeof(类型);3、sizeof object; //sizeof 对象;⼀、基本数据类型的sizeof等于各数据类型在内存中所占的字节数。
这⾥的基本数据类型指的是short、int、long、float等简单的内置数据类型，由于它们和系统相关，所以取值在不同系统下可能会不同，可移植性较差。
如：#include <stdio.h>int main(){int a = sizeof(char);int b = sizeof(short);int c = sizeof(int);int d = sizeof(long);printf("char 长度是 %d 个字节 \n", a);printf("short 长度是 %d 个字节 \n", b);printf("int 长度是 %d 个字节 \n", c);printf("long 长度是 %d 个字节 \n", d);return 0;}运⾏结果为：13:55:58 > char 长度是 1 个字节13:55:58 > short 长度是 2 个字节13:55:58 > int 长度是 4 个字节13:55:58 > long 长度是 4 个字节⼆、指针变量的sizeof等于计算机内部地址总线的宽度。
所以在32位计算机中，⼀个指针变量的返回值必定是4（注意结果是以字节为单位）。
指针变量的sizeof值与指着所指的对象没有任何关系。
三、数组的sizeof数组的sizeof值等于数组所占⽤的内存字节数，如：char a1[] = "abc"; int a2[3]; sizeof( a1 ); // 结果为4，字符末尾还存在⼀个NULL终⽌符 sizeof( a2 ); // 结果为3*4=12(依赖于int，int4个字节) //sizeof当作了求数组元素的个数是不对的，求数组元素的个数写法为：// 总长度/单个元素的长度 int c2 = sizeof( a1 ) / sizeof( a1[0] ); // 总长度/第⼀个元素的长度.注意数组名做函数参数传递时退化为指针。
c++中sizeof（）的用法介绍
c++中sizeof（）的⽤法介绍1. 定义sizeof是⼀个操作符（operator）。
其作⽤是返回⼀个对象或类型所占的内存字节数。
2. 语法sizeof有三种语法形式：1） sizeof (object); //sizeof (对象)2） sizeof object; //sizeof 对象3） sizeof (type_name); //sizeof (类型)对象可以是各种类型的变量，以及表达式（⼀般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，编译⽆误1. 基本数据类型的sizeof这⾥的基本数据类型是指short、int、long、float、double这样的简单内置数据类型。
由于它们的内存⼤⼩是和系统相关的，所以在不同的系统下取值可能不同。
2. 结构体的sizeof结构体的sizeof涉及到字节对齐问题。
为什么需要字节对齐？计算机组成原理教导我们这样有助于加快计算机的取数速度，否则就得多花指令周期了。
为此，编译器默认会对结构体进⾏处理（实际上其它地⽅的数据变量也是如此），让宽度为2的基本数据类型（short等）都位于能被2整除的地址上，让宽度为4的基本数据类型（int等）都位于能被4整除的地址上，依次类推。
这样，两个数中间就可能需要加⼊填充字节，所以整个结构体的sizeof值就增长了。
c语言结构体的sizeof
c语言结构体的sizeof
在C语言中，`sizeof`是一个判断数据类型或者表达式长度的运算符，以字节为单位。
`sizeof`的处理都是在编译阶段进行的。
对于结构体而言，`sizeof`的结果并不等于结构体中所有成员所占空间的总和，这是因为字节对齐的原因。
此外，`sizeof`运算符可以对一个表达式求值，编译器会根据表达式的最终结果类型来确定大小，一般不会对表达式进行计算。
例如，`sizeof(1+2)`等价于`sizeof(int)`，而`sizeof(1+2.5)`等价于`sizeof(double)`。
指针类型的字节是8个。
需要注意的是，`sizeof`操作符不能用于函数类型、不完全类型或位字段。
sizeof编程
sizeof编程
`sizeof`是C语言中的一个运算符，其作用是用来返回括号中()里卖弄的变量或者数据类型占用的内存字节数。
下面是一些关于`sizeof`编程的介绍：
`sizeof`可以用来求一个对象（类型、变量、数组等）所占的内存大小（以字节为单位）。
例如：
```c
char *p = NULL;
sizeof(p) == 4; //指针变量占4字节
```
`sizeof`可以用于判断变量和某个数据类型在当前环境下占几个字节。
例如：
```c
sizeof(1.0) == 8; //浮点数占8字节
```
`sizeof`还可以用于函数参数传递，当数组名为一个函数参数时，会被当作指针来看。
例如：
```c
void func(int b() /*int * b*/)
{
sizeof(b) == 4; //指针占4字节
}
```
总的来说，`sizeof`运算符在编程中是非常有用的，可以帮助我们更好地理解和处理内存相关的问题。
在使用`sizeof`时，需要注意数据类型的兼容性和平台的差异性，以确保程序的正确性和可靠性。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言中sizeof()的用法
2008-12-31 09:45:35.0 来源:51CTO
关键词：C语言
要参加软件研发的笔试（C/C++)几乎都会涉及到sizeof()的用法，我昨天也遇到了，有的也会，但是真正sizeof()的核心还是没有领会，今天上网，无聊中就看到了详细的sizeof()的阐述，现在分享给大家。
－－－－－－－－－－－－sizeof－－－－－－－－－－－－－－－－
sizeof 一般形式为：sizeof（object），也可以sizeof var_char,不过大部分programer 习惯用sizeof()。
对象可以是表达式或者数据类型名，当对象是表达式时，括号可省略。
sizeof是单目运算符，其运算符的含义是：求出对象在计算机内存中所占用的字节数。
一般来讲，不同的机器，运行不同的对象是不一样的，当目前几乎所有的机器都是32位，很少16位的，所以一般考试都是基于32位的window和linux的。
C语言中数据类型不多。
1.整数型的：
short，int，long(我没有考虑符号问题),一般c语言书上讲，int是2个字节的，即16位，范围是－32768－32767，long是4个字节，范围是－2^32---2^32-1。
当时在xp上运行sizeof(int)的时候，会output 4.这就是32位的原因。
sizeof（long）也是4.
如下:#include "stdio.h"
#include "string.h"
#include "stdlib.h"
int main()
{
short int sa=10;
int a=10;
long la=10;
float f = 20;
double d=20;
char ch=''c'';
char str[]="ABC";
char *p=str;
struct str{
double d;
char ch;
int data;
}str_wu;
struct str1{
char ch;
double d;
int data;
}str_wu1;
printf("sizeof(short):%d\n",sizeof(sa));
printf("sizeof(int):%d\n",sizeof(a));
printf("sizeof(long):%d\n",sizeof(la));
printf("sizeof(float):%d\n",sizeof(f));
printf("sizeof(double):%d\n",sizeof(d));
printf("sizeof(char):%d\n",sizeof(ch));
printf("sizeof(string):%d\n",sizeof(str));
printf("sizeof(point address):%d\n",sizeof(p));
printf("sizeof(Point):%d\n",sizeof(*p));
printf("sizeof(Struct):%d\n",sizeof(str_wu));
printf("sizeof(Struct):%d\n",sizeof(str_wu1));
system("pause");
}
因而int，short的sizeof结果是一样的额。
2.浮点型数据
float，double，long double
上边的图，long double 没有测试（忘了。
）呵呵！
但是应该是16。
3。
指针
对于指针，要特别区分，指针指向什么数据，它在内存占的字节数才是它的结果。
比如：指针指向一个字符串，就是字符串的长度，因为一个字符在内存中占一个字节。
若指针指向一个数据结构，则结果应该是结构型数据的内存字节数。
4。
结构类型
在上面的程序中，
struct str{
double d;
char ch;
int data;
}str_wu;
struct str1{
char ch;
double d;
int data;
}str_wu1;
两个不同的结构，但是内部的元素是相同的，都是double，int，char，只是顺序不一样，就结果不一样。
why？
这时因为VC存储数据的时候要对其，具体的情况如下：
类型
对齐方式（变量存放的起始地址相对于结构的起始地址的偏移量）
Char
偏移量必须为sizeof(char)即1的倍数
int
偏移量必须为sizeof(int)即4的倍数
float
偏移量必须为sizeof(float)即4的倍数
double
偏移量必须为sizeof(double)即8的倍数
Short
偏移量必须为sizeof(short)即2的倍数
比如：str_wu，为上面的结构分配空间的时候，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(str_wu)=8+1+3+4=16，其中有3个字节是VC自动填充的，没有放任何有意义的东西。
而str_wu1，同样的道理：如下：sizeof(char)=1,而1不是8的倍数，因而增加到8，sizeof（double）＝8，现在开始地址是16，16是sizeof（int)的倍数，可以存入。
因而总的地址数：sizeof（char）＋7＋sizeof（double）＋sizeof（int）＝20，
而20不是8的倍数（sizeof(double)=8),所以需要在增加4个地址，即总共24。
－－－－－－－－－－－－－－－－－－－－－－
sizeof具体的，我所知道的就这些了，那位高手还知道什么，或者我写的有什么错，希望指出。
谢谢！。