1 预处理
问题 1：什么是预编译？何时需要预编译？

答：

预编译又称预处理，是整个编译过程最先做的工作，即程序执行前的一些预处理工作。次要处理 #结尾的指令。如拷贝#include 蕴含的文件代码、替换#define 定义的宏、条件编译#if 等。.

何时需要预编译：

1、总是使用不常常改变的大型代码体。

2、程序由多个模块组成，所有模块都使用一组标准的蕴含文件和雷同的编译选项。在这种情况下，可能将所有蕴含文件预编译为一个预编译头。

问题 2：写一个“标准”宏，这个宏输出两个参数并返回较小的一个

答:#define MIN(x, y) ((x)<(y)?(x):(y)) // 结尾没有;

问题 3：# 与 ## 的作用？

答：#是把宏参数转化为字符串的运算符，## 是把两个宏参数连接的运算符。

例如：

define STR(arg) #arg 则宏 STR(hello)开展时为”hello”

define NAME(y) name_y 则宏 NAME(1)开展时仍为 name_y

define NAME(y) name_##y 则宏 NAME(1)开展为 name_1

define DECLARE(name, type) typename##_##type##_type，

则宏 DECLARE(val, int)开展为 int val_int_type

问题 4：如何避免头文件被重复蕴含？

答：

例如，为避免头文件 my_head.h 被重复蕴含，可在其中使用条件编译：

ifndef _MY_HEAD_H

define _MY_HEAD_H /空宏/

/其余语句/

endif

2 关键字
问题 1：static 关键字的作用？

答：

Static 的用途次要有两个，一是用于润饰存储类型使之成为动态存储类型，二是用于润饰链接属性使之成为外部链接属性。

1 动态存储类型：

在函数内定义的动态局部变量，该变量存在内存的动态区，所以即使该函数运行结束，动态变量的值不会被销毁，函数下次运行时能仍用到这个值。

在函数外定义的动态变量——动态全局变量，该变量的作用域只能在定义该变量的文件中，不能被其余文件通过 extern 引用。

2 外部链接属性

   动态函数只能在申明它的源文件中使用。

问题 2：const 关键字的作用？

答：

1 申明常变量，使得指定的变量不能被修改。

const int a = 5;/ a 的值一直为 5，不能被改变/

const int b; b = 10;/ b 的值被赋值为 10 后，不能被改变/

const int ptr; /ptr 为指向整型常量的指针，ptr 的值可能修改，但不能修改其所指向的值 */

int const ptr;/ptr 为指向整型的常量指针，ptr 的值不能修改，但可能修改其所指向的值 */

const int const ptr;/ptr 为指向整型常量的常量指针，ptr 及其指向的值都不能修改 */

2 润饰函数形参，使得形参在函数内不能被修改，示意输出参数。

如 int fun(const int a); 或 int fun(const char *str);

3 润饰函数返回值，使得函数的返回值不能被修改。

const char getstr(void); 使用：const str= getstr();

const int getint(void); 使用：const int a =getint();

问题 3：volatile 关键字的作用？

答：

volatile 指定的关键字可能被零碎、硬件、过程 / 线程改变，强制编译器每次从内存中取得该变量的值，而不是从被优化后的寄存器中读取。例子: 硬件时钟; 多线程中被多个工作共享的变量等。

问题 4：extern 关键字的作用？

答：

1 用于润饰变量或函数，表明该变量或函数都是在别的文件中定义的，提醒编译器在其余文件中寻找定义。

extern int a;

extern int *p;

extern int array[];

extern void fun(void);

其中，在函数的申明带有关键字 extern，仅仅是暗示这个函数可能在别的源文件中定义，没有其余作用。如：

头文件 A：A_MODULE.h 中蕴含

extern int func(int a, int b);

源文件 A: A_MODULE.c 中

include“A_MODULE.h”

int func(int a, int b)

{

     returna+b;

}

此时，开展头文件 A_MODULE.h 后，为

extern int func(int a, int b);/诚然暗示可能在别的源文件中定义，但又在本文件中定义，所以 extern 并没有起到什么作用，但也不会产生谬误/

int func(int a, int b)

{

     returna+b;

}

而源文件 B：B_MODULE.c 中，

include“A_MODULE.h”

int ret = func(10,5);/

开展头文件 A_MODULE.h 后，为

extern int func(int a, int b);/暗示在别的源文件中定义，所以在上面使用 func(5,10)时，在链接的时候到别的目标文件中寻找定义/

int ret = func(10,5);

