经验：
1、一个函数只实现相应的一个单功能
2、用extern声明外部变量
(1)在同一个文件内，若定义在文件中间，要在文件前面使用，可以在前面用extern声明
(2)在相关联的不同的文件内，若文件A定义了变量a，文件B要使用变量a，若都定义变量a会出现重复定义错误，在文件B中只要加上extern a(不用加类型如int，但建议加上，否则可能出现不可预期的错误，实际操作中的经验)，就可以使用(如果不想要某变量被另一个文件外部引用，可以加上static以防止外部引用)
3、关于变量的声明和定义
一般为了叙述方便，把建立存储空间的声明称为定义，而把不需要建立存储空间的声明称为声明。
4、typedef的用法
typedef int INTEGER 这样在程序中可以用INTEGER代替int来进行定义，如INTERGER a;
typedef struct
{
int month;
int day;
int year;
}DATE; 这样可以用DATE定义变量:DATE birthday; DATE *p;它代表一个结构体类型
typedef int NUM[100]; 这样直接用NUM n; 就可以定义整型数组变量n
typedef int ARR[10]; 这样用ARR a,b,c就等同于int a[10],b[10],c[10];
typedef 与 #define的区别：(如typedef int COUNT与 #define COUNT int)
#define 在预编译时处理，它只能做简单的字符串替换，而typedef是编译时处理的，并非简单替换。typedef有利于程序的通用和移植
typedef int (*pcb)(int , int) ;
pcb p1,p2;
以上等价于： int (*p1)(int,int);
int (*p2)(int,int);
5、数组的用法
char a[10]; 定义一个数组
char *p; 定义了一个指针
对指针p进行附初值时可以: p = &a[0]; 或 p = a; 也可以在定义时赋 char *p = a(或者&a[0]);
p+i 和 a+i 就是a[i]的地址值,也就是说p+1或a+1是指向数组中的下一个元素
*(p+i) 和*(a+i)是p+i 和 a+i指向的数组元素，即a[i]
指向数组的指针变量也可以带下标, 如p[i]与*(p+i)等价
引用一个数组元素有以下方法: a[i] ; *(a+i) ; *(p+i)
对一个数组赋值,可以a[10] = {'a','b','c','d','e','f'};
a[10] = {"hello!"}; 长度为7,末尾自动加上'/0'结束符
a[10] = "hello!";
关于释放指针
int *point = new int(10);
int *pointArray = new int[4];
释放是， delete point;
delete [ ] pointArray; //如果delete pointArray 会造成内存泄漏
6、sizeof
(1)用于数据类型 : sizeof(type); 如 sizeof(int) 结果为4，表示4个字节
(2)用于变量: sizeof(var_name);或者sizeof var_name; 带括号的用法更普遍
(注意：sizeof操作符不能用于函数类型，不完全类型或位字段)
(3)sizeof 的操作结果：sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型
I.若操作数具有类型char、unsigned char或signed char，其结果等于1
II.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。
III.当操作数具有数组类型时，其结果是数组的总字节数
IIII.联合类型操作数的sizeof是其最大字节成员的字节数
IIIII.如果操作数是函数中的数组形参或函数类型的形参，sizeof给出其指针的大小
(4)主要用途
I.sizeof操作符的一个主要用途是与存储分配和I/O系统那样的例程进行通信
II.sizeof的另一个的主要用途是计算数组中元素的个数
7、对于位移动"<<" ">>" 左右移动都是补0
如0x01<<1 得到0x02 0x80右移一位得到0x40;
移位只针对C标准中的char和int类型，因此不能对float，double等进行位操作
8、选择输出类型
如果一个数a=10；分别输出它的十进制、八进制、十六进制为：
cout<<dec<<a<<' ' //输出十进制数
<<oct<<a<<' ' //输出八进制数
<<hex<<a<<endl; //输出十六进制数
9、(一) 无名的函数形参
声明函数时可以包含一个或多个用不到的形式参数。这种情况多出现在用一个通用的函数指针调用多个函数的场合，其中有些函数不需要函数指针声明中的所有参数。看下面的例子：
int fun(int x,int y)
{
return x*2;
}
尽管这样的用法是正确的，但大多数C和C++的编译器都会给出一个警告，说参数y在程序中没有被用到。为了避免这样的警告，C++允许声明一个无名形参，以告诉编译器存在该参数，且调用者需要为其传递一个实际参数，但是函数不会用到这个参数。下面给出使用了无名参数的C++函数代码：
int fun(int x,int) //注意不同点
{
return x*2;
}
(二) 函数的默认参数
C++函数的原型中可以声明一个或多个带有默认值的参数。如果调用函数时，省略了相应的实际参数，那么编译器就会把默认值作为实际参数。可以这样来声明具有默认参数的C++函数原型：
#include "iostream.h"
void show(int=1,float=2.3,long=6);
int main()
{
show();
show(2);
show(4,5.6);
show(8,12.34,50L);
return 0;
}
void show(int first,float second,long third)
{
cout<<"first="<<first
<<"second="<<second
<<"third="<<third<<endl;
}
10、static的用法
(1)表示退出一个块后依然存在的局部变量/* 可以解决频繁调用某函数时某个初始变量不变的问题 */
(2)表示不能被其他文件访问的全局变量和函数
(3)属于类且不属于类对象的变量和函数
11、变量作用域
C++语言中，允许变量定义语句在程序中的任何地方，只要在是使用它之前就可以；而C语言中，必须要在函数开头部分。而且C++允许重复定义变量，C语言也是做不到这一点的。看下面的程序：
#include "iostream.h"
int a;
int main()
{
cin>>a;
for(int i=1;i<=10;i++) //C语言中，不允许在这里定义变量
{
static int a=0; //C语言中，同一函数块，不允许有同名变量
a+=i;
cout<<::a<<" "<<a<<endl;
}
return 0;
}
12、输出一些预定义的内容
cerr<<__FILE__ //输出正在被编译的文件名字，包含路径
<<__LINE__ //记录文件已经编译的行数
<<__DATE__
<<__TIME__
13、assert()
assert()是c语言标准库中提供的一个通用预处理器宏。在代码中长利用assert()来判断一个必需的前提条件，以便程序能够正确执行。需包含头文件#include<assert.h> assert.h是C库头文件的C名字，C++库头文件的C++名字总是以字母C开头，后面是去掉后缀.h的C名字
使用断言来发现软件问题，提高代码可测性。
说明：断言是对某种假设条件进行检查（可理解为若条件成立则无动作，否则应报告），它可以快速发现并定位软件问题，同时对系统错误进行自动报警。断言可以对在系统中隐藏很深，用其它手段极难发现的问题进行定位，从而缩短软件问题定位时间，提高系统的可测性。实际应用时，可根据具体情况灵活地设计断言。
示例：下面是C语言中的一个断言，用宏来设计的。（其中NULL为0L）
#ifdef _EXAM_ASSERT_TEST_ // 若使用断言测试
void exam_assert( char * file_name, unsigned int line_no )
{
printf( "/n[EXAM]Assert failed: %s, line %u/n",
file_name, line_no );
abort( );
}
#define EXAM_ASSERT( condition )
if (condition) // 若条件成立，则无动作
NULL;
else // 否则报告
exam_assert( __FILE__, __LINE__ )
#else // 若不使用断言测试
#define EXAM_ASSERT(condition) NULL
#endif /* end of ASSERT */
14、include 预处理器指示符preprocessor include directive
#include<>表示这个文件是一个工程或标准头文件，查找过程会检查预定义的目录。可通过设置搜索路径环境变量或命令行选项来修改这些目录。 #include" " 表明该文件是用户提供的头文件，查找该文件时将从当前文件目录开始
15、exit()
标准库函数exit()终止程序的执行。当函数中出现exit()时，该函数会立即结束全部程序，强制返回操作系统。
exit()的作用类似于跳出整个程序。
exit()的一般形式为void exit(int return_code);
其中返回值return_code将送回调用过程，一般是操作系统。按照管理，0值一般表示正常结束，非0值表示某种错误。
该函数包含在<stdlib.h>头文件中
16、变量的存储类别（从变量值的存在时间角度来分）
(1)静态存储变量: 编译时分配存储空间的变量
定义形式 变量定义前面加static，如static int a = 8;
(2)动态存储变量: 程序运行期间分配固定的存储空间
可以是函数的形参、局部变量、函数调用时的现场保护和返回地址。这些变量函数调用时分配存储空间，函数结束时释放存储空间。
定义形式 变量定义前面加auto ，如auto int a,b,c 可省略不写。
17、 printf格式字符
格式字符 说明
d,i 以带符号的十进制形式输出整数(整数不输出符号)
o 以八进制无符号形式输出整数(不输出前导符o)
x,X 以十六进制无符号形式输出整数(不输出前导符0x)，用x输出十六进制数的a~f时以小写形式输出，用X时则以大 写字母输出
u 以无符号十进制形式输出整数
c 以字符形式输出,只输出一格字符
s 输出字符串
f 以小数形式输出单、双精度数，隐含输出6位小数。
e,E 以指数形式输出实数
g，G 选用%f,或%e格式中输出宽度较短的一种格式，不输出无意义的0.
附加格式
字母l 用于长整型整型，可加在格式符d、o、x、u前面
m(代表一个正整数) 数据最小宽度
n(代表一个正整数) 对实数，表示输出n位小数；对字符串，表示截取的字符个数
- 输出的数字或字符在域内向左靠
在c语言中 ，printf("%-8d",a);即可在8个宽度内以左靠的形式显示字符。
printf("%-5.2f",a);可以在以左靠5个宽度内输出两位精度的浮点数
在c++中 ，cout<<a<<setw(8)<<b<<endl;空8个宽度再输出，需要包含头文件<iomanip>
18、大小写转换函数
toupper函数，原型int toupper(int ch),作用是在ch为字母时，返回等价的大写字母；否则返回的ch值不变。toupper即to-upper的以此函数和toupper类似，只是返回等价小写字母。
两个函数包含在<ctype.h>中
19、枚举类型enum
enum weekday{sun,mon,tue,wed,thu,fri,sta}workday,week_end;
对枚举变量赋值不能超过它的范围。weekday中的值依次是0，1，2，3，4，5，6
20、结构体struct和联合体union
struct Student
{
int num;
char name[];
int age;
int score[3];
}stu[3];
也可以使用typedef
typedef struct
{
int num;
char name[];
int age;
int score[3];
}Student;
定义时直接可以使用 Student stu[3];
对于联合体
union Description
{
int a;
char b;
double c;
}des;
可以进行赋值，des.a = 1;或des.b = 'a';或des.c = 30.11;
也可以
typedef union
{
int a;
char b;
double c;
}Description;
可以定义变量 Description des;
des.a = 1;或des.b = 'a';或des.c = 30.11;
该联合体中3个定义共占一个内存，长度为占用长度最长的那个变量长度。这里是double。
每次只能使用3个中的一个，如des.a =1;然后可以输出值，如果des.a = 1;des.b='a';printf("%d,%s",des.a,des.b);只会产生一个值。
21、引用
对一个数据的可以使用“引用”(reference),这是C++对C的一个重要扩充。C++之所以增加引用类型，主要是把它作为函数参数，以扩充函数传递数据的功能。
引用是一种新的变量类型，它的作用是为一个变量起一格别名。(就自己的理解来说，引用操作的是变量的地址，而非变量本身的值)
声明方法：int a;
int &b = a;
说明：(1)a或b作用相同，都代表同一变量，声明变量b为引用类型并不需要重新开辟地址
(2)&是引用声明符，并不代表地址
(3)在声明一个引用类型变量时，必须同时使之初始化，即声明它代表哪一个变量 。
(4)在声明变量b是变量a的引用后，在它们所在的函数执行期间，该引用类型变量b始终与其代表的变量a联系，不能再做其他变量的引用。如 int a1,a2;
int &b = a1;
int &b = a2;//企图使b又变成a2的引用是不行的
引用作为函数参数。
函数参数传递的两种情况。
(1)将变量名作为实参和形参
(2)传递变量的指针。
int main()
{
void swap(int ,int);
int i = 3,j = 5;
swap(i,j);
...
}
void swap(int a,int b)//将变量名作为实参和形参
{
int temp;
temp = a;
a = b;
b = temp;
}
运行时输出还是3 5，没有进行交换。将变量作为实参和形参，传给形参的是变量的值，传递是单向的。如果在执行函数期间形参的值发生变化，并不传回给实参。因为在调用函数时，形参和实参不是同一存储单元。
int main()
{
void swap(int *,int *);
int i = 3,i = 5;
swap(&i,&j);
cout<<i<<" "<<j<<endl;
return 0;
}
void swap(int *p1,int *p2)
{
int temp;
temp = *p1;
*p1 = *p2;
*p2 = temp;
}
调用函数时把变量i和j的地址传给形参p1和p2(它们是指针变量)，因此*p1和i为同一内存单元，*p2和j为同一内存单元。
这种虚实传递仍然是“值传递”方式，只是实参的值是变量的地址而已。
int main()
{
void swap(int &,int &);
int i=3,j=5;
swap(i,j);
....
}
void swap(int &a,int &b)
{
int temp;
temp = a;
a = b;
b = temp;
}
在swap函数的形参列表中声明a和b是整型变量的引用。注意，此处&a不是a的地址，而是指“a是一个引用型变量”，&是引用型变量的声明符。此时并没有对它们初始化，即没有指定它们是哪个变量的别名，它们也不占存储单元。当main调用函数时，由实参将变量名传给形参，i的名字传给引用变量a，这样a就成了i的别名。
其实虚实结合时是把实参i的地址传到形参a，是形参a的地址取实参i的地址，让a和i共享同一单元。这就是地址传递方式。
与使用指针变量作形参时有什么不同？
1、使用引用类型不必在swap函数中申明形参是指针变量。指针变量要另外开辟内存单元，其内容是地址。‘
2、在main函数中调用swap时，实参不必用变量地址。系统向形参传送的是实参的地址而不是实参的值。
22、数值型和字符型数据的字节数和数值范围（依据谭浩强C++）
类型标志符 字节 数值范围
int 4 32位 (c中是16位)
unsigned int 4 32
short 2 16位
long 4 32位 -2147483648～+2147483647
char 1 8位 -128～127
unsigned char 1 8 0～255
float 4 32 3.4*10e(-38)～3.4*10e(38)
double 8 64
long double 8 64(c中为80位)
23、指针的一些用法和注意
定义指针 int *p; //这里的*是指针声明符号
int a = 5;
p = &a;
printf("%d",*p); //这里的*是指针运算符，它表示“指向”，*p指p所指向的内容
区别 变量的指针 和 指向变量的指针变量；前者是指变量的地址，后者是指针变量，用来指向另一个变量。比如上面p就是指针变量，而&a是a的指针，即p的内容。
关于形参实参的值传递，单向传递的问题：
int main()
{
int x=5,y=9;
int *point1,*point2;
point1 = &x,point2 = &y;
swap(...);
printf("%d,%d",a,b);
}
写一个swap()函数来实现两个数交换。
(1) void swap(int *p1,int *p2)
(2) void swap(int a, int b)
void swap(int *p1,int *p2)
{
int tmp;
tmp = *p1;
*p1 = *p2; //指针变量所指向的变量值发生改变，在函数调用结束后依然保留
*p2 = tmp;
}
void swap(int a, int b)
{
int tmp;
tmp = a;
a = b;
b = tmp;
}
对于当调用函数void swap(int *p1,int *p2)来实现时，输出为9，5，即实现了两个数的交换；而调用void swap(int a, int b)时，输出仍然为5，9；
这里需要注意的问题是: 什么是函数调用时，实参变量的值传给形参变量。这里即调用函数swap(point1,point2)时，实参变量point1、point2的值传给了形参变量p1，p2。
“值传递”是单向的。这句话是说实参将值传给形参以后，形参无论进行什么操作，都无法将其值再回送给实参，即形参无法再改变实参的值。swap(int a, int b)就是这种情况。为了使在函数中改变了的变量值能被main函数所使用，不能采取上述把要改变值的变量作为参数传给形参的办法，而应该用指针变量作为函数参数。在函数执行过程中，指针变量所指向的变量值发生该变，函数调用结束后，变量值依然保存。
24、volatile
一般说来，volatile用在如下的几个地方：
1、中断服务程序中修改的供其它程序检测的变量需要加volatile；
2、多任务环境下各任务间共享的标志应该加volatile；
3、存储器映射的硬件寄存器通常也要加volatile说明，因为每次对它的读写都可能由不同意义；
25、类模板 template<class 类型参数名>
为了解决类里面的类型参数问题。与typedef int DataType这种感觉差不多。就是为了使同一作用的类对不同数据类型都有效。
具体使用方法：
template<class numtype>
class Compare
{
private :
numtype x,y;
public:
Compare(numtype a,numtype b)
{x = a; y = b;}
numtype max()
{return (x>y)?x:y;}
}
main()
{
Compare<int> cmp1(3,7); //注意这里再Compare后加<数据类型>
cout<<cmp1.max();
Compare<float> cmp2(3.1,7.5);
cout<<cmp2.max();
}
注意，类模板的类型参数还可以有多个，每个类型前面都必须加class
template<class t1,class t2>
class someclass
{...};
在定义时分别代入实际类型名，如 someclass<int,float> obj;
26、文件操作 FILE
文件操作主要涉及到几个函数：fopen，fwrite，fread，fclose。
1、要创建文件指针：FILE *fp;
2、可以利用fopen先创建一个没有的文件 fp=fopen("new.txt","w"),也可以利用它打开一个已有文件，但文件内容会被清空，可查询fopen中各打开类型的用法。
3、利用fwrite函数写数据。size_t fwrite( void* buffer, //要写的数据的指针，比如要写int a=10;就给&a
size_t size, //写的数据类型长度，可用sizeof(int)这种来实现
size_t count, //要写的数据个数，如果是一个a，就1，如果要写一个数组，就给 //数组长度
FILE* stream //给文件指针fp
);
4、利用fread读数据 size_t fread(
void* buffer, //要读的数据的指针，比如要写int a=10;就给&a
size_t size, //读的数据类型长度，可用sizeof(int)这种来实现
size_t count, //要读的数据个数，如果是一个a，就1，如果要写一个数组，就给 //数组长度
FILE* stream //给文件指针fp
);
27、sizeof 和 strlen
sizeof{variable|type}, strlen(const char[]);
sizeof可以返回变量类型如int char float等的长度，并且单位是字节，如int 32位的话就返回4；还可返回变量的长度，如int a=10；sizeof(a) 是等于4的(这里是int为32位长)；
strlen用于返回字符数组的实际长度，如char str[20] = "China"; strlen(str) 的值是5，而sizeof(str)为20，要特别注意。
列举几个例子好理解
char a;
int b;
char arr[50] = "Prison Break";
int arr2[50] = "Prison Break"; //这种定义方法是通不过的
sizeof(a) 为 1
sizeof(b) 为 4
sizeof(arr) 为 50
strlen(arr) 为 12
strlen(arr2) //编译不过，strlen的参数要求是 char[]
补充：对于一个struct来说，比如struct people
{
int age; //这里把int当作32位
char sex;
long number;
}
struct people me;
在8位机上，也就是一些单片机上，sizeof(me)为4+1+4=9Byte,如果题目给出为32位平台下，则sizeof(me) = 4+4+4=12Byte。
理解32位存储机制 先存32位的age，再存8位的sex，当再存32位的number时，一个单位的32位只剩下24位，不够，所以只能到下一个单位存number，因此sex也相当于占了32位，因此sizeof的结果是12。
自然对界：
struct 是一种复合数据类型，其构成元素既可以是基本数据类型（如int、long、float 等）的变量，也可以是
一些复合数据类型（如array、struct、union 等）的数据单元。对于结构体，编译器会自动进行成员变量的对齐，
以提高运算效率。缺省情况下，编译器为结构体的每个成员按其自然对界（natural alignment）条件分配空间。各
个成员按照它们被声明的顺序在内存中顺序存储，第一个成员的地址和整个结构的地址相同。
自然对界(natural alignment)即默认对齐方式，是指按结构体的成员中size 最大的成员对齐。
例如：
struct naturalalign
{
char a;
short b;
char c;
};
在上述结构体中，size 最大的是short，其长度为2 字节，因而结构体中的char 成员a、c 都以2 为单位对齐，
sizeof(naturalalign)的结果等于6；
指定对界：
一般地，可以通过下面的方法来改变缺省的对界条件：
使用伪指令#pragma pack (n)，编译器将按照n 个字节对齐；
使用伪指令#pragma pack ()，取消自定义字节对齐方式。
注意：如果#pragma pack (n)中指定的n 大于结构体中最大成员的size，则其不起作用，结构体
仍然按照size 最大的成员进行对界。
例如：
#pragma pack (n)
struct naturalalign
{
char a;
int b;
char c;
};
#pragma pack ()
当n 为4、8、16 时，其对齐方式均一样，sizeof(naturalalign)的结果都等于12。而当n 为2时，其发挥了作用，使得sizeof (naturalalign)的结果为6。
28、大端小端
嵌入式系统人员应该对Big-endian和Little-endian非常清楚。小端模式是指CPU对操作数的存放方式是从低字节到高字节，而大端模式是指CPU对操作数的存放是从低字节到高字节。
例如，16bit宽的数0x1234在Little-endian模式CPU内存中的存放方式（假设从地址0x4000开始存放）为
内存地址 0x4000 0x4001
存放内容 0x34 0x12
而在Big-endian模式CPU内存中的存放方式则为：
内存地址 0x4000 0x4001
存放内容 0x12 0x34
编程实现方式：若处理器是Big_endian的，则返回0；若是Little_endian的，则返回1
int checkCPU( )
{
{
union w
{
int a;
char b;
} c;
c.a = 1;
return(c.b ==1);
}
}
联合体union的存放顺序是所有成员都从低地址开始存放，面试者的解答利用该特性，轻松地获得了CPU对内存采用Little-endian还是Big-endian模式读写
29、运算符重载 （参阅C++ P317）
在C++中，比如复数的相加，在类中声明一个函数 Complex operator+(Complex &c2);
并实现它：
Complex Complex::operator+(Comlex &c2)
{
return Complex(real+c2.real,imag+c2.imag);
}
在主函数中
int main()
{
Complex c1(1,2),c2(2,3),c3;
c3 = c1 + c2; //即可完成相加的结果
}
一般来说，应该令赋值操作符返回一个reference to *this. 即返回应该是一个引用。
在实现 = 操作符的时候应该注意自我赋值 问题。
class Bitmap{...};
class Widget{
....
private:
Bitmap *pb;
};
Widget& Widget::operator=(const Widget& rhs)
{
delete pb; //如果是自我赋值， 这里不只是销毁当前对象的bitmap， 也是销毁rhs的bigmap，那么将导致错误
pb = new Bitmap(*rhs.pb);
return *this;
}
自我赋值解决方案：
1. 证同测试 （identity test）
Widget& Widget::operator=(const Widget& rhs)
{
if(this == &rhs) return *this;
delete pb;
pb = new Bitmap(*rhs.pb);
return *this;
}
具备自我赋值安全性，但是不具备异常安全性（因为无论什么情况导致new Bitmap出现错误， pb的指向都会出错）。
2. 异常安全性测试
Widget& Widget::operator=(const Widget& rhs)
{
Bitmap *pOrig = pb;
pb = new Bitmap(*rhs.pb);
delete pOrig;
return *this;
}
通常保证了异常安全性的都能够保证自我赋值安全性。
这里即便new 操作抛出异常，pb还是指向原位置， 他并不高效，但是行得通。
3. Copy and swap
class Widget{
...
void swap(Widget &rhs); //交换*this 和rhs的数据
};
Widget& Widget::operator=(const Widget& rhs)
{
Widget temp(rhs);
swap(temp);
return *this;
}
这种方法好比是值传递方式，直接进行拷贝然后copy，确保不会出现new问题。缺点是为了伶俐巧妙的修补而牺牲了清晰性。
30、头文件重复包含
为了避免头文件重复包含，需要在头文件开头加 #ifndef _HEARDER_
#define _HEARDER_
...
#endif
第一次编译发现没有定义_HEADER_宏，于是定义并编译。若另有文件包含了此头文件，会发现已定义了_DERDER_,于是跳到#endif执行。
31、memset和memcpy
(1) void *memset(void *s,int c,size_t n)
总的作用：将已开辟内存空间 s 的首 n 个字节的值设为值 c。
如：char *p = "My space is TommySpace";
利用memset(p, 'M', 5);可以将 *p改变成 "MMMMMace is TommySpace"
通常它用作内存初始化
char str[100];
memset(str,0,100); //将开辟的内存全部初始化为0值
一般用在对定义的字符串进行初始化为‘ ’或‘/0’；例:char a[100];memset(a, '/0', sizeof(a));
还可以方便的清空一个结构类型的变量或数组。
struct sample_struct
{
char csName[16];
int iSeq;
int iType;
};
对于变量
struct sample_strcut stTest; 一般的清空方式为：
stTest.csName[0] = '/0'
stTest.iSeq = 0;
stTest.iType = 0;
利用memset可以一次清空： memset(&stTest, 0, sizeof(stTest));
如果是数组：struct sample_struct Test[10];
利用memset一次清空: memset(Test, 0, sizeof(10*(struct sample_struct));
(2) extern void *memcpy(void *dest, void *src, unsigned int count);
功能：由src所指内存区域复制count个字节到dest所指内存区域。
说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。
32、时钟周期、机器周期、指令周期
时钟周期：也称震荡周期，是时钟脉冲的倒数。比如单片机外接晶振为12M，那么时钟周期为1/12000秒，是计算机中最基本、最小的时间单位。 在一个时钟周期内，CPU仅完成一个最基本的动作。一个时钟周期定义为一个节拍（用P表示）
机器周期 在计算机中，为了便于管理，常把一条指令的执行过程划分为若干个阶段，每一阶段完成一项工作。例如，取指令、存储器读、存储器写等，这每一项工作称为一个基本操作。完成一个基本操作所需要的时间称为机器周期。一般情况下，一个机器周期由若干个S周期（状态周期）组成
指令周期 指令周期是执行一条指令所需要的时间，一般由若干个机器周期组成。指令不同，所需的机器周期数也不同。对于一些简单的的单字节指令，在取指令周期中，指令取出到指令寄存器后，立即译码执行，不再需要其它的机器周期。对于一些比较复杂的指令，例如转移指令、乘法指令，则需要两个或者两个以上的机器周期。
32、容器类 Vector
参考资料 1
参考资料 2
创建、拷贝、销毁操作：
vector<Elem> c
vector<Elem> c1(c2)
vector<Elem> c(n)
c.~vector<Elem>()
vector<Elem> c(n,elem)
vector<Elem> c(beg,end)
非修改操作(包括大小操作和比较操作)：
c.size()
c.empty()
c.max_size()
capacity()
reserve()
c1 == c2
c1 != c2
c1 < c2
c1 > c2
c1 <= c2
c1 >= c2
reserve(n) 增加容量至n，提供的n不小于当前大小。
赋值操作：
c1 = c2
c.assign(n,value) 把n个值为value的元素赋给c
c.assign(beg,end) 把范围[beg,end)内的元素赋给c
c1.swap(c2)
swap(c1,c2)
元素访问操作：
c.at(idx) 返回索引号为idx的元素（如果索引号idx超出范围，抛出range error exception）。
c[idx] 返回索引号为idx的元素（无范围检查）。
c.front() 返回第一个元素（不会检查第一个元素是否存在）。
c.back() 返回最后一个元素（不会检查最后一个元素是否存在）。
对一个空容器调用[],front()和back()经常导致不确定行为，所以我们在调用[]时必须确保索引号是
有效的，在调用front()和back()时容器是非空的。
std::vector<Elem> coll; // empty!
if (coll.size() > 5) {
coll [5] = elem; // OK
}
if (!coll.empty()) {
cout << coll.front(); // OK
}
coll.at(5) = elem; // throws out_of_range exception
迭代器操作：
c.begin()
c.end()
c.rbegin()
c.rend()
c.insert(pos,elem) 在pos迭代器所指的位置处插入一个elem的拷贝，并返回新元素的位置。
c.insert(pos,n,elem) 在pos迭代器所指的位置处插入n个elem的拷贝，没有返回。
c.insert(pos,beg,end) 在pos迭代器所指的位置处插入范围[beg,end)内所有元素的拷贝，没有返回。
c.push_back(elem) 在末尾追加一个elem的拷贝。
c.pop_back() 移除最后一个元素，不会返回这个元素。
c.erase(pos) 移除pos迭代器位置处的元素，并返回下一个元素的位置。
c.erase(beg,end) 移除[beg,end)范围内所有的元素，并返回下一个元素的位置。
c.resize(num) 改变元素的数目为num，如果size()增加，新元素通过默认
函数创建。
c.resize(num,elem) 改变元素的数目为num，如果size()增加，新元素拷贝elem得到。
c.clear() 移除所有元素（使容器变为空）。
将vector用作普通数组：
对于vector容器类有下面的表达式成立：
&v[i] == &v[0] + i
其中v为vector容器类，定义如下：
std::vector<T> v;
下面看一个vector用作普通数组的例子：
std::vector<char> v;
v.resize(41); // 分配能容纳41个字符的空间，包括'/0'在内。
strcpy(&v[0], "hello, world"); // copy a C-string into the vector
printf("%s/n", &v[0]);
注意：不能将一个迭代器当作第一个元素的地址，迭代器是特别实现、有特殊含义的类型。
例如下面这样写是不对的：
printf("%s/n", v.begin()); // ERROR (might work, but not portable)
printf("%s/n", &v[0]); // OK
33. static_cast
用法：static_cast < type-id > ( expression )
该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性 。它主要有如下几种用法：
①用于类层次结构中基类和子类之间指针或引用的转换。
进行上行转换（把子类的指针或引用转换成基类表示）是安全的；
进行下行转换（把基类指针或引用转换成子类表示）时，由于没有动态类型检查，所以是不安全的。
②用于基本数据类型之间的转换，如把int转换成char，把int转换成enum。这种转换的安全性也要开发人员来保证。
③把空指针转换成目标类型的空指针。
④把任何类型的表达式转换成void类型。
注意：static_cast不能转换掉expression的const、volitale、或者__unaligned属性。
C++中static_cast和reinterpret_cast的区别
C++primer第五章里写了编译器隐式执行任何类型转换都可由static_cast显示完成;reinterpret_cast通常为操作数的位模式提供较低层的重新解释
1、C++中的static_cast执行非多态的转换，用于代替C中通常的转换操作。因此，被做为隐式类型转换使用。比如：
int i;
float f = 166.7f;
i = static_cast<int>(f);
此时结果，i的值为166。
2、C++中的reinterpret_cast主要是将数据从一种类型的转换为另一种类型。所谓“通常为操作数的位模式提供较低层的重新解释”也就是说将数据以二进制存在形式的重新解释。比如：
int i;
char *p = "This is a example.";
i = reinterpret_cast<int>(p);
此时结果，i与p的值是完全相同的。reinterpret_cast的作用是说将指针p的值以二进制（位模式）的方式被解释为整型，并赋给i，一个明显的现象是在转换前后没有数位损失。
static_cast 和 reinterpret_cast 以及 c语言中的强制转换的区别：
static_cast 是c++中采用的强制转换方法， 具有一定的安全性，即相关部分类型才能转换。
reinterpret_cast 是c++中更类似与C的强制转换方法， 它允许更自由的转换， 但是编程人员需要清楚自己在做什么转换。
c中的强制转换是随便怎么转换都行，不进行限制。
34. final 与static
final:
final可修饰类、域（变量和常量）、方法 （而static不修饰类)
1、final修饰类，表示该类不可被继承。
2、final修饰变量 程序中经常需要定义各种类型的常量，如：3.24268,"201"等等。这时候我们就用final来修饰一个类似于标志符名字。
3、修饰方法： final修饰的方法，称为最终方法。最终方法不可被子类重新定义，即不可被覆盖。
final 与const 如果是限定一些基本类型，没有太大区别，但是用于类， final则 表示其不可继承， 而const的类对象不可调用非const成员函数。
35. 引用、传值和传地址
引用vs 传值
传值操作是一个拷贝操作，能够进行操作的是实参的一个拷贝（形参）， 以及返回值的一个拷贝。 如果传值对象代价高，这样的花销是不值得的。
如果采用引用，即把引用结合const使用， 如 func(const CClassA& a){...} 则可以避免这种开销，因为他不使用拷贝，不会产生新的对象。
但是对于内建类型，如int，float， char这些传值会比引用的效率高， 非内建类型通常使用引用效率高
引用vs 传地址
对于引用和传地址（即指针方式），因为指针需要随时判断是否为空，进行有效性判断，而引用在声明变量是必须初始化，因此无有效性判断，更加安全
36. 虚函数的使用
（1）当类要用来被继承的时候， 析构函数通常被声明为虚函数
需要说明的是， 如果类有其他虚函数， 那么也应该有相应的虚析构函数。
为什么这种类的析构函数通常要被声明为虚函数呢? 这样做是为了当用一个基类的指针删除一个派生类的对象时，派生类的析构函数会被调用。
参考
c++语言标准关于这个问题的阐述非常清楚：当通过基类的指针去删除派生类的对象，而基类又没有虚析构函数时，结果将是不可确定的
37. 函数指针
int max(int x,int y);
int (*pFun)(int x, int y); //这里pFun就是指向 int max(int x,int y)的函数指针， 其声明方法跟函数基本一样，只是名字有所替换（*pFun）替代了max
pFun = max ; //给指针赋值， 函数名代表函数入口地址
38. 构造函数
对于类中有一个成员变量是其他的构造函数带参数的类，如果不定义成指针，而是普通成员变量，其成员变量的构造需要使用构造函数初始化参数列表：
class A
{
public:
A(int a){ m_a = a;}
private: int m_a;
}
class B
{
public:
B(int b): m_b(b), m_classA(b) // 这里这样实现初始化
{
m_pA = new A(b);
}
private:
int m_b;
A m_classA;
A *m_pA;
}
int main()
{
B b(5);
}
强调， 构造函数是用来进行初始化的，最好使用成员初始化列表来进行成员初始化，那种使用函数调用和成员变量赋值的方式不是真正的初始化，效率也不如初始化列表高。
构造函数初始化顺序： 父类高于子类构造函数， 成员变量初始化顺序跟申明顺序相同。
39 const 的用法
(1) const 与函数
void fun(int a) const //任何不会修改数据成员的函数都因该声明为const类型
{...}
这说明函数内部不能改变类的成员变量的值。 如果修改了编译器会报错，大大提高了程序健壮性
const void fun() //通常用于运算符的重载
{...}
比如运算符重载后， 比如 a*b=c， 表示讲c付给了a*b的结果，这样是不行的，如果使用了const修饰，则编译不通过。
(2) const 与指针
char greeting[] = "hello";
char *p = greeting; //non-const pointer, non-const data
const char*p = greeting; //non-const pointer, const data
char * const p = greeting; //const pointer, non-const data
const char* const p = greeting; //const pointer, const data
char *p
40 mutable 的用法
当const用来 这样修饰时 void fun() const {...}, 函数内部的类数据成员是不能被修改的，但是如果定义时声明为 mutable, 则可以再这里被修改。
41 casting 转型
转型是用来将进行一些类型转换的， 如const 型转为非const型， 非const型转为const型
static_cast<const T&>(*this)[position] //为*this加上const
const string str = "hello";
cosnt_cast<char&> str[3]; //将const转除
42 堆栈
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收 。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表，呵呵。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 - 程序结束后有系统释放
4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放
43 virtual
在基类中，通常会出现virtual 的函数或者析构函数。 virtual 一般用于拿来继承的积累，virtual 函数的目的是允许derived class的实现得以客制化。
比较特殊的是析构函数是否采用virtual。
如果一个类是用来作为基类，而且目的是实现多态，那么通常会有一个virtual的析构函数。或者说任何class只要带有virtual函数都几乎确定应该有一个virtual析构函数。
除了客制化，virtual析构函数还可以避免一下情况。
class base
{
base();
~base();
void print();
。。。
}
class deriveClass:public base
{
deriveClass();
~deriveClass();
void print();
。。。
}
base *p = new deriveClass;
delete p;
当我们delete p 的时候要注意，如果base类的析构函数是non-virtual的， 那么delete只会调用~base()，而不会调用~deriveClass，这样会导致非父类的数据不会被销毁，造成内存泄漏。
如果基类采用了virtual ~base(), 那么这里就~deriveClass() （同时也应该调用了~base()）, 达到我们真正的目的。
另外一种情况就是关于上述print()函数。
写一个函数 LetPrint(base b){ b.print();} 目的是调用print打印函数
deriveClass child;
LetPrint(child); 这里调用的是base的print()还是deriveClass的print（）呢？ 如果print函数在基类不是virtual的，那么一句LetPrint的参数类型，就是调用base的print，如果print是virtual的呢？是不是应该就是deriveClass
的print呢？ 不然， 这里还是会调用base的print。因为LetPrint采用的是值传递的方式，这样会使继承的对象出现 切割 引用传值 的方式
LetPrint（const base &b） 这样的话，print就是deriveClass的print了。
总结起来，如果传入一个deriveClass 对象，会有如下结果
const Base &b Base b
virtual print (deriveClass) print (Base) print
print （Base）print （Base）print
44 explicit
c++中的explicit关键字用来修饰类的构造函数，表明该构造函数是显式的。所谓构造函数是显示的还是隐式的说明如下
class Myclass
{
public:
Myclass(int a);
...
};
int main()
{
Myclass m = 10; //默认的构造函数会隐式的把他转化为 Myclass temp(10); Myclass m = temp;
}
如果在构造函数前面加上 explicit Myclass(int a);
则上述 Myclass m = 10 不会通过隐式转换。
45. frient 友元
友元是为了让其他函数或其他类访问类的私有成员，避免将私有成员申明为public。
class Internet
{
public :
Internet(char *name,char *address)
{
strcpy(Internet::name,name);
strcpy(Internet::address,address);
}
friend void ShowN(Internet &obj);//友元函数的声明
friend class friendClass;
public :
char name[20];
char address[20];
};
void ShowN(Internet &obj)//函数定义,不能写成,void Internet::ShowN(Internet &obj)
{
cout <<obj.name<<endl;
}
class friendclass
{
public:
char* subtractfrom()
{
Internet in;
return in.name;
}
};
void main ()
{
Internet a("中国软件开发实验室","www.cndev-lab.com");
ShowN(a);
friendclass c;
cout<< c.substractform<<endl;
cin .get();
}
友元函数并不能看做是类的成员函数，它只是个被声明为类友元的普通函数，所以在类外部函数的定义部分不能够写成void Internet::ShowN(Internet &obj
46. 异常处理 try catch
某一个可能发生异常的地方使用 throw **(任意类型)， 并把这一部分放入try{}里面去， catch紧跟try并进行出错处理
int fun(int a,int b)
{
int c = a+b;
if(c<0) throw c;
return c;
}
int main()
{
int a = 3, b = -4;
try
{
cout<<fun(a,b)<<endl;
}
catch(int)
{
cout<<a<<" "<<b<<" "<<"和小于0"<<endl;
}
cout<<"end"<<endl;
return 0;
}
几个注意:
(1) try catch 中间不能夹杂其他语句 如
try{}
int a = 0;
catch(int){}
(2) try 可以配多个catch， 因为可能抛出不同类型的异常
(3) 删节号 ... 表示可以捕捉任何异常 catch(...) { cout<<"OK";}
(4) try -catch 结构可以出现在不同函数中。
他的找寻顺序是逐次往上层搜索catch （如果找不到catch ，会系统会调用系统terminal是程序终止）
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/zhongjiekangping/archive/2009/12/13/4952730.aspx
2507
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
