C++入门必备知识

本期将为大家带来C++入门必备知识，包括命名空间、输入与输出、引用 &、内联函数、关键字 auto、指针空值nullptr

命名空间

在C/C++中，变量、函数和后面要学到的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。
例如：在C语言中定义的全局变量rand和头文件<stdlib.h>中的rand就有所冲突。

这就是命名冲突导致的错误，所以在C++中就增加了命名空间这一语法。

域

在C++中，域可分为全局域，局部域，命名空间域，类域。

::域作用限定符

（指定域的名称）::（名称）//若域的名称为空这为全局域

编译器搜索变量名称方式：
1. 若变量没有::域作用限定符修饰，这搜索顺序为当前的局部域 -> 全局域
2. 若使用::域作用限定符指定了域，则直接搜索指定的域

关键字namespace

使用方式：

namespace typename
{
	//.....
}

在日常的代码编写中，我们如果需要同时编写两种不同的数据结构如Queue（队列）、Stack（栈），像这两种数据结构都有着不同的Init(初始化)、push(插入)、pop(删除).....这个时候就不得不为取名而苦恼了，我们可以使用如下的方法编写：

namespace S
{
	struct Stack
	{
		int* a;
		int size;
		int capacity;
	};
	void Init(struct Stack* a);
	void Push(struct Stack* a, int x);
	void Pop(struct Stack* a);
}

namespace Q
{
	struct Node
	{
		int val;
		struct Node* next;
	};

	struct Queue
	{
		struct Node* head;
		struct Node* tail;
		int size;
	};

	void Init(struct Queue* node);
	void Push(struct Queue* node, int x);
	void Pop(struct Queue* node);
}

int main()
{
	S::Stack stack;
	S::Init(&stack);
	S::Push(&stack, 1);
	S::Pop(&stack);

	Q::Queue queue;
	Q::Init(&queue);
	Q::Push(&queue, 1);
	Q::Pop(&queue);

	return 0;
}

而在C++头文件< iostream >中，cout,endl是C++中ostream 类型的对象，我们在使用时需要指定命名空间std域，因为std是所有C++库的命名空间，例如：

std::cout<< a << std::endl;

当然，我们也可以直接全部展开std命名空间，例如：

using namespace std;
cout<< a << endl;

同样，我们也可以使用using将命名空间中某个成员引入全局域中，例如：

using std::cout
using std::endl;
cout<< a << endl;

不过，命名空间直接展开，对于小型代码编写或许没有什么问题，但是对于大型项目来说依旧很难避免命名冲突的问题，所以全局直接展开对于项目要慎用，对于日常编写代码影响较小。

输入与输出

cout cin 为io流，c代表控制台console的缩写，所以cout就是输出，cin就是输入。
相较于C语言，cout和cin是自动识别类型。
输入与输出的操作符：流提取 >> ，流插入 <<
例如：输入a的值，并打印

#include<iostream>

int main()
{
	int a;
	std::cin>>a;
	std::cout<<a;
	return 0;
}

引用 &

引用使用方法如下：

int a=0;
int& b = a;

此时，b是a的别名。

特性：
1. 引用必须初始化
2. 引用定义后，不能改变指向
3. 一个变量可以有多个引用，多个别名

引用的两个常用使用场景

• 在函数传参时，也可以使用引用代替指针，例如：

1. 使用指针实现Swap(int* x,int* y)交换函数

void Swap(int* x,int* y)
{	
	int tmp=*x;
	*x=*y;
	*y=tmp;
}

2. 使用引用实现Swap(int& x,int& y)交换函数

void Swap(int& x,int& y)
{	
	int tmp=x;
	x=y;
	y=tmp;
}

• 做返回值

观察下面的代码，来猜猜运行结果吧。

#include<iostream>
using namespace std;

int& Add(int x, int y)
{
	int a = x + y;
	return a;
}

int add(int x, int y)
{
	int a = x + y;
	return a;
}

int main()
{
	int ret0 = add(1, 2);
	int ret1 = Add(1, 2);
	int& ret2 = Add(1, 2);
	
	cout << ret0 << "|" << ret1 << "|" << ret2 << endl;
	add(3, 4);
	Add(3, 4);
	cout << ret0 << "|" << ret1 << "|" << ret2 << endl;
	return 0;
}

运行结构如下：

解析：

• 对于ret0来说，这是一次较为正常的返回值返回。
  ret0为int类型，在函数返回值返回时，返回值会进行一次临时拷贝，然后函数栈帧进行销毁，临时变量赋值给ret0
  过程如下图：

