C预处理、const与sizeof

合集下载

c语言进阶

c语言进阶1.内存管理a. 未初始化的全局变量(.bss)b. 初始化的全局变量(.data)c. 常量数据(.rodata)：常量不一定放在.rodata里，有的立即数直接和指令编码在一起，存放在代码段(.text)d. 代码段(.text)f. 栈(stack)：用于存放临时变量和函数参数。

栈向下增长(低地址)。

g. 堆(heap)：内存分配了不释放，被称为内存泄漏(Memory Leak)2.内存分配方式a.从静态存储区分布：内存在编译时就已经分配好，这块内存在程序的整个运行期间都存在，如全局变量，static 变量等。

b.在栈上创建：函数内部局部变量，函数执行结束时被释放。

c.在堆上创建：动态内存分配。

malloc 和new的时候。

要free 和delete3.野指针a. 指针变量没有被初始化b. 指针p被free或者delete之后，没有置位NULL4.指针和数组对比a. 数组要么在静态存储区被创建，要么在栈上被创建。

数组名对应着一块内存(而不是指向)，其地址和容量在生命期内保持不变，数组内容可以保持不变b. 指针可以指向任意类型的内存块。

c. sizeof(a):得到数组真实的大小; sizeof(p):指针变量的字节数5.预处理a. 宏定义b. 文件包含;<>表示在包含文件目录中区查找 ""表示首先在当前源文件目录中去查找，若未找到则去包含目录中去找c. 条件编译6.函数库的提供形式：静态链接库和动态链接库a. 静态链接库：b. 动态链接库：效率更高。

不是将库函数的代码直接复制进可执行程序中，只是做个链接标记。

当应用程序在内存中执行，运行时环境发现它调用了一个动态库中的库函数时，会加载这个动态库到内存中，以后不管有多少个应用程序在同时使用该库函数，该库函数在内存中只有一份。

7.链接属性a. 程序从源代码到最终可执行程序：预编译、编译(将源代码翻译成xx.o)、汇编和链接b. 内存映像：代码段(test)和rodata段;数据段(data)和bss 段;堆;文件映射区(进程打开了文件后，将这个文件的内容从硬盘读取到进程的文件映射区，以后就直接在内存中操作这个文件);栈;内核映射区(将操作系统的内核程序映射到这个区域)8.加载运行代码a. 单独个人写的C语言程序没法直接在内存中运行，需要一定的外部协助，这段协助的代码叫做加载运行代码,这段代码的主要作用是给全局变量赋值，清bss段(现象：C语言中未初始化的全局变量默认为0)b. 在裸机下写的代码：定义了一个全局变量初始化为0.但是实际不为0.应在裸机的start.s中加入清bss段代码9.存储类相关的关键字auto：修饰局部变量。

C++笔试题

如果你不知道答案，请看参考文献1。这问题对区分一个正常的伙计和一个书呆子是很有用的。只有书呆子才会读C语言课本的附录去找出象这种问题的答案。当然如果你不是在找一个书呆子，那么应试者最好希望自己不要知道答案。死循环（Infinite loops） 4. 嵌入式系统中经常要用到无限循环，你怎么样用C编写死循环呢？这个问题用几个解决方案。我首选的方案是： while(1) { } 一些程序员更喜欢如下方案： for(;;) { } 这个实现方式让我为难，因为这个语法没有确切表达到底怎么回事。如果一个应试者给出这个作为方案，我将用这个作为一个机会去探究他们这样做的基本原理。如果他们的基本答案是："我被教着这样做，但从没有想到过为什么。"这会给我留下一个坏印象。第三个方案是用 goto Loop: ... goto Loop; 应试者如给出上面的方案，这说明或者他是一个汇编语言程序员（这也许是好事）或者他是一个想进入新领域的BASIC/FORTRAN程序员。数据声明（Data declarations） 5. 用变量a给出下面的定义 a) 一个整型数（An integer） b)一个指向整型数的指针（ A pointer to an integer） c)一个指向指针的的指针，它指向的指针是指向一个整型数（ A pointer to a pointer to an intege）r d)一个有10个整型数的数组（ An array of 10 integers） e) 一个有10个指针的数组，该指针是指向一个整型数的。（An array of 10 pointers to integers） f) 一个指向有10个整型数数组的指针（ A pointer to an array of 10 integers）

c语言中const的作用

c语言中const的作用
C语言中的const关键字表示常量，其作用是用于声明不可更改的变量。

也就是说，一旦一个变量被声明为const类型，就不能再对其进行赋值操作。

使用const可以带来如下好处：
1.保证变量的值不会被改变。

这在程序中起到了重要的作用，因为一些常量在程序中的值是不允许被改变的。

2.有助于编译器进行优化。

