C++ 基础内容入门

命名空间

在C/C++中，由于变量、函数和类等的大量存在，这些变量，函数和类的名称都存在于全局作用域中，可能会导致很多命名冲突。
使用命名空间的目的就是对标识符和名称进行本地化，以避免命名冲突或名字污染，namespace关键字的出现就是针对这种问题的。

命令空间的定义

1、定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接⼀对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等。
2、 namespace本质是定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量。命令空间中所有内容都局限于该命名空间中。
3、 C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量/函数/类型出处(声明或定义)的逻辑，所以有了域隔离，名字冲突就解决了。局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。
4、namespace只能定义在全局，但是他还可以嵌套定义。
5、项目工程中多文件中定义的同名namespace会认为是⼀个namespace。

命名空间的普通定义：

namespace N1 //N1为命名空间的名称
{
	//在命名空间中，既可以定义变量，也可以定义函数
	int a;
	int Add(int x, int y)
	{
		return x + y;
	}
}

命名空间的嵌套定义

//命名空间的嵌套定义
namespace N1 //定义一个名为N1的命名空间
{
	int a;
	int b;
	namespace N2 //嵌套定义另一个名为N2的命名空间
	{
		int c;
		int d;
	}
}

命名空间的使用

编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以如果我们需要使用命名空间中变量或者函数等，有以下三种方式。

1.指定命名空间访问

符号"::"是作用域限定符，“命名空间名称::命名空间成员”可以指定访问到某个命名空间中相应的成员

//命名空间名称::作用域限定符
#include <stdio.h>
namespace N
{
	int a;
}
int main()
{
	N::a = 1;//将命名空间中的成员a赋值为1
	printf("%d\n", N::a);//打印命名空间中的成员a
	return 0;
}

2.使用using将命名空间中某个成员展开

//使用using将命名空间中的成员引入
namespace N
{
	int a;
}
using N::a;//将命名空间中的成员a引入
int main()
{
	a = 1;//将命名空间中的成员a赋值为1
	printf("%d\n", a);//打印命名空间中的成员a
	return 0;
}

3.展开命名空间中全部成员

//使用using namespace 命名空间名称引入
namespace N
{
	int a;
}
using namespace N;//将命名空间N的所有成员引入
int main()
{
	a = 1;//将命名空间中的成员a赋值为1
	printf("%d\n", a);//打印命名空间中的成员a
	return 0;
}

C++输入与输出

iostream是InputOutputStream的缩写，是标准的输入、输出流库，定义了C++标准的输入、输出对象。类似于C语言中的stdio.h
C++通过cin/cout进行输入和输出，属于C++标准库，C++标准库都放在std这个命名空间中。
包含了头文件iostream和std标准命名空间后就可以正常使用了。

#include <iostream> // 头文件
using namespace std; // srd标准命名空间
int main()
{
	//C++的输入输出不需要增加数据格式控制
	int i;
	double d;
	char arr[20];
	cin >> i;//读取一个整型
	cin >> d;//读取一个浮点型
	cin >> arr;//读取一个字符串
	cout << i << endl;//打印整型i // endl表示换行
	cout << d << endl;//打印浮点型d
	cout << arr << endl;//打印字符串arr
	return 0;
}

缺省参数

缺省参数是声明或定义函数时为函数的参数指定⼀个缺省值。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参，缺省参数分为全缺省和半缺省参数。（缺省参数也叫默认参数）

全缺省参数

即函数的全部形参都设置为缺省参数

void Print(int a = 10, int b = 20)
{
    // 未传参时 a b 分别为10  20
	cout << a << endl; 
	cout << b << endl;
}

半缺省参数

函数的参数不全为缺省参数

void Print(int a, int b = 10)
{
	// a需要传参，b可以选择性传参，没有传时b默认为10
	cout << a << endl;
	cout << b << endl;
}

半缺省参数有3个注意点：

1、半缺省参数必须从右往左依次给出，不能间隔着给。

//c没有缺省参数，但是b有，间隔着给缺省参数，所以这样是错误的
void Print(int a, int b = 20, int c)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

2、缺省参数不能在函数声明和定义中同时出现

//错误例子
//test.h
void Add(int a, int b, int c = 30);
//test.c
void Add(int a, int b, int c = 30)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}
// 缺省参数只能在函数声明时出现，或者函数定义的时候出现，即当其中一个有出现缺省参数时，另一个的参数中就不能出现缺省参数

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

int x = 30;//全局变量
void Print(int a, int b = 20, int c = x)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

函数重载

C++支持在同⼀作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同。这样C++函数调用就表现出了多态行为，使⽤更灵活。
常用来处理函数实现的功能类似，数据类型不同的情况。

