【C++学习】基础语法（二）

  在C语言中，为了增强代码的复用性、提高性能提出了宏，但宏也存在着调试不方便、没有类型的安全检查、代码可读性差及可维护性差的缺陷。在C++中，引入内联函数实现宏定义的功能（宏函数），并针对宏定义的缺陷进行了一定的优化。

一、内联函数

1.1 概念

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

  下图代码中，tmp处调用函数Add时，在代码被翻译为汇编代码后，实际上通过call指令来带调用栈上的函数Add。

如果在函数Add前面增加关键字inline，则该函数被改成内联函数，在编译期间C++编译器会用函数体替换函数的调用，不会使用调用指令call。

1.2 特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用；优势：减少调用开销，提高程序执行效率；缺陷：使目标文件所需消耗的存储空间变大；

2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小、不是递归、且需频繁调用的函数采用inline修饰，否则编译器会忽略inline特性；

3. inline不建议声明和定义分开，分离会导致链接错误。这是由于inline被展开，就没有函数地址了，链接就会找不到。

二、关键字auto

2.1 类型别名思考

  随着程序越来越复杂，程序中用到的类型也愈加复杂，体现在：

1. 类型难于拼写；
2. 含义不明确导致容易出错。

map<string, string>dict;
std::map<std::string, std::string>::iterator dit = dict.begin();

其中，std::map<std::string, std::string>::iterator是一个类型，但是该类型太长，且不容易拼写。若使用typedef来对类型重命名，又增加了代码编写难度：

typedef char* pstring;
int main()
{
    const pstring p1;
	const pstring* p2;
	return 0;
}

在编程时，常常需要把表达式的值赋值给变量，这就要求在声明的时候清楚地知道表达式的类型。然而有时做到这点并不容易，C++引出auto。

2.2 auto简介

  在C++11中，auto定义为：相比C++前期版本auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

int main()
{
	int a = 0;
	auto b = a;
	auto c = &a;
	auto* d = &a;
	auto& e = a;
	cout << typeid(b).name() << endl;
	cout << typeid(c).name() << endl;
	cout << typeid(d).name() << endl;
	cout << typeid(e).name() << endl;
	return 0;
}

  使用auto定义变量时，必须对其进行初始化；在编译阶段，编译器需要根据初始化表达式来推导auto的实际类型。因此，auto并非是一种“类型”的声明，而是一个类型声明的“占位符”，编译器在编译期会将auto替换为变量的实际类型。

2.3 auto的使用细则

2.3.1 auto与指针和引用结合使用

  上图代码中auto声明指针类型时，auto和auto* 没有任何区别；但auto声明引用类型时必须加**&**。

2.3.2 在同一行定义多个变量

  在同一行声明多个变量时，与C语言相同，这些变量必须是相同的类型，否则C++编译器会报错；因为编译器实际只对第一个类型进行推导，但后用推导出来的类型定义其他变量。

void Test()
{
	auto a = 11, b = 22;//编译成功
	auto c = 33, d = 4.5;//编译失败
}

2.4 auto不能推导的场景

2.4.1 auto不能作为函数参数

void Add(auto a,auto b)
{
	//
}

  此时，编译失败；auto不能作为形参类型，因为编译器无法对a、b的实际类型进行推导。

2.4.2 auto不能直接用来声明数组

void TestAuto()
{
    int a[] = {1, 2, 3};//编译成功
    auto b[] = {4, 5, 6};//编译失败
}

  此外，为了避免与C++98中auto发生混淆，C++11只保留了auto作为类型指示符的用法。

2.5 auto使用场景

  例如下列代码中，auto自动推导类型功能，在面对类型很长时，可以考虑auto自动推导来简化代码。

//简化前
map<string, string>dict;
std::map<std::string, std::string>::iterator dit = dict.begin();

//简化后
map<string, string>dict;	
auto dict = dict.begin();

此外，auto亦能配合范围for循环（详见下面第四节）。

三、关键字const

  const在C++中用来修饰内置类型变量、自定义对象、成员函数、返回值、函数参数，起不易改变的作用。

3.1 const修饰内置类型变量

const int a = 10;
int b = a;

  在上述代码的基础上，具体下图所示：更改变量a的值为8，则编译器报错。由此可知，被const修饰的内置类型变量，被指定为常量后，其值不被允许更改，但可以赋值给同类型的变量。

a=8;

3.2 const修饰指针变量

	int a = 10;
	const int* p= &a;

  指针p指向的a的内容不变，只有变量a能够改变存储的数据，指针p无权限；这种方式称为“左定值”（解引用*位于左边)。

	int a = 20;
	int* const b = &a;