const常量在程序中只需要被读取，而不需要被修改，这样编译器可以将其存储在只读的数据段中，不必在栈或堆上开辟空间。

这样可以减少内存的使用，提高程序的运行速度。

3.提高代码的可读性。

使用const可以使代码更加清晰明了，让其他程序员更容易理解代码的含义。

const可以用于变量、函数参数、函数返回值等，具体用法如下： 1.变量：
const int a = 10; //声明一个const整型变量a，其值为10，不可更改
const char b = 'A'; //声明一个const字符型变量b，其值为'A'，不可更改
2.函数参数：
void fun(const int a); //声明一个函数fun，参数为const
类型的整型变量a，表示在函数中a的值不能被修改
3.函数返回值：
const int fun(); //声明一个函数fun，返回值为const类型的整型变量，表示返回值不能被修改
总之，使用const关键字可以提高程序的可靠性、可读性和效率，是C语言中非常实用的关键字。

c语言中const的用法

c语言中const的用法c语言中const有着重要的作用，它可以用来确保变量值在执行过程中不被意外改变，避免程序出现混乱的状态。

在编程中，const 指令可以提供一种方式确保变量的值在执行过程中不会被改变。

以下是关于c语言中const的一些用法。

1.义常量const关键字可以用来定义常量，其中的值在程序执行过程中不会发生变化。

例如，定义一个PI常量，其值为3.14：const double PI = 3.14;这就表明PI的值不可以被修改，否则程序将会报错。

定义常量时，变量的声明类型和值要在定义时就确定，之后不能再改变。

2.明指针const关键字也可以用来声明指针，用来防止指针指向的内容被意外修改。

例如：int a = 10;const int* p = &a;这里声明的指针p是const的，它指向的内存空间在程序运行过程中不能被修改，否则程序会报错。

3.定函数参数c语言中const也可以用于在函数声明和定义中限定函数参数。

在函数定义时，可以使用const将参数变量声明为只读，因此它的值在函数中不能改变。