#include <iostream>
using namespace std;
int Print(int x, int y)
{
	cout << x << endl;
	cout << y << endl;
}

double Print(double x, double y)
{
	cout << x << endl;
	cout << y << endl;
}
int main()
{
	cout << Print(1, 2) << endl;
	cout << Print(1.1, 2.2) << endl;
	return 0;
}

注意：形参列表不同是指参数个数、参数类型或者参数顺序不同，若仅仅是返回类型不同，则不能构成重载。

函数重载的原理

C++支持函数重载，C语言不支持函数重载

首先，一个C/C++程序要运行需要经历几个阶段：预处理、编译、汇编、链接。

在编译阶段会将程序中的每个源文件的全局范围的变量符号分别进行汇总。汇编阶段会给每个源文件汇总出来的符号分配一个地址（如果符号只是一个声明，就只给其分配一个无意义的地址），然后分别生成一个符号表。最后在链接期间会将每个源文件的符号表进行合并，如果不同的源文件的符号表出现了相同的符号，则取合法的地址为合并后的地址（重定位）

在C语言中，汇编阶段进行符号汇总时，一个函数汇总后的符号就是其函数名，所以当汇总时发现多个相同的函数符号时，编译器就会报错。而C++进行符号汇总时，对于函数的名字修饰做了改动，函数汇总出的符号不仅仅只是函数的函数名，而是通过其参数的类型和个数以及顺序等信息汇总一个符号，所以就算是函数名相同的函数，只要其参数的类型或参数的个数或参数的顺序不同，那么汇总出来的符号就不同。

总结：
1、C语言不能支持重载，是因为同名函数没办法区分。而C++是通过函数修饰规则来区分的，只要函数的形参列表不同，修饰出来的名字就不一样，也就支持了重载。
2、另外我们通过以上也能理解，为什么函数重载要求的是参数类型/参数个数/参数顺序的不同，与返回值没关系。

extern C

有时候在C++工程中可能需要将某些函数按照C的风格来编译，在函数前加“extern C”，即告诉编译器，将该函数按照C语言规则来编译。
如果使用extern C后，该函数就不能支持重载了

引用

引用不是定义一个变量，而是已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它所引用的变量共用同一块内存空间。
类似于李逵的引用就是黑旋风，林冲的引用是豹子头
类型& 引用别名=引用对象;