2 用于 extern“c

extern“c”的作用就是为了能够正确实现 C ++ 代码调用其余 C 语言代码。加上 extern “C” 后，会批示编译器这部分代码按 C 语言的编译形式进行编译，而不是 C ++ 的。

C++ 作为一种与 C 兼容的语言，保留了一部分面向过程语言的个性，如可能定义不属于任何类的全局变量和函数，但 C ++ 毕竟是一种面向对象的语言，为了反对函数的重载，对函数的编译形式与 C 的不同。例如，在 C ++ 中，对函数 void fun(int,int)编译后的名称可能是_fun_int_int，而 C 中没有重载机制，一般间接利用函数名来指定编译后函数的名称，如下面的函数编译后的名称可能是_fun。

这样问题就来了，如果在 C ++ 中调用的函数如上例中的 fun(1,2)是用 C 语言在源文件 a_module.c 中实现和编译的，那么函数 fun 在目标文件 a_module.obj 中的函数名为_fun，而 C ++ 在源文件 b_module.cpp 通过调用其对外提供的头文件 a_module.h 引用后，调用 fun，则间接以 C ++ 的编译形式来编译，使得 fun 编译后在目标文件 b_module.obj 的名称为_fun_int_int，这样在链接的时候，因为_fun_int_int 的函数在目标文件 a_module.obj 中不存在，导致了链接谬误。

解决方法是让 b_module.cpp 知道函数 fun 是用 C 语言实现和编译了，在调用的时候，采纳与 C 语言一样的形式来编译。该方法可能通过 extern“C”来实现（具体用法见上面）。一般，在用 C 语言实现函数的时候，要考虑到这个函数可能会被 C ++ 程序调用，所以在设计头文件时，应该这样申明头文件：

/头文件 a_module.h/

/头文件被 CPP 文件 include 时，CPP 文件中都含有该自定义的宏__cplusplus/

/这样通过 extern“C”告诉 C ++ 编译器，extern“C”{}里蕴含的函数都用 C 的形式来编译/

ifdef __cplusplus

extern“C”

{

endif

extern void fun(int a, int b);

ifdef __cplusplus

}

endif

extern “C” 的使用形式

1. 可能是繁多语句

   extern “C” doublesqrt(double);

2. 可能是复合语句, 相当于复合语句中的申明都加了 extern “C”

   extern “C”

   {

    double sqrt(double);
   
    int min(int, int);
   

   }

3. 可能蕴含头文件，相当于头文件中的申明都加了 extern”C”

extern “C”

{

   #include

}

4. 不可能将 extern”C” 增加在函数外部
5. 如果函数有多个申明，可能都加 extern”C”, 也可能只出现在第一次申明中，前面的申明会接受第一个链接批示符的规定。
6. 除 extern”C”, 还有 extern “FORTRAN” 等。

问题 5：sizeof 关键字的作用？

答：

sizeof 是在编译阶段处理，且不能被编译为机器码。sizeof 的后果等于对象或类型所占的内存字节数。sizeof 的返回值类型为 size_t。

变量：int a; sizeof(a)为 4；

指针：int *p; sizeof(p)为 4；

数组：int b[10]; sizeof(b)为数组的大小，4*10；int c[0]; sizeof(c)等于 0

结构体：struct (int a; char ch;)s1; sizeof(s1)为 8 与结构体字节对齐无关。

注意：不能对结构体中的位域成员使用 sizeof

sizeof(void)等于 1

sizeof(void *)等于 4

3 结构体
问题 1：结构体的赋值？

答：

C 语言中对结构体变量的赋值或者在初始化或者在定义后按字段赋值。

形式 1：初始化

struct tag

{

 chara;

int b;

}x = {‘A’, 1};/初始化/

或

struct tag

{

char a;

int b;

};

struct tag x = {‘A’,1};/在定义变量时初始化/

GNU C 中可使用另外一种形式：

struct tag

{

char a;

int b;

}x =

{

.a =‘A’,

.b =1;

};

或

struct tag

{

char a;

int b;

};

struct tag x =

{

 .a=‘A’,

.b=1,

};

形式 2：定义变量后按字段赋值

struct tag

{

char a;

int b;

};

struct tag x;/定义变量/

x.a =‘A’;/按字段赋值/

x.b = 1; /按字段赋值/

而当你使用初始化的形式来赋值时，如 x = {‘A’,1}; 则出错。

形式 3：结构变量间的赋值

struct tag

{

 chara;

int b;

};

