C++入门基础总结（最详细）

目录

Ⅰ.命名

关键字与命名空间

1.命名空间里的内容

2.命名空间的嵌套

3.多种使用方式

4.多文件工程重名处理

Ⅱ.缺省参数

1.缺省参数概念

2.缺省参数分类

Ⅲ.函数重载

1.函数重载的概念

注意：下列情况不能重载！！

Ⅳ. 内联函数（Inline）

1.内联函数的概念

2.内联函数的特性与用法

Ⅴ. auto关键字(C++11)

1.auto的使用细则

2.auto的注意事项

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

4.范围 for 的使用注意事项

Ⅵ.指针空值 nullptr

引入 nullptr 的原因

Ⅶ.引用

1.引用概念

2.引用特性

3.引用的应用

4.常引用

权限的放大

权限的缩小

保持权限的一致

5.引用与指针的区别

Ⅰ.命名

关键字与命名空间

C++关键字：

众所周知，给变量或者函数命名时不能用关键字，但是如果非要用怎么办呢？

为了很好地解决这种冲突的问题，C++ 就加入了命名空间的特性！在 C++ 里，我们就可以利用 "命名空间" 来解决这个问题，所以 C++ 提出了一个新语法 —— 命名空间 namespace！

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

1.命名空间里的内容

命名空间里的内容，不仅仅可以存放变量，还可以在里面放函数，结构体，甚至是 类

#include <stdio.h>
 
namespace N1 {
	int a = 10;
	int b = 20;
	int Add(int x, int y) {
		return x + y;
	}
}
 
namespace N2 {
	int c = 0;
	struct Node {
		struct Node* next;
		int val;
	};
}
 
int main(void)
{
	int res = N1::Add(N1::a, N1::b);
	printf("result = %d", res);
 
	struct N2::Node node1;
 
	return 0;
}

2.命名空间的嵌套

#include<iostream>
namespace N2
{
	int a=10;
	int b=2;
	int Add(int left, int right)
	{
		return left + right;
	}
 
	namespace N3
	{
		int c=3;
		int d=40;
		int Sub(int left, int right)
		{
			return left - right;
		}
	}
}
 
int main()
{
	int ret = N2::N3::Sub(N2::a, N2::N3::d);
	printf("%d", ret);    //-30
	return 0;
}

虽然套了这么多层，但是它们仍然都是全局的，只是套在了一个命名空间内而已

3.多种使用方式

方法一：空间名 + 作用域限定符 

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

方法二：使用 using namespace 命名空间名称引入 （会破坏隔离效果）

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

也就是全展开，说白了就是约等于完全没用到namespace，跟直接定义在全局一样

方法三：使用 using 将命名空间中成员引入

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

最常见的用法

4.多文件工程重名处理

项目中定义的某个命名空间的名字和其他命名空间的名字冲突了怎么办？

C++规定，同一个工程中允许存在多个相同的命名空间，编译器最后会将它们合成到一起

Ⅱ.缺省参数

1.缺省参数概念

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

void TestFunc(int a = 0) {
	cout << a << endl;
}
int main()
{
	TestFunc(); // 没有传参时，使用参数的默认值
	TestFunc(10); // 传参时，使用指定的实参
}

2.缺省参数分类