例如：void foo(const int a){a = 10; // error，编译会报错}4. const成员函数const有时也可以用于声明成员函数，表明其为只读操作，不能修改成员变量。

const成员函数不能修改类中数据成员和静态成员，但是可以调用非const成员函数。

例如：class Foo{public:void nonConstFunc();void constFunc() const;private:int m_value;};5. const_castconst_cast也是一种常用的表达式，它可以用于在不同类型之间转换，也可以用于去除const属性。

例如：int a = 10;const int* p = &a;int* p1 = p; // errorint* p2 = const_cast<int*>(p); //const int*转换成int* 以上就是围绕c语言中const的用法做的介绍，它可以用于定义常量、声明指针、限定函数参数和const成员函数等。

c语言常量表达式

c语言常量表达式C语言中常量表达式是指在编译时就能确定值的表达式，常用于定义常量、数组长度、枚举值等。

常量表达式在编译时就被计算，可以提高程序的效率和可读性。

常量表达式可以使用任何C语言中的常量和运算符，包括整型、浮点型、字符型、枚举、sizeof、_Alignof等。

以下是常用的常量表达式：1. 整型常量表达式整型常量表达式由整型常量、运算符、括号组成，例如：const int a = 5;const int b = 2;const int c = (a + b) * 3;在上面的例子中，c的值为21，因为(a+b)*3=21。

2. 浮点型常量表达式浮点型常量表达式由浮点型常量、运算符、括号组成，例如：const float pi = 3.14f;const float r = 2.0f;const float area = pi * r * r;在上面的例子中，area的值为12.56f，因为pi*r*r=3.14f*2.0f*2.0f=12.56f。

3. 字符型常量表达式字符型常量表达式由字符常量、运算符、括号组成，例如：const char ch1 = 'a';const char ch2 = 'b';const char ch3 = ch1 + ch2;在上面的例子中，ch3的值为'ab'，因为ch1+ch2='a'+'b'='ab'。

4. 枚举常量表达式枚举常量表达式由枚举常量、运算符、括号组成，例如：enum color {RED, GREEN, BLUE};const int a = RED;const int b = GREEN;const int c = a + b;在上面的例子中，c的值为1，因为a+b=0+1=1。

5. sizeof常量表达式sizeof常量表达式用于计算变量或类型的大小，例如：const int a = 5;const int b = sizeof(a);在上面的例子中，b的值为4，因为int类型占4个字节。

c语言中sizeof的含义

c语言中sizeof的含义
在C语言中，sizeof是一个用于计算数据类型或变量占用字节大小的运算符。

它可以被用于计算任何数据类型、变量或表达式的大小。

sizeof运算符返回的结果
是一个无符号整数，表示指定对象所占用的字节数。

使用sizeof运算符可以帮助程序员在编写代码时更好地控制和管理内存。

在计
算数据类型的大小时，它会考虑编译器对类型所做的对齐和填充处理。

这意味着sizeof运算符返回的结果可能会比直观的数据类型大小略大。

sizeof运算符主要有两种用法：
1. sizeof(数据类型)
这种用法可以用来计算指定数据类型所占用的字节数。

例如，sizeof(int)将返
回整数类型(int)在当前平台上所占用的字节数。

这对于确定数据类型的字节大小非
常有用，特别是在编写与底层内存相关的代码时。

2. sizeof(变量或表达式)
这种用法将返回指定变量或表达式的字节数。

例如，如果有一个整数变量x，我们可以使用sizeof(x)来计算变量x所占用的字节数。

同样地，我们也可以使用sizeof(x + 1)来计算表达式(x + 1)的字节数。

需要注意的是，sizeof运算符在编译时计算大小，而不是运行时。

这意味着它
可以用于计算静态分配的数组大小，但无法用于动态分配的内存块的大小。

总结起来，C语言中的sizeof运算符用于计算数据类型、变量或表达式所占用
的字节数。

它是一个在编译时计算大小的运算符，可以帮助程序员更好地管理内存。

在编写底层或与内存相关的代码时，了解和正确使用sizeof运算符非常重要。

在C语言中const作用的的全面总结

在C语言中const作用的的全面总结const 是一个关键字，用于声明一个常量。

在C语言中，const 的作用主要有以下几个方面：1. 声明常量：const 用于声明一个常量，即一个不可修改的值。

常量的值在声明后不能被修改。

例如：const int MAX_SIZE = 100; 声明了一个名为 MAX_SIZE 的常量，其值为 100，不能被修改。

2. 防止意外修改：通过使用 const 关键字，可以防止在程序中意外地修改一个变量的值。

当一个变量被声明为 const 类型时，任何试图修改其值的操作都会导致编译错误。

3. 优化编译器：const 可以用于给编译器提供有关变量值的信息，从而优化生成的代码。

编译器可以根据 const 的声明来进行一些优化，例如将常量值直接嵌入到代码中，而不是每次都去访问内存。

4. 类型检查：const 可以提供类型检查，防止将一个类型错误的值赋给一个变量。

当一个变量被声明为 const 类型时，任何试图将不兼容的值赋给该变量的操作都会导致编译错误。

5. 作用域：const 变量的作用域和普通变量一样，可以是全局的也可以是局部的。

在不同的作用域中可以使用相同的 const 变量名，它们不会相互干扰。

6. 常量指针：const 还可以用于声明指向常量的指针。

这意味着指针指向的值是不可修改的，但指针本身可以修改。

例如：const int *ptr; 声明了一个指向常量的指针，即不能通过 ptr 修改指向的值，但可以修改 ptr 指向的位置。

7. 常量参数：const 可以用于声明函数的参数为常量参数，这样可以确保函数内部不会修改参数的值。

这样的函数被称为常量函数，可以接受常量参数并返回常量结果。

8. 数组长度：const 可以用于声明数组的长度，使得在程序中可以更方便地使用数组。

例如：const int SIZE = 10; int arr[SIZE]; 声明了一个大小为 10 的数组。

C语言32个关键字详解

C语言中32个关键字详解由ANSI标准定义的C语言关键字共32个:auto double int struct break else long switchcase enum register typedef char extern return unionconst float short unsigned continue for signed voiddefault goto sizeof volatile do if while static根据关键字的作用，可以将关键字分为数据类型关键字和流程控制关键字两大类。

1数据类型关键字A基本数据类型（5个）void：声明函数无返回值或无参数，声明无类型指针，显式丢弃运算结果char：字符型类型数据，属于整型数据的一种int：整型数据，通常为编译器指定的机器字长float：单精度浮点型数据，属于浮点数据的一种double：双精度浮点型数据，属于浮点数据的一种B类型修饰关键字（4个）short：修饰int，短整型数据，可省略被修饰的int。

long：修饰int，长整形数据，可省略被修饰的int。

signed：修饰整型数据，有符号数据类型unsigned：修饰整型数据，无符号数据类型C复杂类型关键字（5个）struct：结构体声明union：共用体声明enum：枚举声明typedef：声明类型别名sizeof：得到特定类型或特定类型变量的大小D存储级别关键字（6个）auto：指定为自动变量，由编译器自动分配及释放。

通常在栈上分配static：指定为静态变量，分配在静态变量区，修饰函数时，指定函数作用域为文件内部register：指定为寄存器变量，建议编译器将变量存储到寄存器中使用，也可以修饰函数形参，建议编译器通过寄存器而不是堆栈传递参数extern：指定对应变量为外部变量，即在另外的目标文件中定义，可以认为是约定由另外文件声明的韵蟮囊桓觥耙谩?const：与volatile合称“cv特性”，指定变量不可被当前线程/进程改变（但有可能被系统或其他线程/进程改变）volatile：与const合称“cv特性”，指定变量的值有可能会被系统或其他进程/线程改变，强制编译器每次从内存中取得该变量的值2流程控制关键字A跳转结构（4个）return：用在函数体中，返回特定值（或者是void值，即不返回值）continue：结束当前循环，开始下一轮循环break：跳出当前循环或switch结构goto：无条件跳转语句B分支结构（5个）if：条件语句else：条件语句否定分支（与if连用）switch：开关语句（多重分支语句）case：开关语句中的分支标记default：开关语句中的“其他”分治，可选。

符号常量的声明方法(一)

符号常量的声明方法(一)符号常量的声明什么是符号常量符号常量是在程序中用来表示某个固定数值的标识符。

与变量不同，符号常量的值在程序执行过程中不能改变，是固定不变的。

声明符号常量的方法方法一：使用宏定义宏定义是C语言中最常见的声明符号常量的方法，它使用#define关键字后跟标识符和常量值，形式如下：#define CONSTANT_NAME value例如，我们可以声明一个名为PI的符号常量，值为3.14159：#define PI 3.14159在程序中使用时，可以直接使用PI代替3.14159。

宏定义的优点是简单、直观，缺点是无法对常量进行类型检查，可能导致意想不到的错误。

方法二：使用const关键字C语言中，使用const关键字也可以声明符号常量。

语法如下：const data_type CONSTANT_NAME = value;例如，我们可以声明一个名为MAX_LENGTH的符号常量，值为100：const int MAX_LENGTH = 100;与宏定义不同，使用const声明的符号常量具有类型检查，编译器可以在编译阶段捕捉到一些错误。

方法三：使用enum关键字在C语言中，还可以使用enum关键字声明一组相关的符号常量。

例如，我们可以声明一个名为Color的枚举类型，其中包含红、绿、蓝三种颜色：enum Color {RED,GREEN,BLUE};在程序中，我们可以使用Color.RED、Color.GREEN、Color.BLUE分别代表红、绿、蓝三种颜色。

enum声明的符号常量默认从0开始自增，也可以手动指定每个常量的值。

方法四：使用#define预处理指令与运算符在C语言中，#define预处理指令可以与运算符一起使用，来声明一些动态计算的符号常量。

例如，我们可以使用#define预处理指令与sizeof运算符来声明一个名为MAX_SIZE的符号常量，表示某个数据类型的最大长度：#define MAX_SIZE (sizeof(int) * 1024)这样，MAX_SIZE的值将根据sizeof(int)的结果在编译时进行动态计算。

校招嵌入式C++工程师笔试题

校招嵌入式/C++工程师笔试题请在40-50分钟内完成测试题，题目较多，注意控制时间。

基本信息：[矩阵文本题] *1.在C/C++中，关键字static和const的作用各是什么? [填空题]_________________________________2.在C/C++中，sizeof和strlen的作用及区别是什么? [填空题]_________________________________3.C++的lambda表达式中，值捕获和引用捕获的区别是什么? [填空题] _________________________________4.struct 和 class 的区别是什么? [填空题]_________________________________5.“大端模式”和“小端模式”的区别是什么? [填空题]_________________________________6.请列举你熟知的单片机型号及所具备的外设。

[填空题]_________________________________7.请列举你熟知的硬件通信方式及特点。

[填空题]_________________________________8.定义一个常量，表示一天有多少秒（） [填空题]_________________________________9.使用宏定义实现输入两个整数，返回最大值（） [填空题]_________________________________10.#define DOUBLE(x) x+x。

表达式(5*DOUBLE(5))=（） [填空题] * _________________________________11.请给出下面程序输出情况。

int a = 0;int b= 1;int c = 2;int d = 3;c=a,b;d=(a,b);printf("c=%d" ,c);printf("d=%d" ,d); [填空题] *_________________________________12.请给出下面程序的执行结果。

C语言中各关键词的含义和用途

C语言中各关键词的含义和用途以下是C语言中常见的关键字以及它们的含义和用途：1. auto: 用于声明局部变量，表示变量的生命周期和作用域由编译器自动管理。

2. break: 用于循环或switch语句中，提前结束当前循环或switch 块。

3. case: 在switch语句中，用于匹配一些特定值并执行相应的语句。

4. char: 用于声明字符类型的变量。

5. const: 用于声明常量，表示该变量的值在程序运行期间不可修改。

6. continue: 用于循环语句中，结束当前循环的迭代，并开始下一次迭代。

7. default: 在switch语句中，用于处理没有匹配到任何case的情况。

8. do: 用于创建do-while循环，至少执行一次循环体。

9. double: 用于声明双精度浮点数类型的变量。

10. else: 在if语句中，用于处理条件为假时的分支。

11. enum: 用于创建枚举类型，定义一组具名的整型常量。

12. extern: 声明一个已在其他地方定义的变量或函数。

13. float: 用于声明单精度浮点数类型的变量。

14. for: 用于创建for循环，多用于迭代。

16. if: 用于创建if条件语句，根据条件的真假执行相应的语句。

17. int: 用于声明整数类型的变量。

18. long: 用于声明长整数类型的变量。

19. register: 声明存储在寄存器中的局部变量，提高访问速度。

20. return: 用于结束函数并返回一个值。

21. short: 用于声明短整数类型的变量。

22. signed: 用于声明有符号类型的变量。

23. sizeof: 返回一个数据类型或变量的字节大小。

24. static: 对局部变量和全局变量的存储类进行限定，使其在程序整个运行期间都存在。

25. struct: 用于声明结构体，可以包含多个不同类型的变量。

26. switch: 用于创建switch语句，在多个选择之间进行条件判断。

C语言符号集

C语言符号集C语言符号集包括：英文字母、数字和一些有特定含义的标点符号。

任何C程序都是由C 的符号集里的符号构成具有一定含义的语句，再由这些语句组成程序。

一、字母、数字和下划线大写英文字母：A——Z小写英文字母：a——z数字符：0——9下划线：_二、空白符空白符是指：空格符、制表符、垂直制表符、回车符、换行符、换页符。

其在C源程序中只产生“空白”的作用。

空白符只在字符常量和字符串常量中起作用。

在其它地方出现时，只起间隔作用，编译程序对它们忽略。

因此在程序中使用空白符与否，对程序的编译不发生影响，但在程序中适当的地方使用空白符将增加程序的清晰性和可读性。

三、标点符号和特殊符号C语言使用的标点符号和特殊符号符号名称符号名称，逗号> 右尖括号. 圆点! 感叹号；分号| 竖线：冒号/ 斜杠？问号\ 反斜杠’ 单引号~ 波折号“ 双引号# 井号( 左圆括号% 百分号) 右圆括号& and（与）[ 左方括号^ xor（异或）] 右方括号* 乘号{ 左大括号- 减号} 右大括号= 等于号< 左尖括号+ 加号四、转义字符转义字符是C语言中表示字符的一种特殊形式。

通常使用转义字符表示ASCII码字符集中不可打印的控制字符和特定功能的字符，如用于表示字符常量的单撇号（'），用于表示字符串常量的双撇号（"）和反斜杠（\）等。

转义字符用反斜杠\后面跟一个字符或一个八进制或十六进制数表示。

表2-4给出了C语言中常用的转义字符。

表2-4 转义字符转义字符意义ASCII码值（十进制）\a 响铃(BEL) 007\b 退格(BS) 008\f 换页(FF) 012\n 换行(LF) 010\r 回车(CR) 013\t 水平制表(HT) 009\v 垂直制表(VT) 011\\ 反斜杠092\? 问号字符063\' 单引号字符039\" 双引号字符034\0 空字符(NULL) 000\ddd 任意字符三位八进制\xhh 任意字符二位十六进制转义字符的作用：表示控制代码；表示字符和字符串常量；表示用ASCII符集中任意字符。

C语言三种预处理

3.条件编译定义：
当满足某条件时对一组语句进行编译，而条件不满足时则编译另一组语句。形式：
#ifndef 标识符程序段 1
#else 程序段 2
#endif 若标识符未被定义则编译程序段 1，否则编译程序段 2。优点：采用条件编译，可以减少被编译的语句，从而减少目标的长度。当条件编译段比较多时，目标程序长度可以大大减少。
1.2 带参数的宏定义格式：
#define 宏名（参数表）字符串举例：
#define S(a,b) ((a)*(b)) 说明：
①宏名和参数间不能有空格！ ②宏替换只做替换，不做计算和表达式求解！ ③宏展开不占程序运行时间只占编译时间！掌握宏概念的关键在“替换”！
2.文件包含由来：
文件包含处理在程序开发中会给模块化程序设计带来很大的好处，通过文件包含的方法把程序中的各个功能模含处理是指在一个源文件中，通过文件包含命令将另一个源文件的内
容全部包含在此文件中。在源文件编译时，连同被包含进来的文件一同编译，生成目标目标文件。形式：
①#include ＂文件名＂; 或
②#include ＜文件名＞; 两种形式区别：
①系统首先在用户当前目录中寻找要包含的文件，若未找到才到包含目录中去查找；
C 语言提供 3 种预处理功能：①宏定义②文件包含③条件编译。
0.预处理指令预处理指令是以#号开头的代码行。#号必须是该行除了任何空白字符外的第
一个字符。#后是指令关键字，在关键字和#号之间允许存在任意个数的空白字符。整行语句构成了一条预处理指令，该指令将在编译器进行编译之前对源代码做某些转换。
②系统在包含文件目录中去查找（包含目录由用户在设置环境时设置）而不在源文件目录去查找。若文件不在当前目录中，双撇号内可给出文件路径。说明：

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)。

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
C语言中的sizeof操作符用于获取数据类型或变量在内存中所
占的字节数。

