【C++之语法篇003】

C++知识开篇

前言：
前篇内容对于C++有一个基本认识，这篇文章将继续学习C++与C语言优化后的语法知识部分。
/知识点汇总/

1、内联函数

1.1、什么是内联函数?

概念：以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序的运行效率。

C++引出inline关键字
比如这个函数频繁调用100万次，如何解决？
C语言中就引用的宏，宏函数解决。但是要求细节和严谨。
inline常用于修饰频繁调用的函数

#include <iostream>
using namespace std;
//int Add(int left, int right)
//{
//	return left + right;
//}
inline int Add(int left, int right)
{
	return left + right;
}
int main()
{
	int ret = 0;
	ret = Add(1, 2);//汇编call --》Add (地址：...)
	//inline修改后，成为内联函数。就直接调用函数不用call Add()函数了。
	return 0;
}

C++引出内联函数主要是用于解决C语言中宏函数容易出现的问题。
回顾：宏或宏函数，使用宏根本上需要注意的就是括号的正确使用。
1.宏的本质就是预处理阶段的替换。
2.宏本身不是函数
3.不需要分号
4.括号优先级

#include <iostream>
#define ADD(a,b) ((a)+(b))
//为什么宏要加里面的括号？
//因为a和b也可能是独立的表达式。否则，容易出现优先级问题错误。
using namespace std;
int main()
{
	int a = 0;
	cin >> a;
	//场景1
	if (ADD(a, 2))
	{
	}
	//场景2
	int m = ADD(a, 2) * 3;
	cout << m << endl;
	return 0;
}

宏的缺点：
1.不容易控制，不容易调试
2.语法复杂，坑多易错
3.没有类型，无法安全检查

对比C++的inline和C语言的宏
可见C++的内敛函数很好的解决此类大部分问题。

1.2、解决外部头文件，重复定义问题

1.声明和定义分离
2.static，修改函数链接属性，只在当前文件可用。(适用于大函数)
3.inline，使其展开就无法call调用。(适用于小函数)

#include <iostream>
using namespace std;
inline int Add(int a, int b)
{
	cout << "int Add(int a,int b)" << endl;
	return a + b;
}
int main()
{
	Add(2, 3);
	return 0;
}

1.3、内联函数的总结

1.inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用
缺陷：可能是目标文件夹变大，优势：少了很多调用花销，提高程序运行效率。
2.inline对于编译器而言只是一个小建议，不同编译器关于inline实现机制可能不同；一般建议将函数规模较小，不是递归且频繁调用的函数采用inline修饰。
3.内敛说明只是向编译器发出请求，编译器可以选择忽略这个请求。
4.inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有Call函数地址了，所以链接就找不到了。

2、auto关键字

2.1、auto的作用

auto会自动推导类型
但是auto同样存在一定的弊端：

1.首先适用于自己知道的类型，如果单纯的只有auto没有注释和文档说明，就比较影响程序的可读性；
2.因为要去推导auto接收的类型，嵌套太多的时候就很影响代码的阅读性。

#include <iostream>
#include <map>
#include <string>
using namespace std;

int Add(int a, int b)
{
	cout << "int Add(int a,int b)" << endl;
	return a + b;
}
auto func(int a, int b)
{
	auto m = a + b;
	return m;
}
int main()
{
	int i = 0;
	int j = i;
	auto k = i;//自动判定接收为整型。
	//auto x;  //auto与引用一样必须初始化
	auto p1 = &i;   //自动判定接收的地址为指针类型。
	auto* p2 = &i;  //指定为指针类型
	//auto* p3 = i; //错误使用
	auto& r = i;

	//常见的应用于复杂的类型：
	//函数指针/数组指针
	int(*pf)(int, int) = Add;
	//等价auto自动识别为函数指针
	auto pf2 = Add;

	//C++使用场景
	cout << typeid(pf).name() << endl;
	cout << typeid(pf2).name() << endl;

	std::map<std::string, std::string> dict;
	//std::map<std::string, std::string>::iterator it = dict.begin();
	//等价
	auto it = dict.begin();
    //注意：auto建议不能作参数，另外auto可以但不建议作函数返回值，嵌套太多不好判断类型。
	auto ret = func(1, 2);//auto嵌套的谨慎使用
	return 0;
}

2.2、auto的总结

注意：auto不能作返回值，另外auto可以但不建议作函数返回值，嵌套太多不好判断类型。
但是auto同样存在一定的弊端：
1.首先适用于自己知道的类型，如果单纯的只有auto没有注释和文档说明，就比较影响程序的可读性；
2.因为要去推导auto接收的类型，嵌套太多的时候就很影响代码的阅读性。

3、范围for

3.1、什么是范围for？

C++引入的范围for由括号里的两部分组成，以冒号分割，冒号前是用于迭代的变量，冒号后是被迭代的范围。

格式：
for (类型（引用） 变量 : 范围)
{}

3.2、范围for的循环应用

#include <iostream>
using namespace std;
int main()
{
	int arr[] = { 1,2,3,4,5 };
	//C语言的for循环
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		arr[i] *= 2;
	}
	for (int* p = arr; p < p + sizeof(arr) / sizeof(arr[0]); p++)
	{
		cout << *p << endl;
	}
	//C++
	//依次取得数组中元素的值赋值给变量e，并且自动迭代，直到自动判断遍历结束
	//for (auto e : arr)
	//{
	//	cout << e << " ";
	//}
	//不加引用是无法修改数组元素的值的，因为属于临时拷贝，所以需要加上别名才能修改元素值
	for (auto& e : arr)
	{
		e *= 2 ;
	}
	cout << endl;
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;

	return 0;
}

数组名作为参数时，范围无法明确，就无法使用范围for

#include <iostream>
using namespace std;
//注意:这里看似传的数组，但是数组作为参数本质就是转换为指针了；
//所以范围无法明确，自然就无法使用范围for了。
void func(int arr[])
{
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;
}
int main()
{
	return 0;
}

总结：

1.范围for的使用范围是明确的；
2.可以正常的使用continue和break

4、指针空值关键字nullptr

4.1、指针空值的作用

引用新的nullptr，解决了C++本身自己的底层定义NULL语法时的错误

#include <iostream>
using namespace std;

void f(int)
{
	cout << "f(int)" << endl;
}

void f(int*)
{
	cout << "f(int*)" << endl;
}

int main()
{
	f(0);
	f(NULL);
	f(nullptr);
	//等价
	//f((void*)0);
	//所以指针初始化就采用nullptr了
	int* p = nullptr;
	return 0;
}