[C++]02-基本语法

1.内联函数

       1.1 内联函数是什么

• 使用inline关键字声明或者实现,可以使其变为内联函数。建议声明和实现都加inline实现

       1.2 内联函数的特点

• 编译器会将函数调用直接展开为函数体代码，不存在开辟和回收栈空间。

       1.3 什么时候使用内联函数

• 代码行数不超过10行
• 在代码体积的不大的情况下 ,频繁调用函数

       1.4 为什么要使用内联函数

• 提高代码的执行效率 函数调用使用会开辟栈空间。如果函数代码量少的情况下,频繁的调用会频繁的开辟和回收栈空间。

       1.5 内联函数的本质

#include <iostream>
using namespace std;

 inline int sum(int a, int b) {
	return a + b;
}

  int sub(int a, int b) {
	 return a - b;
 }

  inline void run() {
	  int a = 20;
	  int b = 30;
	  int c = a + b;
	  run();
 
  }
int main() {
	// 内联函数
	int a = sum(4, 3);
	// 非内联函数
	int b = sub(3, 4);
	// 内联递归函数
	run();
	cout << a << b << endl;
	return 0;
}

       1.6 注意

• 尽量不要内联超过10行代码的函数
• 有些函数即使声明为inline，也不一定会被编译器内联，比如递归函数

2.const

       2.1 const

• const 是常量的意思
• 如果修饰的是类,结构体（的指针）,其成员也不可以更改

       2.2 const的修饰原则

• const 修饰的是其右边的内容

       2.3 const的使用

• 在指针中的使用

struct Date {
	int year;
	int month;
	int day;
};

int main() {
	

	int age = 10;
	int height = 30;

	// p1不是常量，*p1是常量
	const int* p1 = &age;
	// p2不是常量，*p2是常量
	int const* p2 = &age;
	// p3是常量，*p3不是常量
	int* const p3 = &age;
	// p4是常量，*p4也是常量
	const int* const p4 = &age;
	// p5是常量，*p5也是常量
	int const* const p5 = &age;

	//*p4 = 20; // age = 20;
	//p4 = &height;
	//*p4 = 40; // height = 40;

	getchar();
	return 0;
}

• 在结构体中的使用

#include <iostream>
using namespace std;

	struct Date {
		int year;
		int month;
		int day;
	};

int main() {
		// const int age = 20;

		Date d1 = {2011, 2, 5};
		Date d2 = {2013, 4, 8};

		const Date *p = &d1;
		// 报错 ：*p是常量 即d1结构体是常量
		p->year = 2015;
		(*p).month = 5;
		*p = d2;

		cout << d1.year << endl;

		
		getchar();
		return 0;
	

}

3.引用 reference

       3.1 什么是引用：

• 变量的别名

int main()
{
	int age = 10;
	// 引用相等于变量的别名
	int& ref = age;
	// 使用ref相等于使用ref
	ref = 20;
	cout << age << endl;

}

       3.2 引用有什么用：

• 在c++中使用引用 可以起到跟指针类似的功能,比指针更安全,函数返回值可以被赋值

指针可以随便修改指向，指向不该指的空间，会存在安全隐患。而引用一开始必须指向一个变量
int *p =&age;
p=0x123123;// 假如这个空间存放很重要的数据,修改这个数据有安全隐患
*p= 20;

       3.3 引用的特点：

• 引用相当于变量别名（基本数据类型,枚举,结构体,类,指针,数组等都可以有引用）

—指针引用—
int age = 30;
int* p = &age;
int* &ref = p;
*ref = 40;
cout << age << endl;
—数组引用—
int array[] = { 1,2,3 };
int(&ref)[3] = array;

• 在定义的时候就必须初始化，一旦指向了某个变量，就不可以再改变，“从一而终”
• 可以利用引用初始化另一个引用,相当于某个变量的多个别名

	int age = 10;
	// 引用相等于变量的别名
	int& ref = age;

	int& ref1 = ref;
	int& ref2 = ref1;

	// 使用ref相等于使用ref
	ref += 10;
	ref1 += 10;
	ref2 += 10;
	//40
	cout << age << endl;
	

       3.4 引用本质是什么：

• 本质还是指针,但是是弱化了的指针,比指针使用起来更方便.更安全。

	int age = 10;
	int* p = &age;
	*p = 30;

	int& ref = age;
	ref = 30;

int age = 10;
	mov         dword ptr [age],0Ah  
int* p = &age;
    lea         eax,[age]  
    mov         dword ptr [p],eax  
*p = 30;
    mov         eax,dword ptr [p]  
    mov         dword ptr [eax],1Eh  
-------------引用-----------------------
int& ref = age;
    lea         eax,[age]  
    mov         dword ptr [ref],eax  
ref = 30;
    mov         eax,dword ptr [ref]  
    mov         dword ptr [eax],1Eh  

       3.5 常引用：

 int age = 10;
	// 常引用 表示&ref指向的值不可以修改,即age的值不可以修改
	int const & ref = age;
	ref = 30;