1.预处理
1)问题1:什么是预编译?何时需要预编译?
答:预编译又称预处理,是整个编译过程最先做的工作,即程序执行前的一些预处理工作。主要处理#开头的指令。如拷贝#include包含的文件代码、替换#define定义的宏、条件编译#if等。.
2)问题2:何时需要预编译?
答:总是使用不经常改动的大型代码体。
程序由多个模块组成,所有模块都使用一组标准的包含文件和相同的编译选项。在这种情况下,可以将所有包含文件预编译为一个预编译头。
3)问题3:写一个“标准”宏,这个宏输入两个参数并返回较小的一个
答:#define MIN(x, y) ((x)<(y)?(x):(y)) //结尾没有;
4)问题4:#与##的作用?
答:#是把宏参数转化为字符串的运算符,##是把两个宏参数连接的运算符。
例如:
#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
5)问题5)如何避免头文件被重复包含?
答:例如,为避免头文件my_head.h被重复包含,可在其中使用条件编译。
#ifndef _MY_HEAD_H
#define _MY_HEAD_H /*空宏*/
/*其他语句*/
#endif
2.关键字
1)问题1:static关键字的作用?
答:Static的用途主要有两个,一是用于修饰存储类型使之成为静态存储类型,二是用于修饰链接属性使之成为内部链接属性。
(1)静态存储类型:
在函数内定义的静态局部变量,该变量存在内存的静态区,所以即使该函数运行结束,静态变量的值不会被销毁,函数下次运行时能仍用到这个值。
在函数外定义的静态变量——静态全局变量,该变量的作用域只能在定义该变量的文件中,不能被其他文件通过extern引用。
(2)内部链接属性
静态函数只能在声明它的源文件中使用。
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)问题3:volatile关键字的作用?
答:volatile指定的关键字可能被系统、硬件、进程/线程改变,强制编译器每次从内存中取得该变量的值,而不是从被优化后的寄存器中读取。例子:硬件时钟;多线程中被多个任务共享的变量等。
4)问题4:extern关键字的作用?
答:用于修饰变量或函数,表明该变量或函数都是在别的文件中定义的,提示编译器在其他文件中寻找定义。
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);
5)问题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)问题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)问题2:结构体变量如何比较?
答:虽然结构体变量之间可以通过=直接赋值,但不同通过比较符如==来比较,因为比较符只作用于基本数据类型。这个时候,只能通过int memcmp(const void *s1, const void *s2, size_t n);来进行内存上的比较。
4.函数
1)问题1:函数参数入栈顺序
答:C语言函数参数入栈顺序是从右向左的,这是由编译器决定的,更具体的说是函数调用约定决定了参数的入栈顺序。C语言采用是函数调用约定是__cdecl的,所以对于函数的声明,完整的形式是:int __cdecl func(int a, int b);
2)问题2:inline内联函数
答:inline关键字仅仅是建议编译器做内联展开处理,即是将函数直接嵌入调用程序的主体,省去了调用/返回指令。
5 .内存分配回收
1)问题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)问题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;
}