对于数组而言，sizeof返回的是整个数组所占内存空
间的大小，而不是数组中元素的个数。

当我们使用sizeof操作符来获取数组的大小时，需要注意以下
几点：
1. 对于静态数组，可以使用sizeof来获取数组的大小。

例如，对于int类型的数组arr，可以使用sizeof(arr)来获取整个数组所
占的内存空间大小。

2. 对于动态数组，sizeof操作符不能直接获取数组的大小，
因为动态数组在内存中只是一个指针，sizeof操作符返回的是指针
变量本身所占的字节数，而不是指向的数组所占的空间大小。

3. 如果想要获取动态数组的大小，可以通过其他方式来实现，
例如通过在数组声明时记录数组的长度，或者通过传递数组长度作
为参数来获取数组的大小。

总之，sizeof操作符在获取数组大小时需要根据数组的类型和声明方式进行灵活使用，以确保能够准确获取数组所占的内存空间大小。

C语言中sizeof函数用法详解！

C语⾔中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。

C语言简单实现sizeof功能代码

C语⾔简单实现sizeof功能代码sizeof不是函数，⽽是运算符，C/C++语⾔编译器在预编译阶段的时候就已经处理完了sizeof的问题，也就是说sizeof类似于宏定义。

下⾯给出⼀个sizeof的⼀个宏定义实现版本#define sizeof(L_Value) ((char*)(&L_Value + 1) - (char*)(&L_Value))实验⼀：#define mysizeof(L_Value) ((char*)(&L_Value + 1) - (char*)(&L_Value))int main(){int a[5]={1,2,3,4,5};printf("%d",mysizeof(a));char c=getchar();return 0;}输出：20不过本⽂的mysizeof只能对已定义的变量求⼤⼩实验⼆：#define mysizeof(L_Value) ((char*)(&L_Value + 1) - (char*)(&L_Value))int main(){int a[5]={1,2,3,4,5};printf("%d",mysizeof(&a));char c=getchar();return 0;}此时会报语法错误，因为&a并不是我们定义的变量，详细说是&a不是左值，⽤宏替换后变为((char*)(&&a + 1) - (char*)(&&a))，&&a有语法错误。