int main()
{
	int a = 10;
	int& b = a;//给变量a取了一个别名，叫b
	cout << "a = " << a << endl;//a打印结果为10
	cout << "b = " << b << endl;//b打印结果也是10
	b = 20;//改变b也就是改变了a
	cout << "a = " << a << endl;//a打印结果为20
	cout << "b = " << b << endl;//b打印结果也是为20
	return 0;

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

引用的特性

1、引用在定义时必须初始化

int a = 10;
int& b = a;//引用在定义时必须初始化

2、一个变量可以有多个引用

int a = 10;
int& b = a;
int& c = a;
int& d = a;
// 此时 b,c,d都是a的引用

3、引用一旦引用了一个实体，就不能再引用其它实体

	int a = 10;
	int& b = a;
	int c = 20;
	b = c;//这里看似想让b转为引用c，但其实是将b赋值为c

常引用

上面提到，引用类型必须和引用实体是同种类型的。但是仅仅是同种类型，还不能保证能够引用成功，我们若用一个普通引用类型去引用一个被const所修饰的对应类型，那么引用将不会成功。

int main()
{
	const int a = 10;
	//int& ra = a;    //该语句编译时会出错，a为常量
	const int& ra = a;//正确
	
	//int& b = 10;    //该语句编译时会出错，10为常量
	const int& b = 10;//正确
	return 0;
}

由于const修饰的类型是常量，不能被改变，而将其赋值给一个变量，属于权限放大，这样是不允许的，但是可以权限缩小。

引用的使用场景

1、引用做参数

//交换函数
void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
// 这里类似于C语言中的传址，能够真正将实参a和b的值进行交换

2、引用做返回值

引用也能做返回值，但是要特别注意，我们返回的数据不能是函数内部创建的普通局部变量，因为在函数内部定义的普通的局部变量会随着函数调用的结束而被销毁。我们返回的数据必须是被static修饰或者是动态开辟的或者是全局变量等不会随着函数调用的结束而被销毁的数据。

int& Add(int a, int b)
{
	static int c = a + b;
	return c;
}

注意：如果函数返回时，出了函数作用域，返回对象还未还给系统，则可以使用引用返回；如果已经还给系统了，则必须使用传值返回。

引用和指针的区别

在语法概念上，引用就是一个别名，没有独立的空间，其和引用实体共用同一块空间

int main()
{
	int a = 10;
	//在语法上，这里给a这块空间取了一个别名，没有新开空间
	int& ra = a;
	ra = 20;

	//在语法上，这里定义了一个pa指针，开辟了4个字节（32位平台）的空间，用于存储a的地址
	int* pa = &a;
	*pa = 20;
	return 0;
}

但是在底层实现上，引用实际是有空间的
从汇编角度来看，引用的底层实现也是类似指针存地址的方式来处理的。

引用和指针的区别

1、引用在定义时必须初始化，指针没有要求。
2、引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
3、没有NULL引用，但有NULL指针。
4、在sizeof中的含义不同：引用的结果为引用类型的大小，但指针始终是地址空间所占字节个数（32位平台下占4个字节）。
5、引用进行自增操作就相当于实体增加1，而指针进行自增操作是指针向后偏移一个类型的大小。
6、有多级指针，但是没有多级引用。
7、访问实体的方式不同，指针需要显示解引用，而引用是编译器自己处理。
8、引用比指针使用起来相对更安全

内联函数

用inline修饰的函数叫做内联函数，编译时C++编译器会在调用的地方展开内联函数，这样调用内联函数就不需要建立栈帧了，可以提高效率。

内联函数的特性

1、inline对于编译器而言只是⼀个建议，也就是说，你加了inline编译器也可以选择在调用的地方不展开，不同编译器关于inline什么情况展开各不相同，因为C++标准没有规定这个。inline适用于频繁调用的短小函数，对于递归函数，代码相对多⼀些的函数，加上inline也会被编译器忽略。
2、inline是一种以空间换时间的做法，省了去调用函数的额外开销。
3、 inline不建议声明和定义分离到两个⽂件，分离会导致链接错误。因为inline被展开，就没有函数地址，链接时会出现报错。

auto关键字(C++11)

auto能够在编译时对变量的类型进行推导

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

auto的使用

1、auto与指针和引用结合使用

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

#include <iostream>
using namespace std;
int main()
{
	int a = 10;
	auto b = &a;   //自动推导出b的类型为int*
	auto* c = &a;  //自动推导出c的类型为int*
	auto& d = a;   //自动推导出d的类型为int
	//打印变量b,c,d的类型
	cout << typeid(b).name() << endl;//打印结果为int*
	cout << typeid(c).name() << endl;//打印结果为int*
	cout << typeid(d).name() << endl;//打印结果为int
	return 0;
}

因此，用auto声明引用时必须加&，否则创建的只是与实体类型相同的普通变量

2、在同一行定义多个变量

同一行中，声明多个变量时，这些变量的类型必须相同，因为编译器只对第一个类型进行推导，然后用推导出来的结果定义其它变量

int main()
{
	auto a = 1, b = 2; //正确
	auto c = 3, d = 4.0; //编译器报错：“auto”必须始终推导为同一类型
	return 0;
}

auto不能推导的场景

1、auto不能作为函数的参数

auto不能作为形参类型，因为编译器无法对x的实际类型进行推导

// 错误
void TestAuto(auto x)
{}

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

int main()
{
	int a[] = { 1, 2, 3 };
	auto b[] = { 4, 5, 6 };//error
	return 0;
}

基于范围的for循环(C++11)

常规遍历：

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

基于范围的for循环遍历：

	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//打印数组中的所有元素
	// 格式 范围内用于迭代的变量 : 被迭代的范围
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;

注意：与普通循环类似，可用continue来结束本次循环，也可以用break来跳出整个循环

范围for的使用条件

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

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

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

关于迭代器的使用

指针空值nullptr

在声明一个变量的同时最好给该变量一个合适的初始值，否则可能会导致错误。

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

/* Define NULL pointer value */
#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else  /* __cplusplus */
#define NULL    ((void *)0)
#endif  /* __cplusplus */
#endif  /* NULL */

可以看到，NULL可能被定义为字面常量0，也可能被定义为无类型指针(void*)的常量。

 #include<iostream>
 using namespace std;
 void f(int x)
 {
 	cout << "f(int x)" << endl;
 }
 void f(int* ptr)
 {
 	cout << "f(int* ptr)" << endl;
 }
 int main()
 {
 	f(0);		   // 打印结果f(int x)
 	f(NULL);       // 打印结果f(int x)
 	f((int*)NULL); // 打印结果f(int* ptr)
 	f(nullptr);
    return 0;
 }

本意是想通过f(NULL)调用指针版本的f(int* p)函数，但是由于NULL被定义为0，f(NULL)最终调用的是f(int p)函数

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

指针空值nullptr

对于C++98中的问题（NULL被定义为0），C++11引入了关键字nullptr。

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