指针b指向的变量a的地址不能更改，但变量a中储存的内容可以更改；这种方式简称“右定向”。

	int a = 30;
	const int* const pp = &a;
	cout << *pp << endl;
	int b = 300;
	pp = &b;

指针pp所指向的变量a的内容和地址都已固定且不可更改。

3.3 const参数传递与函数返回值

3.3.1 传值传参

int Add(const int a, const int b)
{
	++a;
	++b;
	return a + b;
}
int main()
{

	int c = Add(10, 20);
	cout << c << endl;
	return 0;
}

由于传值传参的形参a和b的值是常量，被固定住，无法进行自加操作，因而上述代码无法正常运行。

3.3.2 const修饰指针以防数据篡改

const 修饰内置类型的返回值，修饰与不修饰返回值作用一样;

const 修饰自定义类型的作为返回值，此时返回的值不能作为左值使用，既不能被赋值，也不能被修改;

const 修饰返回的指针或者引用，是否返回一个指向 const 的指针，取决于我们想让用户干什么。

3.4 const修饰类成员函数

这部分将在后续的类与对象的语法中详细讲述。

3.5 小结

const修饰指针变量的三种情况：

1. 修饰指针指向的内容，则内容为不可变量；
2. 修饰指针，则指针为不可变量；
3. 修饰指针和指针指向的内容，则指针和指针指向的内容都为不可变量。

四、基于范围的for循环

  在C++11之前版本中，遍历数组，只能按照下列方式进行：

int main()
{
	int arr[] = { 10,1,4,2,7,3,5,9 };
	for (int i = 0; i < sizeof(arr) / sizeof(int); i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
	return 0;
}

对于一个有范围的集合而言，由程序员来控制循环的范围不仅多余，而且极易犯错。例如下面代码中，栈的数据打印函数中在初始化栈的成员变量时，若size=-1则控制循环的i不超过ps->size；若size=0则i不超过ps->size-1。

struct Stack
{
	int* a;
    int size;
    int capacity;
};
void StackPrint(struct Stack* ps)
{
    assert(ps);
    for(int i = 0;i < ps->size-1;i++)
    {
        cout<<ps->a[i]<<" ";
    }
    cout<<endl;
}

4.1 范围for的语法

  具体语法详见下列代码案例：

int main()
{
	int arr[] = { 10,1,4,2,7,3,5,9 };
	for (auto e:arr)//自动依次取数组中数据赋值给e，自动判断结束
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

C++11中，引入基于范围的for循环。for循环的括号内容由**😗*分为两部分：前面的用于范围内迭代的变量，后面的表示被迭代的范围。此外，与普通循环一样，continue可以结束本次循环，break结束循环。

4.2 范围for的使用条件

4.2.1 for循环迭代的范围必须是确定的

  对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

void Testfor(int array[])
{
	for(auto& e:array)
	{
		cout<<e<<endl;
	}
}

上述代码有错误，for的范围不确定。C++语法不支持array[ ]这种数组传参形式，因而该段代码无法编译成功。

4.2.2 迭代的对象要实现++和==的操作

  这部分将在后续的迭代器详细说明。

五、指针空值nullptr

5.1 C++98中的指针空值

  在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能出现无法预料的错误，例如未初始化指针。

  若一个指针没有合法的指向，我们基本是按照下面方式对其进行初始化：

void TestPtr()
{
    int* p1 = NULL;
    int* p2 = 0;
    //...
}

通过查阅C的头文件stddef.h，可以看到下图代码：

由此可知，NULL能可被定义为字面常量0，或者被定义为无类型指针(void)的常量*。不论采取何种定义，在使用空值的指针时，都不可避免的会遇到一些麻烦：

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

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

int main()
{
	f(0);
	f(NULL);
	return 0;
}

上列代码中，我的本意是想通过NULL调用指针版本的f(int*)函数，由于NULL实际上是一个宏，在C++中NULL被定义成0。因此未到达开始设想。

  在C++98中，字面常量0既可以是一个整形数字，也可以是无类型的指针(void*)常量，但编译器默认情况下将其看成是一个整形常量，如果要将其按照指针方式来使用，必须对其进行强制转换(void*)0。

注意：

1. 在使用nullptr表示指针空值时，不需要包含头文件，因为nullptr是C++11作为新关键字引入的；
2. 在C++11中，sizeof(nullptr)与sizeof((void*)0)所占的字节数相同；
3. 为了提高代码的健壮性，在后续表示空指针时建议最好使用nullptr。