由于没有怎么复习到C++的内容，今天面试被问了好多，都不怎么会答得上来，所以就先放下进程通信那部分，先来复习一下C++。
1.linux环境下的C++。
第一个C++程序
#include <stdio.h> #include <iostream> int main() { printf("hello world\n");//C语言写法 std::out<<"hello"<<"world"<<std::endl;//C++写法 return 0; }
在linux系统下的C++程序的编译命令：g++ -o hello hello.cpp
（1）C++文件的后缀：.cpp .cxx .cc .hpp .h
（2）C++文件的头文件：标准C++头文件是没有.h的，比如iostream。
1.如果在C++中要使用到C语言的标准库函数，添加头文件的时候要把.h去掉,并且在前面添加c，比如 stdio.h------>cstdio
2.也可以在添加头文件的时候指定为C语言
extern “C” { #include <add.h>}
（3）在C++程序中cin、cout、cerr、clog对象是自动创建（类似于C语言文件stdin,stdout,stderr），用户不能再创建新的istream对象或者ostream对象。
std::cin>>变量 比如：int a; double b； std::cin>>a>>b; std::cout<<变量/常量 比如：int a=12; double b=10.1；std::cout<<a<<” ”<<b<<std::endl;
2.C++对C的扩展
堆空间的分配
（1）在C语言中空间的申请和释放 malloc---free 用户自己申请空间和释放
（2）在C++中空间的申请和释放 new-----delete
申请格式： 数据类型 *p = new 数据类型 比如： char *p = new char 在堆空间中申请一个char对象空间（1字节） char *p = new char(‘a’) 申请一个字节空间并且用a初始化 char*p=(char*)malloc(1) char *p = new char[100] 在堆空间中申请100个char对象-数组 释放格式： delete 指针; 比如： delete p; //只申请一个char对象 delete []p; //释放连续空间（释放100个对象空间）
C++中的new和delete与C语言中的malloc和free的异同
（1）都可以申请堆空间，空间是连续的。
（2）new相当于malloc+构造函数
（3）delete相当于free+析构函数
命名空间
作用：避免函数、变量、类型的冲突，合作开发的时候可以避免交叉冲突。
namespace 空间名{ 成员（非main函数， 变量， 常量， 结构体， 类等） };
namespace class01 { string jack; string rose; }; namespace class02 { string jack; string rose; }; int main() { class01::jack = “classs01Jack”; class02::jack=”class02Jakc”; }
空间成员的使用
1.直接通过空间::成员 来使用
class01::jack = “classs01Jack”;
2.使用using指示符号指引
using namespace class01; //把class01空间中的成员全部暴露在全局区域 //string jack=””; int main() { jack = “classs01Jack”; //属于class01里面的jack class02::jack=”class02Jakc”; //属于class02里面的jack }
3.使用using声明成员
using class01::jack; //把class01空间中的jack在当前文件创建一个副本类似于在当前位置定义string jack; int main() { jack = “classs01Jack”; //属于class01里面的jack class02::jack=”class02Jakc”; //属于class02里面的jack }
命名空间
1.命名空间嵌套
namespace AAA { namespace BBB { string name; } } //空间嵌套 //要使用name //AAA::BBB::name
2.同名空间 同名命名空间属于同一个空间，在同一个区域中
//同名命名空间--属于同一个空间（同一个区域中） namespace CCC { int number =123; }; namespace CCC { int data = 321;; }
3.匿名空间 空间中的成员要使用的时候必须加空间名，但是匿名空间除外，匿名空间的成员在当前的文件中是可以直接使用的（只能在当前文件中使用）
namespace { int myage; }
引用
应用就是变量或者常量的别名。
int a =10； int *p=&a;
定义：数据类型 &引用=变量
const 数据类型 &引用=变量/常量
int a = 10； int &b = a; b就是a的引用
引用的特点：
| 1 | 引用不占用内存空间，与引用的对象共用空间 |
| 2 | 引用与引用的对象数据类型必须一致 |
| 3 | 引用定义的时候必须要初始化 |
| 4 | 一个引用只能引用一个对象，一个对象可以被多次引用，引用可以再被引用 |
| 5 | 如果引用的对象是常量那么引用必须用const修饰 |
引用作为函数参数
函数传参的方式：1.传值 2.传地址 3.传引用
void swap(int &a, int &b) { int t = a; a = b; b= t; } int a =123, b=456; swap(a,b);
const修饰引用
const int a = 100; const int &b = a; const int &c = 123;
const 修饰全局变量 const int size =100；//存储在只读数据段 const修饰局部变量 const int psize = 200；//数据存储在栈空间 int *p = （int*）&psize; //p所指向的空间是psize符号的副本，*p是可以修饰，但psize本身不能修改 *p= 20; cout<<*p<<” ”<<psize<<endl; ==>20, 200;
C++一般用const修饰的常量来代替宏定义
#define size 100 ==> const int size = 100;
1. const修饰的常量在使用的时候会检查数据类型，宏定义不会（是直接替换）
2. const修饰的常量在使用的时候只分配一次空间， 宏定义多次分配空间
3. const修饰会对数据进行优化
函数参数是引用的时候用const修饰---让编译器指出错误，如果在函数内部不想让引用的对象值发生改变，那么引用的参数就要加const修饰。
int add(const int &a, const int &b) { //a++; return a+b; }
函数重载
定义：函数名相同，函数参数列表不同，这一系列函数称为函数重载，重载可以解决函数重名的问题。
int add(const int &a,const int &b){return a+b;} double add(const double &a, const double &b){return a+b;}
函数重载-函数调用
函数重载---在编译的时候会根据函数的实参来匹配对应函数
静态链编---在编译的时候就已经确定调用的函数（静态链编多态）
c++为什么能实现函数重载---编译器在编译函数的时候会检测函数名，和参数列表，
c语言编译器在编译函数的时候只检测函数名，不会检测函数参数
函数重载依据 ： 1， 函数名相同， 2， 参数列表不同， add(int, double), 3.const修饰的指针或引用也可以作为函数重载依据
函数缺省参数--函数默认参数
#include<iostream> extern "C" { #include <sys/types.h> #include <sys/stat.h> #include <fcntl.h> } using namespace std; int open_lcd(const char *filename="/dev/fb0", int flag=O_RDWR) {} int main(void) { int fd = open_lcd ("/dev/fb0", O_RDWR); fd = open_lcd ("/dev/fb0"); fd = open_lcd(); return 0; }
默认参数规则：参数列必须从右往左连续默认
int show(int a=2, int b=1, int c=0)；
int show(int a, int b, int c=1)
int show(int a, int b, int c)
PS：有哪里写错的地方，请指正，互相学习。