内联函数 函数重载 引用指针 new和delete

inline内联函数和普通函数

inline内联函数：在编译过程中，就没有函数的调用开销了，在函数的调用点直接把函数的代码进行展开处理了

int sum(int x,int y)            inline int sum(int x,int y)
{								{					
	return x + y;					return x + y;
}								}
int main()						int main()
{								{
	int a = 10;						int a =10;
	int b = 20;						int b =20;
	int rt = sum(a, b); 		 	int rt = 10 + 20 //直接展开 
	return 0;						return 0；
}								}

左图普通函数调用点，函数的处理流程先进行实参压栈然后处理函数体。右图内联函数调用点，函数没有开辟和清栈，函数体直接在调用点代码展开。

inline函数不再生成相应的函数符号
inline 只是建议编译器把这个函数处理成内联函数
但是不是所有的inline都会被编译器处理成内联函数-递归 过多代码的函数
debug版本上，inline不起作用；inline只有在release版本下才能出现

函数重载

函数重载：一组函数，其中函数名相同，参数列表的个数或者类型不同，那么这一组函数就称作-函数重载。

1.c++为什么支持函数重载 c语言不支持函数重载
c++代码在产生函数符号的时候，函数名+参数列表组成
c代码在产生函数符号的时候，函数名决定

2.函数重载需要注意什么
一组函数要称得上重载，一定先是处在同一个作用域当中的。
const 或者volatile的时候
一组函数，函数名相同，参数列表也相同，仅仅是返回值不同不叫重载

void func(int a){}
//void func(const int a){} 两者参数列表同类型 会重定义

3.c++和c语言代码之间如何相互调用
c调用c++：无法直接调用 需要把c++源码括在extern“C”中
c++调用c：无法直接调用 需要将c函数的声明括在extern“C”中

extern "C"{}

使用如下方法，无论使用c 或 c++ 编译 都可以给c项目直接调用

#ifdef __cplusplus 			//__cplueplue  c++编译器内置的宏名 
extern"C"{
#endif
	int sum(int a, int b){}
#if __cplusplus
}
#endif

const使用

c和c++中const的区别是什么
编译方式不同
c中当做一个变量来编译生成指令的。
c++中，所有出现const常量名字的地方，都被常量的初始化替换了

最基础的理解 const修饰的变量不能够作为左值，初始化完成后，之不能被修改（可以不用初始化）
c 中 const修饰的量叫做常变量，不叫常量

void main()
{
	const int a = 20;
	//int array[a] = {};  // error a不是常量
	int *p = (int*)&a;
	*p = 30;
	printf("%d %d %d \n", a, *p, *(&a));//30 30 30
}

c++的const 必须初始化
当初始值是一个立即数 叫做常量 可以定义数组的大小
当初始值不是一个立即数 则为常变量 与c 中一样

void main()
{
	const int a = 20;
	//int b = 20;
	//const int c = b;		c为常变量 不是常量
	int array[a] = {}; 
	int *p = (int*)&a;
	*p = 30;
	printf("%d %d %d \n", a, *p, *(&a));//20 30 20  
	//地址虽然改变 但是 a  *（&a） 直接替换成20  
}

const和指针

const修饰的量常出现的错误是

1.常量不能再作为左值 《= 直接修改常量的值
2.不能把常量的地址泄露给一个普通的指针或者普通的引用变量
《= 可以间接修改常量的值
3.const 右边没有指针不参与类型

一级指针结合

c++的语言规范：const修饰离他最近的类型
1.const int * p int const * p
修饰指针指向 p本身没有修饰
可以任意指向不同的int类型的内存，但是不能通过指针间接修改指向的内存的值
2.int * const p
修饰p本身
这个指针p现在是常量，不能指向其他内存，但是可以通过解引用修改指向的内存的值
3.const int *const p
指向与本身均被修饰 均不能修改

总结const和指针的类型转换公式：
int* <= const int* //false
const int* <= int* //true

int a = 10;
int *p1 = &a;        
const int *p2 = &a;  // const int * <= int *  true
int *const p3 = &a;  // int * <= int *        true
int *p4 = p3;        // int * <= int *        true

二级（多级）指针的结合

1.const int **q;
2.int *const * q;
3.int **const q;
类型转换
Int ** <= const int ** //false
const int ** <= int ** //false
int ** <= int * const * //false
int / const * <= int ** //true

引用与指针

引用与指针的区别
引用是一种更安全的指针
1.引用是必须初始化的，指针可以不初始化
2.引用只有一级引用，没有多级引用；指针可以有一级指针，也可以有多级指针；
3.定义一个引用变量和定义一个指针变量，其汇编指令是一模一样的；通过引用变量修改所引用内存的值，和通过指针解引用修改指针指向的内存的值，其底层的指令也是一模一样的

1.左值引用和右值引用

int &&c = 20；专门用引用右值类型，指令上，可以自动产生临时量然后直接引用临时量 c = 40;
右值引用变量本身是一个左值，只能用左值引用来引用它
不能用一个右值引用变量，来引用一个左值

int a = 10; //左值，它有内存，有名字，值可以被修改
int &b = a;
//int &C = 20;//20是右值，没内存，没名字
//c++11提供了右值引用
int &&c = 20;
c = 30;
int &e = c; //一个右值引用变量，本身是一个左值
/*
int temp = 20;
temp -> d
*/
const int &d = 20;

2.const ,一级指针，引用的结合

int a = 10;
const int *p = &a;
int *&q = p;  //false   等同于 int ** <= const int **

int a = 10;
int *p = &a;
const int *&q = p;
//const int **q = &p //const int ** <= int **   false

new和delete

new和malloc区别？
不仅可以做内存开辟，还可以做内存初始化。malloc开辟内存失败，是通过返回值和nullptr作比较；而new开辟内存失败，是通过抛出bad_alloc类型的异常来判断的。
deletet和free区别？
malloc和free称作C的库函数
new和delete称作运算符
delete 相当于 析构函数 + free

int *p = (int *)malloc(sizeof(int));
if(p == nullptr)
{
	return -1;
}
*p = 20;
free(p); //malloc不进行初始化
int *p1 = new int(20); // new 不仅可以做内存开辟，还可以做内存初始化
delete p1;

int*q = (int *)malloc(sizeof(int) * 20);//开辟数组
if(q == nullptr)
{
	return *1;
}
free(q);
//int *q1 = new int[20] 不初始化
int *q1 = new int[20]();  //初始化为0  
delete []q1;

//new有多少种
int *p1 = new int (20);
int *p2 = new (nothrow) int; //不抛出异常
const int * p3 = new const int(40); //开辟常量空间
//定位new
int data = 0;
int *p4 = new (&data) int (50); //在指定内存开辟
cout << "data:" << data << endl; //data:50