struct tag x,y;

x.a=’A’;

x.b=1;

y = x;/结构变量间间接赋值/

问题 2：结构体变量如何比较？

答：诚然结构体变量之间可能通过 = 间接赋值，但不同通过比较符如 == 来比较，因为比较符只作用于基本数据类型。这个时候，只能通过 int memcmp(const void s1, const void s2, size_t n); 来进行内存上的比较。

问题 3：结构体位域

答：

位域是一个或多个位的字段，不同长度的字段（如申明为 unsigned int 类型）存储于一个或多个其所申明类型的变量中（如整型变量中）。

位域的类型：可能是 char、short、int，少数使用 int，使用时最好带上 signed 或 unsigned

位域的个性：字段可能不命名，如 unsignedint :1; 可用来填充；unsigned int :0; 0 宽度用来强制在下一个整型（因此处是 unsigned int 类型）边陲上对齐。

位域的定义：

struct st1

{

unsigned chara:7;/字段 a 占用了一个字节的 7 个 bit/

unsigned charb:2;/字段 b 占用了 2 个 bit/

unsigned charc:7;/字段 c 占用了 7 个 bit/

}s1;

sizeof(s1)等于 3。因为一个位域字段必须存储在其位域类型的一个单元所占空间中, 不能横跨两个该位域类型的单元。也就是说，当某个位域字段正处于两个该位域类型的单元两头时，只使用第二个单元，第一个单元残余的 bit 地位补（pad）0。

于是可知 Sizeof(s2)等于 3 *sizeof(int)即 12

struct st2

{

unsigned inta:31;

unsigned intb:2;/前一个整型变量只剩下 1 个 bit，容不下 2 个 bit，所以只能存放在下一个整型变量/

unsigned int c:31;

}s2;

位域的好处：

   1. 有些信息在存储时，并不需要占用一个完整的字节，而只需占几个或一个二进制位。例如在存放一个开关量时，只有 0 和 1 两种状态，用一位二进位即可。这样俭约存储空间，而且处理繁缛。这样就可能把几个不同的对象用一个字节的二进制位域来示意。2. 可能很便利的利用位域把一个变量给按位合成。比如只需要 4 个大小在 0 到 3 的随即数，就可能只 rand()一次，而后每个位域取 2 个二进制位即可，省时省空间。

位域的缺点：

不同零碎对位域的处理可能有不同的后果，如位段成员在内存中是从左向右调配的还是从右向左调配的，所以位域的使用不利于程序的可移植性。

问题 4：结构体成员数组大小为 0

结构体数组成员的大小为 0 是 GNU C 的一个个性。好处是可能在结构体中调配不定长的大小。如

typedef struct st

{

    inta;

int b;

char c[0];

}st_t;

sizeof(st_t)等于 8，即 char c[0]的大小为 0.

define SIZE 100

st_t s = (st_t )malloc(sizeof(st_t) + SIZE);

4 函数
问题 1：函数参数入栈次序

答：

C 语言函数参数入栈次序是从右向左的，这是由编译器决定的，更具体的说是函数调用约定决定了参数的入栈次序。C 语言采纳是函数调用约定是__cdecl 的，所以对于函数的申明，完整的形式是：int __cdecl func(int a, int b);

问题 2：inline 内联函数

答：

inline 关键字仅仅是倡导编译器做内联开展处理，即是将函数间接嵌入调用程序的主体，省去了调用 / 返回指令。

5 内存调配回收
问题 1：malloc/free 与 new/delete 的区别

答：

1) malloc 与 free 是 C /C++ 语言的标准库函数，new/delete 是 C ++ 的运算符。它们都可用于申请动态内存和开释内存。

2) 对于非外部数据类型的对象而言，光用 maloc/free 无奈满足动静对象的申请。对象在创建的同时要主动执行结构函数，对象在沦亡之前要主动执行析构函数。因为 malloc/free 是库函数而不是运算符，不在编译器管制权限之内，不能够把执行结构函数和析构函数的工作强加于 malloc/free。因此 C ++ 语言需要一个能实现动态内存调配和初始化工作的运算符 new，以及一个能实现清理与开释内存工作的运算符 delete。注意 new/delete 不是库函数。
咱们不要希图用 malloc/free 来实现动静对象的内存治理，应该用 new/delete。因为外部数据类型的“对象”没有构造与析构的过程，对它们而言 malloc/free 和 new/delete 是等价的。