我们的版本还是不够强⼤啊，不知道C语⾔设计中是怎么实现的sizeof(&a)计算。

C++类的大小——sizeof（class）

C++类的大小——sizeof（class）C++类的大小——sizeof(class)第一：空类的大小运行cout<<"sizeof(CBase)="<<sizeof(CBase)<<endl;sizeof(CBase)=1；为什么空的什么都没有是1呢？先了解一个概念：类的实例化，所谓类的实例化就是在内存中分配一块地址，每个实例在内存中都有独一无二的地址。

同样空类也会被实例化（别拿豆包不当干粮，空类也是类啊），所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。

所以空类的sizeof为1。

第二：一般非空类大小后输出什么？运行结果：sizeof(CBase)=8第三：有虚函数类再运行：sizeof(CBase)=12“C++ 类中有虚函数的时候有一个指向虚函数的指针（vptr），在32位系统分配指针大小为4字节”。

第四步：有虚函数类的继承基类就是上面的了不写了运行：cout<<"sizeof(CChild)="<<sizeof(CChild)<<endl;输出：sizeof(CChild)=16；可见子类的大小是本身成员变量的大小加上子类的大小。

############################################# ######另外：1. 空类class A{};void main(){printf("sizeof(A): %d\n", sizeof(A));getchar();}得到结果为：1。

