define和inline的区别：

1. 内联函数在编译时展开，define在预处理阶段展开
2. 内联函数直接嵌入到目标代码中，宏只做一个简单的文本替换
3. 内联函数在编译阶段有类型检测，语法处理等功能，而宏没有
4. inline是函数，宏不是

函数缺省值：

#include using namespace std;int add(int a=2,int b=1){//从右往左依次赋值，不能跳跃，原因入栈先后顺序return a+b;
}int main()
{int a=10,b=20;cout << add(a,b) << endl;//结果为：30cout << add(a) << endl;//结果为：11，采用缺省cout << add() << endl;//结果为：3，采用缺省return 0;
}

函数重载：

是函数调用的灵活实现，也是多态的一种（同名函数的不同实现《执行逻辑的不同》）。

底层机制：根据不同的**参数类型，参数个数不同，与返回值无关，函数名相同**，则会在底层的程序的代码段的符号表中生成一个新的函数名，当使用不同的实参调用时，寻找匹配的函数调用。

#include using namespace std;int add(int a,int b){return a+b;
}float add(float a,float b){return a+b;
}string add(string a,string b){return a+b;
}//int add(int a,int b,int c=1){
//    return a+b;
//}//与上面的int add(int a,int b)存在二义性，不能同时存在int main()
{cout << add(1,2) << endl;cout << add(3.14f,5.12f) << endl;cout << add("yao","liang") << endl;return 0;
}

注意：使用缺省值，注意二义性

引用（quote)

出现原因：避免程序中出现野指针的现象，因为野指针在代码维护中，很难发现问题

底层实现：类型 * const 指针变量 = &变量

#include using namespace std;int add(int * const a,int * const b){return *a+*b;
}
int main()
{int a=10,b=20;cout << add(&a,&b) << endl;return 0;
}

语法形式：类型名& 引用变量 = 某个变量

#include using namespace std;int add(int * const a,int * const b){return *a+*b;
}int add(int& a,int& b){return a+b;
}int main()
{int a=10,b=20;cout << add(&a,&b) << endl;cout << add(a,b) << endl;cout << "a的地址：" << &a << endl;//0x4444int * const c=&a;cout << "c的地址：" << c << endl;//0x4444int& c=a;//c没有自己的空间，相当于a的别名，相当于int * const &c = a;cout << "c的地址：" << &c << endl;//0x4444return 0;
}

引用优点：防止指针传址造成的不良影响，

注意：不要返回局部的返回值，引用作为函数返回值时，可以作为左值使用

#include using namespace std;static int f = 100;int& add(int& a,int& b){f=a+b;return f;
}int main()
{int a=10,b=20;cout << add(a,b) << endl;//30add(a,b)=1000;cout << f << endl;//1000return 0;
}

指针与引用的对比：

#include static int *fun;int *func(int * const a,int * const b) {int sum=*a+*b;fun=∑return fun;
}int main(int argc, const char *argv[])
{/*your code*/int x=10,y=20;printf("%d\n",*func(&x,&y));*func(&x,&y)=100;printf("%d\n",*fun);return 0;
}

实例（数值交换）：

#include using namespace std;void swapfunc(int& a,int& b){int temp=a;a=b;b=temp;
}int main()
{int x=10,y=20;cout << "x = " << x << ",y = " << y << endl;//x=10,y=20swapfunc(x,y);cout << "x = " << x << ",y = " << y << endl;//x=20,y=10return 0;
}

常引用：

#include using namespace std;string func(const string & s){
//    s="yao";return s;
}int main()
{string str="yaoliang";cout << "str = " << func(str) << endl;return 0;
}

总结：

从编译器上：

• 引用是指针的升级

从语法形式上：

• 引用变量是引用空间的变量别名
• 引用引用的是一块合法的空间
• 指针可以是野指针，十分灵活，在c++中可能会把程序写飞
• 指针可以进行无限次的赋值
• 引用只能赋值一次int * const a = &b; <==>int &a = b

开辟空间

在c中：

int *p=(int *)malloc(sizeof(*p));//申请空间，不初始化
memset(p,0,sizeof(*p));//初始化升级：
int *q=(int *)calloc(0,sizeof(*q));//申请空间直接初始化升级：
int *s=(int *)realloc(ptr,sizeof(int)*5);//给申请空间申请空间
realloc()函数将ptr所指向的内存块的大小更改为字节大小。
内容将在区域的开始到新旧大小的最小值的范围内保持不变。
如果新的大小大于旧的大小，则新增的内存将不会初始化。
如果ptr为NULL，那么对于所有size值，调用等价于malloc(size);
如果size等于零，且ptr不为NULL，则调用等价于free(ptr)。
除非ptr为NULL，否则它一定是由之前对malloc()、calloc()或realloc()的调用返回的。
如果指向的区域被移动，则执行free(ptr)操作。

failure:NULL;

在cpp中:

#include using namespace std;int main()
{int *p=new int;//malloccout << *p << endl;  //单纯开辟空间，未初始化int *q=new int();//可在括号中指定初始化的值,calloccout << *q <

#include using namespace std;struct stu{string _name;int _age;//结构体或类中的构造函数stu(string name ,int age){_name=name;_age=age;cout << "含参构造"  << endl;}//开辟多个空间stu(){cout << "无参构造" << endl;}//结构体或类的析构~stu(){cout << "析构" << endl;}
};int main()
{stu* s=new stu("yaoliang",19);delete s;stu * ss=new stu[5];delete[] ss;return 0;
}