3) 既然 new/delete 的功能残缺覆盖了 malloc/free，为什么 C ++ 不把 malloc/free 淘汰出局呢？这是因为 C ++ 程序常常要调用 C 函数，而 C 程序只能用 malloc/free 治理动态内存。
如果用 free 开释“new 创建的动静对象”，那么该对象因无奈执行析构函数而可能导致程序出错。如果用 delete 开释“malloc 申请的动态内存”，后果也会导致程序出错，然而该程序的可读性很差。所以 new/delete 必须配对使用，malloc/free 也一样。

问题 2：malloc(0)返回值

答：如果请求的长度为 0，则标准 C 语言函数 malloc 返回一个 null 指针或不能用于拜访对象的非 null 指针，该指针能被 free 安全使用。

6 可变参数列表
可变参数列表是通过宏来实现的，这些宏定义在 stdarg.h 头文件，它是标准库的一部分。这个头文件申明了一个类型 va_list 和三个宏：va_start、va_arg 和 va_end。

typedef char *va_list;

define va_start(ap, A) (void)((ap) = (char *)&(A) + _Bnd(A, _AUPBND))

define va_arg(ap, T) (*(T)((ap) += _Bnd(T, _AUPBND)) – _Bnd(T, _ADNBND)))

define va_end(ap) (void)0

int print(char *format, …)

宏 va_start 的第一个参数是 va_list 类型的变量，第二个参数是省略号前最初一个有名字的参数，功能是初始化 va_list 类型的变量，将其值设置为可变参数的第一个变量。

宏 va_arg 的第一个参数是 va_list 类型的变量，第二个参数是参数列表的下一个参数的类型。va_arg 返回 va_list 变量的值，并使该变量指向下一个可变参数。

宏 va_end 是在 va_arg 拜访完最初一个可变参数之后调用的。

问题 1：实现 printf 函数

/*（转载）

• A simple printf function. Only support the following format:
• Code Format
• %c character
• %d signed integers
• %i signed integers
• %s a string of characters
• %o octal
• %x unsigned hexadecimal
  */

int my_printf(const char* format, …)
{

va_list arg;
int done = 0;

va_start (arg, format); 

while(*format != '\0')
{if( *format == '%')
    {if( *(format+1) == 'c' )
        {char c = (char)va_arg(arg, int);
            putc(c, stdout);
        } else if(*(format+1) == 'd' || *(format+1) == 'i')
        {char store[20];
            int i = va_arg(arg, int);
            char* str = store;
            itoa(i, store, 10);
            while(*str != '\0') putc(*str++, stdout); 
        } else if(*(format+1) == 'o')
        {char store[20];
            int i = va_arg(arg, int);
            char* str = store;
            itoa(i, store, 8);
            while(*str != '\0') putc(*str++, stdout); 
        } else if(*(format+1) == 'x')
        {char store[20];
            int i = va_arg(arg, int);
            char* str = store;
            itoa(i, store, 16);
            while(*str != '\0') putc(*str++, stdout); 
        } else if(*(format+1) == 's' )
        {char* str = va_arg(arg, char*);
            while(*str != '\0') putc(*str++, stdout);
        }

        // Skip this two characters.

        format += 2;
    } else {putc(*format++, stdout);
    }
}

va_end (arg);

return done;

}

7 其余
问题 1：ASSERT()的作用

答:ASSERT()是一个调试程序时常常使用的宏，在程序运行时它计算括号内的表达式，如果表达式为 FALSE (0), 程序将报告谬误，并终止执行。如果表达式不为 0，则继续执行前面的语句。这个宏通常原来判断程序中是否出现了显著非法的数据，如果出现了终止程序免得导致重大后果，同时也便于查找谬误。例如，变量 n 在程序中不应该为 0，如果为 0 可能导致谬误，你可能这样写程序：

……

ASSERT(n != 0);

k = 10/ n;

…..

ASSERT 只有在 Debug 版本中才无效，如果编译为 Release 版本则被忽略。

assert()的功能类似，它是 ANSI C 标准中规定的函数，它与 ASSERT 的一个重要区别是可能用在 Release 版本中。

问题 2：system(“pause”); 的作用

答: 零碎的暂停程序，按任意键持续，屏幕会打印，” 按任意键持续。。。。。” 省去了使用 getchar（）；

问题 3：请问 C ++ 的类和 C 外面的 struct 有什么区别？

答:c++ 中的类具备成员保护功能，并且具备继承，多态这类 oo 个性，而 c 里的 struct 没有。c 外面的 struct 没有成员函数, 不能继承, 派生等等.