[ C++篇 ] C++基础知识

C++基础

命名空间

命名空间的定义

C++ 的 命名空间可以用来解决复杂项目中名字冲突的问题。
举个例子：C++ 标准库的所有内容均定义在 std 命名空间中，如果你定义了一个叫 cin 的变量，则可以通过 cin 来访问你定义的 cin 变量，通过 std::cin 访问标准库的 cin 对象，而不用担心产生冲突。

命名空间的定义使用关键字 namespace，后跟命名空间的名称，如下所示：

namespace name 
{
   // 代码声明
}

命名空间还可以嵌套，如下所示：

namespace A
{
	namespace B
	{
		void f()
		{
			.....
		}
	}
		void f()
		{
			B::f();实际访问的是 A::B::f()，由于当前位于命名空间A内，所以可以省略前面的A::
		}
}
void f()  // 这里定义的是全局命名空间的 f 函数，与 A::f 和 A::B::f都不会产生冲突
{
  A::f();
  A::B::f();
}

同一工程中允许存在多个相同名称的命名空间，编译器最后会合并成同一个命名空间

using指令

声明了命名空间之后，如果在命名空间外部访问命名空间内部的成员，需要在成员名前面加上 命名空间::。
如果我们想直接通过成员名访问命名空间内的成员，就需要用到using指令。

• using 命名空间::成员名。这条指令可以让我们省略某个成员名前的命名空间，直接通过成员名访问成员，相当于将这个成员导入了当前的作用域。
• using namespace 命名空间;。这条指令可以直接通过成员名访问命名空间中的任何成员，相当于将这个命名空间的所有成员导入了当前的作用域。

因此，如果执行了 using namespace std;，就会将 std 中的所有名字引入到全局命名空间当中。这样，我们就可以用 cin 代替 std::cin，用 cout 代替 std::cout。

由于 using namespace std; 会将 std 中的 所有名字 引入，因此如果声明了与 std 重名的变量或函数，就可能会因为命名冲突而导致编译错误。因此在工程中，并不推荐使用 using namespace 命名空间; 的指令。

命名空间的使用

命名空间的使用有三种方式：

• 加命名空间名称及作用域限定符

int main()
{
	int main()
	{
		printf("%d\n",N::a);
		return 0;
	}
}

• 使用using将命名空间某个成员引入

using N::b;
int main()
{
	printf("%d\n",b);
	return 0;
}

• 使用using namespace将某个命名空间引入

using namespace N;
int main()
{
	printf("%d\n",b);
	Add(10,20);
	return 0;
}

C++输入与输出

cin与cout

#include <iostream>

int main() {
  int x, y;                          // 声明变量
  std::cin >> x >> y;                // 读入 x 和 y
  std::cout << y << std::endl << x;  // 输出 y，换行，再输出 x
  return 0;                          // 结束主函数
}

问： 什么是std?
答：std 是 C++ 标准库所使用的 命名空间。使用命名空间是为了避免重名。

缺省函数

缺省参数概念

缺省参数是声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值。

void f(int a = 0)
{
	cout<<a<<endl;
}
int main()
{
	f(); //没有传参时，使用形参的缺省值
	f(10); //传参时，使用指定的实参
}

缺省参数分类

全缺省参数

void f(int a = 1, int b =2, int c = 3)
{
	....
}

半缺省参数

void f(int a, int b, int c = 10)
{
	.....
}

注意：

• 半缺省参数必须从右往左依次给出，不能间隔着给
• 缺省值不能在函数声明和定义中同时出现

  如果缺省值在声明和定义位置同时出现且不相同，那么编译器会报错，所有一般把缺省值放在声明处。

• 缺省值必须是常量或者全局变量

函数重载

自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。
比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！”

函数重载概念

C++允许在同一作用域中声明几个功能类似的同名函数，通过函数的的形参列表（参数个数或类型或类型顺序）不同来进行区分,不能根据返回值的类型区分。

函数重载的原理

C++代码在编译时会根据参数列表对函数名进行命重名，例如 void swap(int v1, int v2)会被重命名为 _swapii ，void swap(char v1,char v2)会被重命名为 _swapcc（不同的编译器会有不同的重命名规范，这里仅仅举例说明，实际情况可能并非如此）。当发生函数调用时，系统便会根据这些被重新命名的函数名去调用相应的函数。

因此从这个角度来讲，函数重载仅仅是语法层面上的，本质上它们还是不同的函数，占用不同的内存，入口地址也不一样。

引用

引用概念

引用不是新定义一个变量，而是给已存在的变量取一个别名，它和它引用的变量共用一块内存空间。引用的基本原则是在声明时必须指向对象，以及对引用的一切操作都相当于对原对象操作。

