本文详细介绍了C/C++编程中的预处理指令，如#define、#include、条件编译等，以及static、const、volatile、extern等关键字的作用。此外，还讲解了结构体的使用，包括赋值、比较和位域，并讨论了内联函数、内存管理和可变参数列表。最后，文章提到了函数参数入栈顺序、系统调用和常见的编程陷阱。
预处理相关
问题1：什么是预编译？何时需要预编译？
答：
预编译又称预处理，是整个编译过程最先做的工作，即程序执行前的一些预处理工作。主要处理#开头的指令。如拷贝#include包含的的文件代码、替换#define定义的宏、条件编译#if等。
何时需要预编译：
总是使用不经常改动的大型代码体。
程序由多个模块组成，所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下可以将所有包含文件预编译为一个预编译头。
问题2：写一个“标准”宏，这个宏输入两个参数并返回较小的一个。
#define MIN(x,y)((x)<(y)?(x):(y)) //结尾没有分号（;）
问题3：#与##的作用？
答：
#表示：是把宏参数转化为字符串的运算符。
##表示：是把两个宏参数名与宏定义代码序列中的标识符连接在一起，形成一个新的标识符。
示例1：
#define NAME(y) name_y //宏NAME(1)展开时仍然为name_y
#define NMAE(y) name_##y //宏NAME(1)展开时为name_1
#define DECLARE(name,type) type name##_##type##type //宏DECLARE(val,int)展开为int val_int_type
示例2：
// #表示：对应变量字符串化
// ##表示：把宏参数名与宏定义代码序列中的标识符连接在一起，形成一个新的标识符
#include <stdio.h>
#define trace(x, format) printf(#x " = %" #format "\n", x)
#define trace2(i) trace(x##i, d)
int main()
{
int i=1;
char *s="three";
float x=2.0;
trace(i, d); // 相当于 printf("x = %d\n", x)
trace(x, f); // 相当于 printf("x = %f\n", x)
trace(s, s); // 相当于 printf("x = %s\n", x)
int x1=1, x2=2, x3=3;
trace2(1); // 相当于 trace(x1, d)
trace2(2); // 相当于 trace(x2, d)
trace2(3); // 相当于 trace(x3, d)
return 0;
}
问题4：如何避免头文件重复包含？
答：
&esmp;&esmp;例如避免my_head.h被重复包含，可以使用条件编译：
示例1：
#ifndef _MY_HEAD_H
#define _MY_HEAD_H /*一个空的宏*/
/*其他语句*/
#endif //与#ifndef配套使用
问题5：C指令及用途？
//指令 用途
# //空指令，无任何效果
#include //包含一个源代码文件
#define //定义宏
#undef //取消已经定义的宏
#if //如果给定条件为真，则编译下面代码
#ifdef //如果宏已经定义，则编译下面代码
#ifndef //如果宏没有定义，则编译下面代码
#elif //如果前面的#if给定条件不为真，当前条件为真，则编译下面代码
#endif //结束一个#if...#else条件编译块
#error //停止编译并显示错误信息
关键字相关
问题1：static关键字的作用？
答：
Static的用途主要有两个：一是用于修饰存储类型使之成为静态存储类型，二是用于修饰链接属性使之成为内部链接属性。
-
静态存储类型：
在函数内定义的静态局部变量，该变量存在内存的静态区，所以即使该函数运行结束，静态变量的值不会销毁，函数下次运行时能仍到这个值。
在函数外定义的静态变量——静态全局变量，该变量的作用域只能在定义该变量的文件中，不能被其他文件通过extern引用。 -
内部链接属性
静态函数只能在声明它的源文件使用。
问题2：const关键字的作用？
答：
const的用法有四种：参数、返回值、函数,用const修饰变量将限定变量为只读，该变量值不允许被改变。使用const还可以节省内存空间。
const与define的区别
define：定义预编译时处理的宏；只进行简单的字符替换，无类型检测
const：定义程序中的常量，编译时处理；常量修饰符，把变量定义为常量。
- 声明常变量，使得指定的变量不能被修改。
const int a = 5; //a的值一直为5，不能被改变
const int b; b = 10; //b的值被赋值为10后，不能被改变
const int *ptr; //ptr为指向整型常量的指针，ptr的值可以修改，但是不能修改其所指向的值
int *cont ptr; //ptr为指向整型的常量指针，ptr的值不可修改，但是可以修改其所指向的值
const int *const ptr; //ptr为指向整型常量的常量指针，ptr及其指向的值不能修改
- 修饰函数形参，使得形参在函数内不能被修改，表示输入参数。
int fun(const int a);
int fun (const char *str);
- 修饰函数返回值，使得函数的返回值不能被修改。
const char *getser(void); //使用：const *str = getstr();
const int getint(void); //使用：const int a = getint();
第一，限定一个只读变量（不是常量）。如const double PI=3.14；
第二，限定函数参数，如，void function(const char *p) //函数只能读取不能改变其变量p的值
问题3：volatile关键字的作用？
答：
volatile指定的关键字可能被系统、硬件、进程、线程改变，强制编译器每次从内存中取得该变量的值，而不是从被优化后的寄存器中读取。例子：硬件时钟；多线程中多个任务共享的变量等。
volatile影响编译器编译的结果,指出，volatile变量是随时可能发生变化的，与volatile变量有关的运算，不要进行编译优化，以免出错。
问题4：extern关键字的作用？
答：
- 用于修饰变量或函数，表明该变量或函数都是在别的文件中定义的，提示编译器在其他文件中寻址定义。
extern int a;
extern int *p;
extern int array[];
extern void fun(void);
其中，在函数的声明带有关键字extern，仅仅是暗示这个函数可能在别的原文件中定义，没有其他作用。
例如：
/*A_MY.h中包含*/
extern int func(int a,int b);
/*源文件A_MY.c中*/
#include "A_MY.c"
int func(int a,int b)
{
return a+b;
}
此时，展开头文件A_MY.h后为extern int func(int a,int b); /*虽然暗示可能在别的源文件中定义，但又在本文件中定义，所以extern并备有起到什么作用，也不会产生错误*/
而源文件B：B_MY.c中，
#include "A_MY.h"
int ret = fun(10,5);
展开头文件后，为extern int func(int a,int b); /*暗示在别的源文件中定义，所以在下面使用func(10,5)时，在链接的时候到别的目标文件中寻找定义*/
- 由于
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_MY.c中实现和编译的，那么函数fun在目标文件A_MY.obj中的函数名为_fun，而C++在源文件B_MY.cpp通过调用其对外提供的头文件a_module.h引用后，调用fun，则直接以C++的编译方式来编译，使得fun编译后在目标文件B_MY.obj的名称为_fun_int_int，这样在链接的时候，因为*_fun_int_int的函数在目标文件A_MY.obj*中不存在，导致了链接错误。
解决方法是让B_MY.cpp知道函数fun是用C语言实现和编译了，在调用的时候，采用与C语言一样的方式来编译。该方法可以通过extern “C”来实现（具体用法见下面）。一般，在用C语言实现函数的时候，要考虑到这个函数可能会被C++程序调用，所以在设计头文件时，应该这样声明头文件：
/头文件A_MY.h/
/头文件被CPP文件include时，CPP文件中都含有该自定义的宏__cplusplus/
/这样通过extern “C”告诉C++编译器，extern “C”{}里包含的函数都用C的方式来编译/
extern "C"的使用方式
- 可以是单一语句
extern "C" doublesqrt(double);
- 可以是复合语句, 相当于复合语句中的声明都加了extern “C”
extern "C"
{
double sqrt(double);
int min(int, int);
}
3.可以包含头文件，相当于头文件中的声明都加了extern"C"
extern "C"
{
#include <cmath>
}
-
不可以将extern"C" 添加在函数内部
-
如果函数有多个声明，可以都加extern"C", 也可以只出现在第一次声明中，后面的声明会接受第一个链接指示符的规则。
-
除extern"C", 还有extern “FORTRAN” 等。
问题5：sizeof关键字的作用？
答：
sizeof是在预编译阶段处理，且不能被编译为机械码。sizeof的结果等于对象或类型所占的内存字节数。
sizeof的返回值类型为size_t
int a;sizeof(a); //值为4
int *p;sizeof()p; //值为4
int arr[10];sizeof(arr); //值为4*10
struct
{int a;char ch;}s1;
sizeof(s1); //值为8，结构体的大小与字节对齐有关，4字节对齐
sizeof(void); //等于1
sizeof(void *); //等于4
问题6：typedef关键字的作用？
用来定义一种类型的别名，这样，可以用它来连续定义变量，而不是简单的宏替换，比如：
typedef char *PCHAR;
PCHAR pa,pb; //用类型别名定义了两个char*类型的指针变量
在C时代，定义了一个结构体之后，再使用的时候还要加上struct关键字才能用来定义变量，这样会比较麻烦，而使用typedef来定义之后，就可以不用写struct关键字了，比如：
typedef struct tagPOINT
{
int x;
int y;
}POINT;
POINT p1; //用结构体类型别名声明了一个结构体变量
当然,，C++里可以不用这样，因为C++使用结构体的时候不需要加struct关键字；
用typedef来定义与平台无关的类型。比如你有一个跨平台的项目，需要统一使用一种双精度浮点型的类型，而在一些平台上可能没有这种实现，或者实现不同，这时候你就可以根据不同的平台来定义你自己的类型4，用来使复杂的定义简单化，最常用的就是给函数指针定义一个别名所以，总的来说，typedef并不是"发明"了另外一种新类型，而相当于是一种类型的别名，为了方便使用。
结构体有关
问题1：结构体的赋值？
答：
C语言中对结构体变量的幅值或者在初始化或者在定义后按字段幅值。
方式1：初始化时进行赋值操作。
struct tag
{
char a;
int b;
}x ={'A',1}; /*初始化1*/
struct tag
{
char a;
int b;
};
struct tag x = {'A',2}; /*在定义变量时初始化2*/
//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
{
char a;
int b;
};
struct tag x,y;
x.a = 'A';
x.b = 1;
y = x; //结构变量间的直接赋值
问题2：结构体变量如何比较？
答：
虽然结构体变量之间可以通过"="直接赋值，但是不能通过比较符如“==”来比较，因为比较符只作用于基本数据类型。这时候只能通过int memcmp(const void *s1, const void *s2, size_tn);来进行内存上的比较。
问题3：结构体位域。
答：
位域是一个或多个位的字段，不同长度的字段（如声明为unsigned int类型）存储于一个或多个其所声明类型的变量中（如整型变量中）。
位域的类型： 可以是 char、short、int， 多数使用 int，使用时最好带上signed或unsigned。
位域的特点: 字段可以不命名，如unsigned int：1；可以用来填充；unsigned int:0;0宽度用来强制在下一个整型（因此处是 unsigned int 类型）边界上对齐。
位域的定义：
struct st1
{
unsigned char a:7; //字段a占用一个字节的7个bit
unsigned char b:2; //字段b占用了2个bit
unsigned char c:7; //字段c占用了7个bit
}s1;
sizeof(s1);
//s1的大小是3，因为一个位域字段必须存储在其位域类型的一个单元所占空间中，不能横跨拉另个该位域类型的单元，
//也就是说，当某个位域字段正处于两个该位域类型的单元中间时，只使用第二个单元，第一个单元剩余的bit位补0.
struct st2
{
unsigned int a:31;
unsigned int b:2; //前一个整型变量只剩下1个bit，容不下2个bit，所以只能存放在下一个整型变量中
unsigned int c:31;
}s2;
sizeof(s2); //其值是3*sizeof(int),即12
位域的好处：
1. 有些信息在存储时，并不需要占用一个完整的字节，而只需要占用几个或一个二进制位bit位。例如在存放一个开关量时，只用到了0和1两种状态，只用到了一位二进制位。这样节省存储空间，而且处理简便。这样就可以把几个不同的对象用一个字节的二进制位域来表示。
2. 可以很方便的利用位域把一个变量给按位分解。比如只需要4个大小在0到3的随机数，就可以rand()一次，然后每个位域取2个二进制位即可，省时省空间。
位域的缺点：
不同系统对位域的处理可能有不同的结果，如位段成员在内存中是从左向右分配的还是从右向左分配的（大端序、小端序），所以位域的使用不利于程序的可移植性。
问题4：结构体成员数组大小为0。
结构体数组成员的大小为0是GNU C的一个特性。好处是可以在结构体中分配不定长的大小。如：
typedef struct st
{
int a;
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);
#include <stdio.h>
struct str
{
int len;
char s[0];
};
struct foo
{
struct str *a;
};
int main(int argc, char** argv) {
struct foo f={0};
if (f.a->s)
{
printf( f.a->s); //这一行出问题
}
return 0;
}
把出问题的一行改为printf("%x\n",f.a->s);程序输出4，访问0*4的内存地址，才会有问题。
挠头“要死了！”
1）为什么不是 13行if语句出错？f.a被初始化为空了嘛，用空指针访问成员变量为什么不crash？
2）为什么会访问到了0×4的地址？靠，4是怎么出来的？
3）代码中的第4行，char s[0] 是个什么东西？零长度的数组？为什么要这样玩？
函数相关问题
问题1：函数参数入栈顺序
答：
C语言函数参数入栈顺序是从右向左的，这是由编译器决定的，更具体的对的说是函数调用约定决定了参数的入栈顺序。C语言采用是函数调用约定是 _cdecl的，所以对于函数声明，完整形式是int _cdecl func(int a,int b);
问题2：inline内联函数。
答：
inline关键字仅仅是建议编译器做内联展开处理，即是将函数直接嵌入调用程序的主体，省去了调用、返回指令。
内存分配回收
问题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)返回值
答：
如果请求的长度为零，则标准C语言函数malloc返回一个NULL指针或不能用于访问对象的非NULL指针，该指针被free安全使用。
可变参数列表
可变参数列表是通过宏来实现的，这些宏定义在stdarg.h头文件，它是标准库的一部分。这个头文件声明了一个类型va_list和三个宏：va_start、va_arg和va_end。
问题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;
}
其他问题
问题1：system("pause");的作用
答：系统的暂停程序，按任意键继续，屏幕会打印。“按任意键继续。。。。”省去了使用getchar();
问题2：请问C++的类和C里面的struct有什么区别？
答:c++中的类具有成员保护功能，并且具有继承，多态这类oo特点，而c里的struct没有。c里面的struct没有成员函数,不能继承,派生等等.
问题2：逗号运算符的作用。
答：
可以将两个（或多个）表达式连接起来，优先级最低。
int a;
3+5,6+8; //先求解表达式1，在求解表达式2.整个逗号表达式的值就是表达式2的值。“14”
a=3*5,a*4; //先求解表达式1，a=15，再求解表达式2，整个表达式的值为60，a仍为15
（a=3*5,a*4）,a+5; //两个“，”表达式组合，整个标的是的值为20，a仍诶15.
x=(a=3,6*3); //是一个赋值表达式，将一个逗号表达式的值赋值给x，x的值为18，a的值为3
x=a=3,6*3; //表达式的值是18，x、a的值为3。
找错题
题目1：
void test1()
{
char string[10];
char* str1 = "0123456789";
strcpy(string, str1);
}
解答： 字符串str1有11个字节（包括末尾的结束符’\0’），而string只有10个字节，故而strcpy会导致数组string越界。
题目2：
void test2()
{
char string[10], str1[10];
int i;
for(i=0; i<10; i++)
{
str1= 'a';
}
strcpy(string, str1);
}
解答： 因为str1没有结束符’\0’，故而strcpy复制的字符数不确定。strcpy源码如下：
#include <string.h>
char *strcpy(char *s1, cosnt char *s2)
{
char *s = s1;
for (s = s1; (*s++ = *s2++) != '\0';); /*最后的结束符'\0'也会被复制*/
return s1;
}
题目3：
void test3(char* str1)
{
char string[10];
if(strlen(str1) <= 10 )
{
strcpy(string, str1);
}
}
解答： 应修改为if (strlen(str1) < 10)，因为strlen的结果未统计最后的结束符’\0’。strlen的源码如下：
#include <string.h>
size_t strlen(const char *s)
{
const char *sc;
for (sc = s; *sc != '\0'; ++sc)/*不包含最后的结束符'\0'*/
;
return (sc - s);
}
题目4：
void GetMemory(char *p)
{
p = (char *)malloc( 100 );
}
void Test( void )
{
char *str = NULL;
GetMemory(str);
strcpy(str,"hello world");
printf(str);
}
解答： C语言中的函数参数为传值参数，在函数内对形参的修改并不能改变对应实参的值。故而调用GetMemory后，str仍为NULL。
题目5：
扫一扫
6641
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