void TestFunc(int a = 10, int b = 20, int c = 30) {
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

void TestFunc(int a, int b = 10, int c = 20) {
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;
}

注意：

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

2. 缺省参数不能在函数声明和定义中同时出现，如：

//a.h
void TestFunc(int a = 10);
// a.c
void TestFunc(int a = 10)
{}
// 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该用那
个缺省值。

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

4. C 语言不支持（编译器不支持）

Ⅲ.函数重载

1.函数重载的概念

#include <iostream>
using namespace std;
 
int Add(int x, int y) {
	cout << "int x, int y" << endl;        // 为了方便区分
	return x + y;
}
double Add(double x, double y) {
	cout << "double x, double y" << endl;  // 为了方便区分
	return x + y;
}
void Func(int a) {
	cout << "Func(int a)" << endl;
}
void Func(char b, int a) {
	cout << "Func(char b, int a)" << endl;
}
void Func(int a, char b) {
	cout << "int a, char b" << endl;
}
 
 
int main(void)
{
	cout << Add(1, 2) << endl;
	cout << Add(1.1, 2.2) << endl;
 
	Func(10);
	Func('A', 20);
	Func(10, 'A');
 
	return 0;
}

注意：下列情况不能重载！！

int f(int a) {
    ;
}
 
void f(int a) {
    ;
}

short Add(short left, short right) {
	return left + right;
}
int Add(short left, short right) {
	return left + right;
}

#include <iostream>
using namespace std;
 
void func() {
    cout << "func()" << endl;
}
 
void func(int a = 0) {
    cout << "func(int a)" << endl;
}
 
int main(void)
{
    func();   // 调用存在歧义，报错
    func(1);  // 可以 
 
    return 0;
}

Ⅳ. 内联函数（Inline）

1.内联函数的概念

同时为了替换c语言中宏函数，C++引入了inline函数。

那么C++为啥不继续使用宏函数呢？

宏的优缺点？

优点：

1. 增强代码的复用性。
2. 提高性能。

缺点：

1.  宏无法调试（因为宏在程序预编译阶段进行替换）。
2.  宏的大量使用可能会导致代码的可读性差，可维护性差，容易误用。
3.  宏没有类型安全的检查

为了填C语言的坑，C++引入了inline函数；

2.内联函数的特性与用法

1.  inline是一种以空间换时间的做法，省去调用函数额开销。所以代码很长或者有循环/递归的函数不适宜 使用作为内联函数。
2. inline对于编译器而言只是一个建议，编译器会自动优化，如果定义为inline的函数体内有循环/递归等等，编译器优化时会忽略掉内联。
3.  inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会 找不到。

 宏与inline函数对比

#include <iostream>
using namespace std;
 
inline int Add(int x, int y) {
    int ret = x + y;
    return ret;
}
 
int main(void)
{
    cout << "内联函数: " << Add(1, 2) << endl;
 
    return 0;
}

#include<iostream>
using namespace std;
 
// 写一个两数相加的宏
#define ADD(X, Y) ((X) + (Y))
 
int main(void)
{
 
    cout << "宏: " << ADD(1, 2) << endl;
    // 写宏的技巧：记住宏原理是替换，你替换一下看看对不对
    cout << "宏: " << 10 * ADD(3, 4) << endl;
 
    return 0;
}

对比发现，写宏要非常小心括号问题，而inline函数直接在正常函数前面加个inline就完事儿了

Ⅴ. auto关键字(C++11)

在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量。

C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型 指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

typeid().name函数可以用来让编译器告知某个变量的类型是什么，该函数的返回类型是一个字符串。

int TestAuto()
{
	return 10;
}
int main()
{
	int a = 10;
	auto b = a;//a是整型，编译器推导出变量b的类型是int型
	auto c = 'a';//'a'是字符型，编译器推导出变量c的类型是char类型
	auto d = TestAuto();//TestAuto函数的返回类型是int型，编译器推导出变量d的类型是int型
    const int e = 10;
    auto ie = &e;
 
	cout << typeid(b).name() << endl;//输出结果为int
	cout << typeid(c).name() << endl;//输出结果为char
	cout << typeid(d).name() << endl;//输出结果为int
	cout << typeid(ie).name() << endl;//输出结果为const int *  
 
	//auto e; 无法通过编译，使用auto定义变量时必须对其进行初始化
	return 0;
}

一般来说用于推出长而复杂的类型，如下： 

#include <iostream>
#include <map>
 
int main(void) 
{
    std::map<std::string, std::string> dict = {{"sort", "排序"}, {"insert", "插入"}};
    std::map<std::string, std::string>::iterator it = dict.begin();
    // 这个类型又臭又长，写起来太麻烦了。。。
    
    auto it = dict.begin();   // 可以改成这样，爽！
    // ↑ 根据右边的返回值去自动推导it的类型，写起来就方便多了
 
    return 0;
}

1.auto的使用细则

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

int a = 10;
auto* pa = &a;//指定pa为指针类型
auto* ppa = &pa;
auto& ia = a;//指定ia的类型为引用类型
auto* pa = a;//程序非法，因为指定了pa的类型是指针类型，但是我们却给它赋了地址
cout << typeid(pa).name() << endl;//输出结果为int *
cout << typeid(ppa).name() << endl;//输出结果为int **
cout << typeid(ia).name() << endl;//输出结果为int

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

auto a = 10, d = 3.14;//错误的使用方式
auto i = 0, *p = &i;//正确的使用方式，i是整数，p是整型指针
auto a = 10, b = 20;//正确的使用方式，因为经过编译器推导之后，程序会变成下面的定义方式
int a = 10, b = 20;

3.auto在使用时会遵循隐式类型转换的规则。

int main()
{
	auto a = 3.14 + 5;//表达式3.14和5相加后的类型转换为double类型，值为8.14
	cout << typeid(a).name() << endl;
	return 0;
}

2.auto的注意事项

1. 使用 auto 是必须要给值的！

int i = 0;
auto j;  //错误
 
auto j = i;  //必须给值！！

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

• 2.auto 不能作为函数的参数

// 此处代码编译失败，auto不能作为形参类型，因为编译器无法对a的实际类型进行推导
void TestAuto1(auto a)//注意：auto也不能作为缺省参数，例如：void TestAuto1(auto a = 10) {}
{}
auto TestAuto2(int a)
{}

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

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

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

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

在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 };
    //下面的auto是元素的类型，我们也可以将其写为int，因为数组元素都是int类型
	for (auto& e : array)//必须使用引用才能拷贝，因为e只是array数组中元素的临时拷贝
		e *= 2;
 
	for (auto e : array)
		cout << e << endl;
}
int main()
{
	TestFor();
	return 0;
}