//类型& 引用变量名 = 引用实体
void TestRef()
{
		int a = 10;
		int& ra = a;
		printf("%p\n",&a);
		printf("%p\n",&ra);
}

注意：引用类型和引用实体必须是同类型的。

引用特性

• 引用在定义时必须初始化，即必须在定义说清是谁的别名
• 一个变量可以有多个引用
• 引用一旦引用一个实体，无法更改

常引用

指针和引用赋值时权限可以缩小，但不可放大

//权限不变
int a = 0;
int& ra = a;
//权限放大❌
const int b = 1;  
int& rb = b;      //b为常变量，rb的类型也应该为可读不可写类型
//权限缩小
int a = 0;
const int& ra = a;

使用场景

1.做输出参数：可对实参进行修改
2.做返回值
传值返回：函数的返回值先传给临时变量，再由临时变量传给要接收的变量。

函数被销毁不会影响临时变量

传引用返回：函数的返回值直接传给要接收的变量。
传引用返回好处：

1. 减少了拷贝，提高效率
2. 对的修改相当于直接对原值进行的修改。

变量类型转换会建立一个临时变量，临时变量具有常性，即不可修改。
故

		double d = 12.34;
		int& ri = d;  //不可
		const int& ri = d; //可以

同理：

int count( )
{
		int n = 0;
		return n;    //n为临时变量
}
int main( )
{
		int& ret = n;  //不可，n为临时变量，不可修改
		const int& ret = n;   //可以
		return 0；
}

内联函数

概念

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

void Sort(int * a,int n)
{
	....//
	swap(a,b);
}

那么当数组a中待排序元素较多时，swap函数必然会不断调用栈帧和销毁栈帧，影响程序运行的效果。
如何改进？
C语言用宏函数，但宏函数存在以下缺点：

• 不能调试
• 没有类型安全检查
• 容易写错

C++通过内联函数解决了以上问题。

特性

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

//如下风格的函数不能构成内联函数
inline void Fun(int x, int y); // inline仅与函数声明放在一起
void Fun(int x, int y)
{
…
}
而如下风格的函数Fun则构成内联函数
void Fun(int x, int y);
inline void Fun(int x, int y) // inline与函数定义体放在一起
{
…
}

auto关键字（C++11)

auto的简单介绍

auto可以在定义变量的时候根据变量初始值的类型自动为此变量选择匹配的类型，例如：

int a = 10;
auto b = a;//自动类型推断，au_a为int类型
cout << typeid(au_a).name() << endl;
//最终输出结果为int

typeid运算符可以输出变量的类型
auto在声明变量时必须用初始化

auto的用法

使用场景

1. auto与指针和引用结合起来使用
   用auto声明指针类型时，用auto和auto*没有任何区别，但用auto声明引用类型时则必须加&

int main()
{
int x = 10;
auto a = &x;
auto* b = &x;
auto& c = x;
return 0;
}

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

void TestAuto()
{
auto a = 1, b = 2;
auto c = 3, d = 4.0; // 该行代码会编译失败，因为c和d的初始化表达式类型不同
}

不能使用的场景

1. auto不能作为函数的参数类型

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto(auto a)
{}

2. auto不能直接用来声明数组

void TestAuto()
{
int a[ ] = {1,2,3};
auto b[ ] = {4，5，6};
}

3. 为了避免与C++98中的auto发生混淆，C++11只保留了auto作为类型指示符的用法
4. auto在实际中最常见的优势用法就是跟C++11提供的新式for循环，还有lambda表达式等进行配合使用。

基于范围的for循环（C++11）

范围for的语法

在C++98中如果要遍历一个数组，可以按照以下方式进行：

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for (int i = 0; i < sizeof(array) / sizeof(array[0]); ++i)
        array[i] *= 2;
    for (int* p = array; p < array + sizeof(array)/ sizeof(array[0]); ++p)
        cout << *p << endl;
}

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

void TestFor()
{
    int array[] = { 1, 2, 3, 4, 5 };
    for(auto& e : array)
        e *= 2;
    for(auto e : array)
        cout << e << " ";
}

范围for的使用条件

• for循环迭代的范围必须是确定的
  对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。
  注意：以下代码就有问题，因为for的范围不确定

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

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

指针空值nullptr(C++11)

C++98中的指针空值

在良好的C/C++编程习惯中，声明一个变量时最好给该变量一个合适的初始值，否则可能会出现不可预料的错误，比如未初始化的指针。如果一个指针没有合法的指向，我们基本都是按照如下方式对其进行初始化：

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

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

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

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

注意：

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