类的实例化就是给每个实例在内存中分配一块地址。

空类被实例化时，会由编译器隐含的添加一个字节。

所以空类的size为1。

2.虚函数class A{virtual void FuncA(); virtual void FuncB();};得到结果：4当C++ 类中有虚函数的时候，会有一个指向虚函数表的指针（vp tr），在32位系统分配指针大小为4字节。

C语言关键字详解

C语⾔关键字详解</h1> 相对于其他语⾔来说，C语⾔的关键字算是少的了。

在C98中关键⼦总共只有32个，我们来分析⼀下每个关键字在C语⾔中它独特的作⽤。

1、关于数据类型的关键字 (1) char ：声明字符型变量或函数 (2) double ：声明双精度变量或函数 (3) enum ：声明枚举类型 enum类型可以增加可读性，可移植性；在enum中定义的每个对象，默认都是从0开始，当然也可以⾃定义。

如下：enum Color{RED,BLACK,WHITE};enum Number{ONE=1,TWO,THREE}; Color中RED=0，BLACK=1，WHITE=2; Number中ONE=1，TWO=2，THREE=3； (4) float：声明浮点型变量或函数 (5) int：声明整型变量或函数 (6) long ：声明长整型变量或函数 (7) short ：声明短整型变量或函数 (8) signed：声明有符号类型变量或函数 (9) struct：声明结构体变量或函数结构体struct的作⽤已经在上⼀篇博⽂中讲到，可以⽤来实现C语⾔的封装，继承，多态等等。