范围for工作原理：依次取数组array中的元素，然后将其赋值给临时变量e（但是e的改变不会改变数组，除非使用引用），然后达到了遍历的目的。

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

4.范围 for 的使用注意事项

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

下面的代码就是 for 循环范围不确定！

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

这里传递过来的是数组的首元素地址，并不是数组，它会不知道范围是多少，所以会报错

Ⅵ.指针空值 nullptr

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

如果一个指针没有合法的指向，我们就需要手动给它置为空。

在之前的C语言教程里，我们都是用 NULL 来解决的：

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

引入 nullptr 的原因

正如之前所说，NULL 其实是一个宏：

我们打开传统的 C 头文件 （stddef.h） 中可以看到如下代码：

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

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

不论采取何种定义，在使用空值和指针时，都不可避免地会遇到一些麻烦，比如：

void Func(int)
{
	cout << "Func(int)" << endl;
}
void Func(int*)
{
	cout << "Func(int*)" << endl;
}
int main()
{
	Func(0);
	Func(NULL);
	Func((int*)NULL);
 
	return 0;
}

注意：

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

Ⅶ.引用

1.引用概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

概念：引用就是给一个已经存在的变量取一个别名。

语法：数据类型&  引用名 =  引用实体；

2.引用特性

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

int& b;  //错误

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

int a = 10;
 // int& ra; // 该条语句编译时会出错
int& ra = a;
int& rra = a;

3. 引用一旦引用一个实体，再不能引用其他实体

#include<iostream>
using namespace std;
int main()
{
	int a = 10,c = 20;
	int& b = a;
    &b = c;//报错
 
	return 0;
}

引用是不会变的，我们定义它的时候它是谁的别名，就是谁的别名了。以后就不会改了，它是从一而终的！！！

3.引用的应用

一个人当然可以有多个绰号，所以一个变量也可以有多个别名。

void TestRef()
{
	int a = 10;
	// int& ra; // 该条语句编译时会出错
	int& ra = a;
	int& rra = a;
	printf("%p %p %p\n", &a, &ra, &rra);
}

#include<iostream>
using namespace std;
 
void Swap(int x, int y) {
	int tmp = x;
	x = y;
	y = tmp;
}
 
void Swap(int* px, int* py) {
	int tmp = *px;
	*px = *py;
	*py = tmp;
}
 
void Swap(int& rx, int& ry) {
	int tmp = rx;
	rx = ry;
	ry = tmp;
}
 
int main(void)
{
	int a = 10;
	int b = 20;
 
	Swap(&a, &b);
	Swap(a, b);  // 报错
 
	return 0;
}

注意：传引用跟传值方式一样，所以函数重载时要注意了！

#include <iostream>
#define N 10
using namespace std;
 
 
int& At(int i) {
	static int arr[N];
	return arr[i];  // 返回的是数组的第i个的引用（别名）
}
 
int main(void)
{
	// 写
	for (size_t i = 0; i < N; i++) {
		At(i) = 10 + i;  // 依次给 11 12 13 14…… 给 At
	}
 
	// 读
	for (size_t i = 0; i < N; i++) {
		cout << At(i) << " ";  // 获取值，但是只是打印
	}
	cout << endl;
 
	return 0;
}

一定要用static修饰数组，这样出了作用域不会销毁,才不会导致错误。（数组为全局变量也行）

4.常引用

如果既要利用引用来提高程序的效率，又想要保护传递给函数的数据不能在函数中被改变，就应使用常引用。

语法：const 数据类型&  引用名 =  引用实体；

一共有三种情况：分别是权限的放大、保持权限不变、权限的缩小。

权限的放大

如果对引用实体使用 const 修饰，直接引用会导致报错：

int main(void)
{
    const int a = 10;
    int& ra = a;
 
    return 0;
}

权限的缩小

如果引用实体并没有被 const 修饰，是可读可写的，但是我希望它的引用不能修改它，我们可以用常引用来解决。

int main(void)
{
    int a = 10;
    const int& ra = a;
 
    return 0;
}

保持权限的一致

既然引用实体用了 const 进行修饰，我直接引用的话属于权限的放大，我们可以给引用前面也加上 const，让他们的权限保持不变。

int main(void)
{
    const int a = 10;
    const int& ra = a;
 
    return 0;
}

5.引用与指针的区别

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

6.引用深理解

A.引用必须初始化，必须在定义引用时明确引用的是哪个变量或者对象，否则语法错误，指针不初 始化时值为随机指向（引用必须被初始化，指针不必）

B.引用一旦定义时初始化指定，就不能再修改，指针可以改变指向

C.引用必须初始化，不能出现空引用，指针可以赋值为空

D.简单粗暴的引用理解可以理解为被引用变量或对象的"别名"

E.引用表面好像是传值，其本质也是传地址，只是这个工作有编译器来做，所以错误

F.函数调用为了提高效率，常使用引用或指针作为函数参数传递变量或对象