• 对于ret1来说，这是一次不正常的返回值返回。
  ret1为int类型，Add的返回类型为int&，返回的是a的别名，但我们都知道，Add函数运行结束后，该函数对应的栈空间就被回收了，此时的变量a就没有意义了，所以这里ret1的值应根据编译器而定。如果该函数栈空间被销毁后编译器清理使用栈空间的空间，则ret1为随机值。但是我们可以看到结果为3，说明编译器并未清理栈空间，所以返回值为3,并且后续也并没有改变。
  

• 对于ret2来说，这是一次不正常且危险的返回值返回。
  ret2的类型为int&，返回值类型为int&，所以ret2接收到a的引用，也就是能够访问到Add函数中a的内存地址，这种危险程度就相当于野指针的使用，我们可以将其称为野引用，所以我们在第二次调用Add函数并进行其他数字的相加时，ret2也随之变化，因为ret2为该空间的引用，这是一种非常危险的行为，如果编译器在占空间销毁后进行清理，访问的为随机数，如果再调用其他函数时，ret2依旧指向该位置，可能对该位置原来的值造成干扰，或者直接导致程序崩溃。

• 综上，我们可以得到：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。

C++的引用的作用：对指针使用比较复杂的场景进行一些替换，让代码更简单易懂，但是不能完全代替指针

引用无法取代指针的原因：引用定义后，不能改变指向

引用与指针的区别

语法：
- 印用是别名，不开空间，指针是地址，需要开空间存储。
- 引用必须初始化，指针可以比初始化
- 引用不能改变指向，指针可以
- 引用相对更安全，没有空引用，但是有空指针，容易出现野指针，但不容易出现野引用
- 在sizeof中意义不同：引用结果为引用类型的大小，但是指针始终是地址空间 所占字节个数
- 有多级指针，没有多级引用

底层：
- 从汇编层面上，没有引用，都是指针，引用编译后也转换成了指针
- 引用底层是指针实现的。
- 语法含义和底层实现是背离的。

内联函数

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

以如下代码为例：

int Add(int x,int y)
{
	return x + y;
}

int main()
{
	int a = 0;
	a = Add(1, 2);
	return 0;
}

这是一个较为简单的函数调用且未使用内联函数，我们来看看他调用Add函数时的底层汇编，如下：

	a = Add(1, 2);
00021BCC  push        2  
00021BCE  push        1  
00021BD0  call        Add (021271h)  
00021BD5  add         esp,8  
00021BD8  mov         dword ptr [a],eax  

现在我们将Add普通函数改为内联函数，如下：

inline int Add(int x,int y)
{
	return x + y;
}
//更改后的Add函数

我们再来看看底层汇编，如下：

	a = Add(1, 2);
009A1BAC  mov         eax,1  
009A1BB1  add         eax,2  
009A1BB4  mov         dword ptr [a],eax  

• 我们可以清楚的看到，Add函数为普通的函数时，在主函数main中，调用Add函数是通过地址调用Add函数，在Add函数中实现计算并返回返回值；而在内联的Add函数中，因为编译器识别Add函数逻辑较为简单，就直接在main函数中进行替换展开，再调用内联的Add函数时，main函数中并使用call调用函数的地址，而是直接进行使用mov,add进行计算。

内联函数特性

1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，函数就不会进符号表，就没有函数地址了，链接就会找不到。

关键字 auto

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

注意：

1. 用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&
2. 当在同一行声明多个变量时，这些变量必须是相同的类型，否则编译器将会报错，因为编译器实际只对第一个>类型进行推导，然后用推导出来的类型定义其他变量。

auto a=1,b=2;  //pass
auto c=3,d=4.0;//error

3. auto不能作为函数的参数
4. auto不能直接用来声明数组

	int a[] = { 1,2,3 };
	auto b = a;			 //pass
	auto b[] = { 1,2,3 };//error

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

auto 在C++11中for的应用

对于一个有范围的集合而言，由程序员来说明循环的范围是多余的，有时候还会容易犯错误。因此C++11中引入了基于范围的for循环。for循环后的括号由冒号“ ：”分为两部分：第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

使用方法如下：

int main()
{
	int a[] = { 1,2,3,4,5,6,7,8,9,0 };
	for (auto& e : a)
	{
		std::cout << e << " ";
	}
	return 0;
}

运行结果如下：

指针空值nullptr

NULL实际是一个宏，在传统的C头文件(stddef.h)中，可以看到如下代码：

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

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

所以，在C++11中引入了nullptr专门表示空指针值。

结语

以上就是本期的全部内容了，喜欢就多多关注吧！！！