union类型可以⽤来提⾼内存的使⽤率，如下：int main(){union Unoin{int a;float b;char *c;};union Unoin p;p.a = 100;/*执⾏语句1*/p.b = 10.0;/*执⾏语句2*/p.c = "hello world!";/*执⾏语句3*/return 0} 如果不使⽤union，我们需要分别定义int,float,cahr*，需要占⽤12字节的内存空间，但是当我们使⽤union时，只需要占⽤4字节即可；但是需要注意的时，我们在上⾯那个代码中执⾏语句2或者3中需要⽤到int a时，就⽆法使⽤union 了，必须单独定义int a;否则读出的a值将会错误的。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

[C++面试题]之预处理、const与sizeof1、用预处理指令#define声明一个常数，用以表明一年中有多少秒（忽略闰年的问题）解析：1.#define语法的基本知识（例如，不能以分号结束，括号的使用等）2.要懂得预处理器将为你计算常数表达式的值，因此，写出你是如何计算一年中有多少秒而不是计算出实际的值，会更好意义。

3.意识到这个表达式将使一个16位机的整型数溢出，因此要用到长整形符号L，告诉编译器这个常数是长整型数。

如果表达式中用到UL（表示无符号长整型），那么你就有了一个好的第一印象了，记住，第一印象很重要。

答案：view sourceprint?1 #defineSECONDS_PER_YEAR(60*60*24*365)UL2、写一个“标准”的宏MIN，这个宏输入两个参数并返回较少的一个解析：1.标识#define在宏中应用的基本知识，这是很重要的，因为知道嵌入操作符变为标准C的一部分，宏都是方便地产生嵌入代码的唯一方法。

对伊嵌入式系统来说，为了能达到要求的性能，嵌入代码经常是必须的方法。

2.三重条件操作符的知识。

这个操作符存在C语言中的原因是它使得编译器能产生比if-then-else更优化的代码，了解这个用法是很重要的。

3.懂得在宏中小心的把参数用括号括起来。

答案：view sourceprint?1 #define MIN(A,B) ((A) <= (B) ? (A) : (B))3、const有什么用途？请至少说明两种？解析：在C程序中，const的用法主要有定义常量、修饰函数参数、修饰函数返回值。

在C++程序中，它还可以修饰函数的定义体，定义类中某个成员函数为恒态函数，即不改变类中的数据成员。

答案：（1）可以定义const常量。

（2）const可以修饰函数的参数和返回值，甚至函数的定义体。

被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。

4、const与#define相比有什么不同？答案：C++语言可以用const定义常量，也可以用#define定义常量，但是前者比后者有更多的有点：（1）const常量有数据类型，而宏常量没有数据类型。

编译器可以对前者进行类型安全检查，而对后者只是进行字符替换，没有类型安全检查，并且在字符替换中可能产生意料不到的错误（边际效应）。

（2）有些集成话的调试工具可以对const常量进行调试，但是不能对宏常量进行调试。

在C++程序中只使用const常量而不使用宏常量，即const常量完全取代宏常量。

5、下面代码输出结果是什么？view sourceprint?#include<iostream>1usingnamespacestd;23struct4{5shorta1;6shorta2;7shorta3;8}A;911struct11{21longa1;31shorta2;41}B;5161intmain ()71{81char* ss1 ="0123456789";2charss2[] ="0123456789";21charss3[100] ="0123456789";22intss4[100];23charq1[] ="abc";24charq2[] ="a\n";25char* q3 ="a\n";26char*str1 = (char*)malloc(100); 27void*str2 = (void*)malloc(100); 282 9 cout<<"sizeof(ss1):"<<sizeof(ss1)<<end l;3 0 cout<<"sizeof(ss2):"<<sizeof(ss2)<<end l;3 1 cout<<"sizeof(ss3):"<<sizeof(ss3)<<end l;3 2 cout<<"sizeof(ss4):"<<sizeof(ss4)<<end l;3 3 cout<<"sizeof(q1):"<<sizeof(q1)<<endl ;3 4 cout<<"sizeof(q2):"<<sizeof(q2)<<endl ;3 5 cout<<"sizeof(q3):"<<sizeof(q3)<<endl ;3 6 cout<<"sizeof(A):"<<sizeof(A)<<endl ;3 7 cout<<"sizeof(B):"<<sizeof(B)<<endl ;3 8 cout<<"sizeof(str1):"<<sizeof(str1)<<end l;3 9 cout<<"sizeof(str2):"<<sizeof(str2)<<end l;44return0;4}2解析：ss1是一个字符指针，指针的大小是一个定值，就是4字节，所以sizeof(ss1)是4字节ss2是一个字符数组，这个数组最初未定大小，由具体填充值来定。

填充值是“0123456789 ”。

1个字符所占空间是1字节，10个就是10字节，再加上隐含的“\0”，所以一共是11字节。

ss3也是一个字符数组，这个数组开始预分配100，所以它的大小一共是100字节。

ss4也是一个字符数组，这个数组开始预分配100，但是每个整型变量所占用空间是4，所以它的大小一共是400字节。

q1与ss2类似，所以是4字节。

q2里面有一个“\n”，“\n”算做一位，所以它的空间大小是3字节。

q3是一个字符指针，指针的大小是一个定值，就是4，所以sizeof(q3)是4字节。

A和B是两个结构体，在默认情况下，为了方便对结构体内元素的访问和管理，当结构体内的元素的长度都小于处理器的位数的时候，便以结构体里面最长的数据元素为对齐单位，也就是说，结构体的长度一定是最长的数据元素的整数倍。

如果结构体内存在长度大于处理器位数的元素，那么就以处理器的位数为对齐单位，但是结构体内类型相同的连续元素将在连续的空间内，和数组一样。

结构体A中有3个short类型变量，各自以2个字节对齐，所以sizeof(A)是为6字节。

结构体B中a1以4字节对齐，a2以2字节对齐，则结构体大小为6字节，但是结构体的长度一定是最长数据元素的整数倍，显然6不是4的整数倍数，补空字节，增到8字节，符合所以条件。

故sizeof(B)为8字节。

str1和str2都是字符指针，都是4字节。

答案：sizeof(ss1): 4sizeof(ss2): 11sizeof(ss3): 100sizeof(ss4): 400sizeof(q1): 4sizeof(q2): 3sizeof(q3): 4sizeof(A): 6sizeof(B): 8sizeof(str1): 4sizeof(str2): 46、以下代码为32位机器编译，数据是以4字节为单位，这两个类型的输出结果为什么不同？view sourceprint?classB1{20private:boolm_bTemp1;4intm_nTemp;5boolm_bTemp2;6};78classC91{1private:11intm_nTemp;21boolm_bTemp1;31boolm_bTemp2;41};5161cout <<sizeof(B) << endl;71cout <<sizeof(C) << endl;8解析：编译器会对结构体进行对齐处理，根据对齐原则。

类型B情况如下：| bool |-----|----|----||-----------int---------|| bool |-----|----|----|类型C情况如下：|-----------int-----------|| bool | bool |----|----|答案：B类输出12字节，C类输出8字节。

7、说明sizeof和strlen之间的区别解析：第1个例子：char *a="0123456789";sizeof(a)结果为4，a是指向字符串常量的字符指针。

sizeof(*a)结果是1，*a是第一个字符。

strlen(a)结果是10，它内部实现是用一个循环计算字符的长度，直到“\0”为止。

第2个例子：char a[100]="0123456789";sizeof(a)结果为100，a表示在内存中预分配的大小。

strlen(a)结果还是10，它内部实现是用一个循环计算字符的长度，直到“\0”为止。

第3个例子：char a[]="0123456789";sizeof(a)结果为11，a是数组计算到“\0”位置，因此是（10+1）。

strlen(a)结果还是10，它内部实现是用一个循环计算字符的长度，直到“\0”为止。

第4个例子：int a[100]="0123456789";sizeof(a)结果为400，a表示在内存中预分配的大小,100*4。

strlen(a)错误，strlen的参数只能是char*，且必须是以“\0”结尾的。

答案：（1）sizeof操作符的结果类型是size_t，它在头文件中的typedef为unsigned int类型。

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

（2）sizeof是运算符，strlen是函数。

（3）sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以“\0”结尾的。

sizeof还可以用函数做参数，结果与函数返回值的类型一致。

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

（5）strlen的结果要运行时才能计算出来，用来计算字符串的长度，而不是类型占内存的大小。

（6）sizeof计算结构变量的大小就必须讨论数据对齐问题（C++处理数据时经常把结构变量中的成员的大小按照4或8的倍数计算）。