初识C++

1.C++的发展历史

• C++的起源可以追溯到1979年，当时Bjarne Stroustrup（本贾尼·斯特劳斯特卢普）在贝尔实验室从事计算机科学和软件工程的研究工作。面对项目中复杂的软件开发任务，尤其是模拟和操作系统的开发，他意识到现有语言（如C语言）在表达能力、可维护性和可扩展性方面的不足。
• 1983年，Bjarne Stroustrup在C语言的基础上加入了面向对象编程的特性，设计出了C++语言的雏形。此时的C++已经包含了类、封装、继承等核心概念，为后来的面向对象编程奠定了基础。这一年，C++正式命名为C++。
• 随后几年，C++在学术界和工业界的应用逐渐增多。许多大学和研究所开始将C++作为教学和研究的首选语言，一些公司也开始在产品开发中使用C++。这一时期，C++的标准库和模板等特性也得到了进一步的完善和发展。
• C++的标准化工作从1989年开始，并成立了一个由ANSI和ISO（国际标准化组织）组成的联合标准化委员会。1994年，标准化委员会提出了第一个标准化草案。在该草案中，委员会在保留斯特劳斯特卢普最初定义的所有特征的同时，还增加了部分新特性。
• 在完成C++标准化第一个草案后不久，STL（标准模板库）由惠普实验室开发，它是一系列软件的统称。由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工作时开发出来的。通过标准化第一个草案后，联合标准化委员会投票通过了将STL包含到C++标准中的提议。STL的加入拓展了C++的功能，超出了C++最初的定义范围。虽然将STL纳入标准是一个重要决定，但也因此延缓了C++标准化的进程。
• 1997年11月14日，联合标准化委员会通过了C++标准的最终草案，并于1998年正式发布了C++的ANSI/ISO标准。

2.C++的版本更新

 3.C++参考文档

https://legacy.cplusplus.com/reference/

https://zh.cppreference.com/w/cpp

https://en.cppreference.com/w/

第一个链接不是C++官方文档，标准仅更新到C++11，但它以头文件的形式呈现，内容较为易懂。后两个链接分别是C++官方文档的中文版和英文版，信息完整，更新到了最新的C++标准，但相对第一个链接不那么易懂。几个文档各有优势，可以结合使用。

4. 第一个C++程序 

C++兼容C语言绝大多数的语法，所以C语言实现的hello world依旧可以运行。在C++中需要把定义文件代码后缀改为.cpp。VS编译器看到是.cpp就会调用C++编译器编译，Linux下要用g++编译，不再是gcc 

当然是从hello world开始，这是c语言的

#include <stdio.h>
 
int main()
{
 printf("hello world\n");
 return 0;
}

 C++有一套自己的输入输出，虽然上面的也能被兼容

//这⾥的std cout等我们都看不懂，没关系，下⾯我们会依次讲解
#include<iostream>
using namespace std;
 
int main()
{
	cout << "hello world\n" << endl;
	return 0;
}

5.命名空间

5.1 namespace的价值

在C/C++中，变量、函数以及后续学习的类等标识符都会存在于全局作用域中，这可能导致许多命名冲突。使用命名空间的目的是将标识符的名称本地化，从而避免命名冲突或名字污染。引入namespace关键字的目的是为了解决这类问题，尤其是命名冲突的问题。

在C语言项目中，类似下面程序中的命名冲突问题是普遍存在的，而C++引入namespace正是为了更好地解决这些问题。

#include <stdio.h>
#include <stdlib.h>
int rand = 10;
int main()
{
    // 编译报错：error C2365: “rand”: 重定义；以前的定义是“函数”
	printf("%d\n", rand);
	return 0;
}

因为在<stdlib.h>这个头文件中，rand是已经定义好的函数，所以当我们打印rand时，编译器会报错（重复定义）。为了解决这样的问题C++就引入了namespace。

5.2 namespace的定义 

• 定义命名空间时，需要使用namespace关键字，后面跟命名空间的名字，然后用一对{}括起来，括号中的内容就是命名空间的成员。命名空间中可以定义变量、函数、类型等。namespace本质上定义了一个域，这个域与全局域是独立的，因此不同的域可以定义同名的变量，从而避免了命名冲突。例如，下面的rand就不会发生冲突。
• C++中存在多种域，包括函数局部域、全局域、命名空间域和类域。域的作用是影响编译时语法查找变量、函数或类型的出处（声明或定义）的逻辑。通过域的隔离，命名冲突得以解决。局部域和全局域不仅影响编译查找逻辑，还影响变量的生命周期，而命名空间域和类域则不影响变量的生命周期（它们是全局的）。
• 命名空间只能定义在全局作用域中，但它也可以嵌套定义。在项目工程中，如果在不同文件中定义了同名的命名空间，它们会被视为同一个命名空间，不会发生冲突。C++标准库中的内容都放在一个名为std（standard）的命名空间中。

#include <stdio.h>
 
#include <stdlib.h>
 
// bit是命名空间的名字，⼀般开发中是⽤项⽬名字做命名空间名。 
 
namespace bit
{
 // 命名空间中可以定义变量/函数/类型 
 int rand = 10;
 int Add(int left, int right)
 {
     return left + right;
 }
 
 struct Node
 {
     struct Node* next;
     int val;
 };
}
 
int main()
{
 // 这⾥默认是访问的是全局的rand函数指针 
 printf("%p\n", rand);
 // 这⾥指定bit命名空间中的rand 
 printf("%d\n", bit::rand);
 return 0;
}

由于main函数中没有rand，所以编译器会在全局域中进行搜索。而rand在头文件<stdlib.h>中已经被定义为一个函数，且头文件在预处理阶段就会被展开，因此一开始访问的是全局的rand函数指针。

如果要查找特定域中的标识符，可以使用命名空间名加上::运算符，这样就可以在指定的域中查找。如果在该域中找不到标识符，编译器不会再继续在其他域中查找。

printf("%d\n", a)默认访问的是局部的a，想要用全局的a就要在a前面加上::

编译器默认查找

1. 当前局部域
2. 全局域
3. 到展开的命名空间中找

在不同于中我们可以定义同名的变量/函数/类型

命名空间三种访问方法

1. 指定访问（使用命名空间的名字搭配::）例如：bit::
2. 到展开的命名空间域中查找。例如：using namespace bit
3. 指定展开某一个。例如：using bit:: x; x是命名空间中的变量x

命名空间还可以嵌套

//命名空间嵌套
namespace bit
{
	namespace ac
	{
		int rand = 1;
		int Add(int left, int right)
		{
			return left + right;
		}
	}
	namespace gb
	{
		int rand = 2;
		int Add(int left, int right)
		{
			return (left + right) * 10;
		}
	}
}
 
int main()
{
	printf("%d\n", bit::ac::rand);
	printf("%d\n", bit::gb::rand);
	printf("%d\n", bit::ac::Add(1, 2));
	printf("%d\n", bit::gb::Add(1, 2));
	return 0;
}

测试结果

多文件中可以定义同名namespace，他们会默认合并到一起，就像同一个namespace一样。 

#pragma once
//Stack.h
#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
 
namespace bit
{
	#define N 10000
	typedef int STDataType;
	typedef struct Stack
	{
		STDataType* a;
		int top;
		int capacity;
	}ST;
 
	static int x = 0;
	static int y = 0;
 
	// 缺省参数在声明给
	void STInit(ST* ps, int n = 4);
	void STDestroy(ST* ps);
 
	// 栈顶
	void STPush(ST* ps, STDataType x);
	void STPop(ST* ps);
	STDataType STTop(ST* ps);
	int STSize(ST* ps);
	bool STEmpty(ST* ps);
}
 
#include"Stack.h"
//Stack.cpp
namespace bit
{
	// 缺省参数不能声明和定义同时给
	void STInit(ST* ps, int n)
	{
		assert(ps);
 
		ps->a = (STDataType*)malloc(n * sizeof(STDataType));
		ps->top = 0;
		ps->capacity = n;
	}
 
	void STDestroy(ST* ps)
	{
		assert(ps);
 
		free(ps->a);
		ps->a = NULL;
		ps->top = ps->capacity = 0;
	}
 
	// 栈顶
	void STPush(ST* ps, STDataType x)
	{
		assert(ps);
 
		// 满了， 扩容
		if (ps->top == ps->capacity)
		{
			printf("扩容\n");
			int newcapacity = ps->capacity == 0 ? 4 : ps->capacity * 2;
			STDataType* tmp = (STDataType*)realloc(ps->a, newcapacity * sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			ps->a = tmp;
			ps->capacity = newcapacity;
		}
		ps->a[ps->top] = x;
		ps->top++;
	}
 
	void STPop(ST* ps)
	{
		assert(ps);
		assert(!STEmpty(ps));
		ps->top--;
	}
 
	STDataType STTop(ST* ps)
	{
		assert(ps);
		assert(!STEmpty(ps));
		return ps->a[ps->top - 1];
	}
 
	int STSize(ST* ps)
	{
		assert(ps);
		return ps->top;
	}
 
	bool STEmpty(ST* ps)
	{
		assert(ps);
		return ps->top == 0;
	}
}
 
//Test.cpp
int main()
{
	bit::ST st1;
	STInit(&st1);
	STPush(&st1, 1);
	STPush(&st1, 2);
	printf("%d\n", sizeof(st1));
	bit::ST st2;
	printf("%d\n", sizeof(st2));
	bit::STInit(&st2);
	bit::STPush(&st2, 1);
	bit::STPush(&st2, 2);
	return 0;
}

 运行结果

5.3 命名空间的使用 

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

• 指定命名空间访问，项目中推荐这种方式。
• using将命名空间中某个成员展开，项目中经常访问的不存在冲突的成员推荐这种方式。
• 展开命名空间中全部成员，项目不推荐，冲突风险很大，日常小练习程序为了方便推荐使用。

#include<stdio.h>
 
namespace bit
{
	int a = 0;
	int b = 1;
}
 
int main()
{
	// 编译报错：error C2065: “a”: 未声明的标识符 
    //不展开bit，默认是不会到bit域中查找的
	printf("%d\n", a);
	return 0;
}

// 指定命名空间访问
int main(){
    printf("%d\n", N::a);
    return 0;
}

// using将命名空间中某个成员展开
using N::b;
int main(){
    printf("%d\n", N::a);
    printf("%d\n", b);
    return 0;
}

// 展开命名空间中全部成员
using namespce N;
int main(){
    printf("%d\n", a);
    printf("%d\n", b);
    return 0;
}

6. C++输入&输出

• <iostream>是Input Output Stream的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。
• std::cin是istream类的对象，主要面向窄字符（char类型）的标准输入流。
• std::cout是ostream类的对象，主要面向窄字符的标准输出流。
• std::endl是一个函数，在流插入输出时，相当于插入一个换行字符并刷新缓冲区。
• <<是流插入运算符，>>是流提取运算符（在C语言中，这两个运算符也用于位运算的左移/右移）。
• 使用C++的输入输出更方便，不需要像printf/scanf那样手动指定格式，C++的输入输出可以自动识别变量类型（本质上通过函数重载实现，后面会讲到）。其实，C++输入输出最重要的一点是，它能够更好地支持自定义类型对象的输入输出。
• IO流涉及类和对象、运算符重载、继承等很多面向对象的知识，这些知识我们还没有讲解，所以这里我们只能简单认识C++ IO流的用法，后面会有专门的章节来详细讲解IO流库。
• cout、cin、endl等都属于C++标准库，而C++标准库放在一个叫std（standard）命名空间中，因此要通过命名空间的使用方式来使用它们。
• 在日常练习中，我们可以使用using namespace std，但在实际项目开发中不建议这样做。
• 这里没有明确包含<stdio.h>，但可以使用printf和scanf，因为在包含<iostream>时，间接包含了它。对于VS系列编译器是这样，其他编译器可能会报错。

int main()
{
	int a = 0;
	double b = 0.1;
	char c = 'x';
	cout << a << " " << b << " " << c << endl;
	std::cout << a << " " << b << " " << c << std::endl;
	/
	scanf("%d%lf", &a, &b);
	printf("%d %lf\n", a, b);
	//cin和cout可以自动识别变量类型
	cin >> a;
	cin >> b >> c;
	cout << a << endl;
	cout << b << " " << c << endl;
}

#include<iostream>
using namespace std;

int main(){
    // 在io需求⽐较⾼的地⽅，如部分⼤量输⼊的竞赛题中，加上以下3⾏代码
    // 可以提⾼C++IO效率
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    return 0;
}

7. 缺省参数

缺省参数是在声明或定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有为某个参数指定实参，则采用该形参的缺省值；如果指定了实参，则使用指定的实参。缺省参数可以分为全缺省和半缺省参数。（有些地方也称缺省参数为默认参数）

• 全缺省是指所有形参都给定缺省值。
• 半缺省是指部分形参给定缺省值。

C++规定，半缺省参数必须从右往左依次连续给定缺省值，不能间隔跳跃地给缺省值。

在带缺省参数的函数调用中，C++规定必须从左到右依次给实参，不能跳跃给实参。

当函数声明和定义分离时，缺省参数不能同时出现在声明和定义中，必须在函数声明时指定缺省值。

//全缺省
void Func1(int a = 10, int b = 20, int c = 30)
{
	cout << a << " " << b << " " << c << endl;
}
//半缺省
void Func2(int a, int b = 10, int c = 40)
{
	cout << a << " " << b << " " << c << endl;
}
 
int main()
{
	Func1();
	Func1(1,2,3);
	Func2(1);
	Func2(1, 2, 3);
	return 0;
}

运行结果

8.函数重载

C++支持在同一作用域中出现同名函数，但是要求这些同名函数的形参不同，可以是参数个数不同或者类型不同（也包括类型顺序不同）。这样C++函数调用就表现出了多态行为，使用更灵活。C语言是不支持同一作用域中出现同名函数的。

不同作用域可以同名，同一作用域也可以同名，但要满足重载规则。

#include<iostream>
using namespace std;
 
// 1、参数类型不同 
int Add(int left, int right)
{
	cout << "int Add(int left, int right)" << endl;
	return left + right;
}
 
double Add(double left, double right)
{
	cout << "double Add(double left, double right)" << endl;
	return left + right;
}
 
// 2、参数个数不同 
void f()
{
	cout << "f()" << endl;
}
 
void f(int a)
{
	cout << "f(int a)" << endl;
}
 
// 3、参数类型顺序不同 
 
void f(int a, char b)
{
	cout << "f(int a,char b)" << endl;
}
 
void f(char b, int a)
{
	cout << "f(char b, int a)" << endl;
}

 返回值不同不能作为重载条件，因为调用时也无法区分

// 返回值不同不能作为重载条件，因为调⽤时也⽆法区分 
 
void fxx()
{}
 
int fxx()
{
 return 0;
}

有些函数即使构成了重载，运行的时候也有可能报错

// 下⾯两个函数构成重载 
// f()但是调⽤时，会报错，存在歧义，编译器不知道调用谁 
void f1()
{
	cout << "f()" << endl;
}
 
void f1(int a = 10)
{
	cout << "f(int a)" << endl;
}
 
int main()
{
	f1();
	f1(10);
	return 0;
}

测试结果

因为全缺省实参可以不传值，所以在调用 f1() 时，编译器无法确定到底调用哪个函数，可能会导致歧义。而在 61 行的调用和 66 行的调用是可以分别调用不同的函数的，因为它们传递了不同的参数。

至于为什么C++支持重载，而C语言不支持，原因在于C语言无法通过函数名区分不同的函数，因为函数名本身没有区分度。而C++通过函数修饰规则（如函数的参数类型、个数等）来区分不同的函数，只要参数或类型不同，编译器就会生成不同的名字，从而支持函数重载。

9. 引用 

9.1 引用的概念的定义

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间， 它和它引用的变量共用同一块内存空间。比如：水浒传中李逵，宋江叫"铁牛"，江湖上人称"黑旋风"；林冲，外号豹子头；

类型& 引用别名 = 引用对象;

C++中为了避免引⼊太多的运算符，会复用C语言的一些符号，不如前面的>，这里引用也和取地址使用了同用个符号&，大家注意使用方法角度区分就可以。（吐槽一下，这个问题其实挺坑的，个人觉得用更多符号反而更好，不容易混淆）

int main()
{
	int a = 0;
	//引用：b和c是a的别名
	int& b = a;
	int& c = a;
	//也可以给别名b取别名，d相当于还是a的别名
	int& d = b;
	d++;
	cout << a << " " << b << " " << c << " " << d << endl;
	//这里取地址我们看到是一样的
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	cout << &d << endl;
 
	return 0;
}

8.2 引用的特性

• 引用在定义时必须初始化
• 一个变量可以有多个引用
• 引用一旦引用一个实体，再不能引用其他实体

int main()
{
	int a = 10;
	//引用的时候必须要进行初始化，否则会报错
	//int& ra;错误案例
	int& b = a;
	int c = 20;
	//这里并非是让b引用c,因为b是a的别名，不能再被修改了
	//这里b = c是赋值操作
	b = c;
	cout << &a << endl;
	cout << &b << endl;
	cout << &c << endl;
	return 0;
}

8.3 引用的使用

• 引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。 
• 引用传参跟指针传参功能是类似的，引用传参相对更方便一些。
• 引用返回值的场景相对⽐较复杂，我们在这里简单讲了一下场景，还有一些内容后续类和对象章节中会继续深入讲解。
• 引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向， Java的引用可以改变指向。
• 一些主要用C代码实现版本数据结构教材中，使用C++引用替代指针传参，目的是简化程序，避开复杂的指针，但是很多同学没学过引用，导致⼀头雾水。

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
 
int main()
{
	int x = 0;
	int y = 1;
	cout << x << " " << y << endl;
	Swap(x, y);
	cout << x << " " << y << endl;
	return 0;
}

 用引用传参使用栈

#include <iostream>
#include <assert.h>
#include <stdlib.h>
using namespace std;
typedef int STDataType;
 
typedef struct Stack
 
{
	STDataType* a;
	int top;
	int capacity;
}ST;
 
void STInit(ST& rs, int n = 4)
{
	rs.a = (STDataType*)malloc(n * sizeof(STDataType));
	rs.top = 0;
	rs.capacity = n;
}
 
// 栈顶 
void STPush(ST& rs, STDataType x)
{
	// 满了， 扩容 
	if (rs.top == rs.capacity)
	{
		printf("扩容\n");
		int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
		STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *
 
			sizeof(STDataType));
		if (tmp == NULL)
		{
			perror("realloc fail");
			return;
		}
		rs.a = tmp;
		rs.capacity = newcapacity;
	}
	rs.a[rs.top] = x;
	rs.top++;
}
 
 
int& STTop(ST& rs)
{
	assert(rs.top > 0);
	//返回类型是int&
	//所以引用的那块空间就是栈顶最上面的元素空间
	return rs.a[rs.top-1];
}
 
int main()
{
	// 调⽤全局的 
	ST st1;
	STInit(st1);
	STPush(st1, 1);
	STPush(st1, 2);
	cout << STTop(st1) << endl;
	//因为返回类型是引用
	//所以STTop(st1) += 10;就能改变栈顶元素
	STTop(st1) += 10;
	cout << STTop(st1) << endl;
	return 0;
}

运行结果 

8.4 const引用

• 可以引用⼀个const对象，但是必须用const引用。const引用也可以引用普通对象，因为对象的访问权限在引用过程中可以缩小，但是不能放大。  
• 不需要注意的是类似 int& rb = a*3; double d = 12.34; int& rd = d; 这样一些场景下a*3的和结果保存在一个临时对象中， int& rd = d 也是类似，在类型转换中会产生临时对象存储中间值，rb和rd引用的都是临时对象，而C++规定临时对象具有常性，所以这里就触发了权限放大，必须要用常引用才可以。
• 所谓临时对象就是编译器需要一个空间暂存表达式的求值结果时临时创建的一个未命名的对象， C++中把这个未命名对象叫做临时对象。

#include <iostream>
using namespace std;
 
int main()
{
	//可以权限的平移
	int x = 0;
	int& y = x;
 
	//可以，权限变小了
	const int& z = x;
	//z++; // 不行z是常量，不能被修改
	y++;
 
	//原本是只读的，但是赋给n就变成可读可写的
	//权限变大了，所以不可以
	const int m = 0;
	// int& n = m;
	//可以，权限的平移
	const int& n = m;
 
	//赋值操作，可以
	int p = m;
 
 
	const int* p1 = &m;
	// p1++;  const修饰的是*p1，所以p1可以++，*p1不可以修改空间里面的内容
	// int* p2 = p1;权限放大不可以
	const int* p2 = p1;
 
 
	int* p3 = &x;
	const int* p4 = p3;
 
	return 0;
}

8.5 指针和引用的关系
C++中指针和引用就像两个性格迥异的亲兄弟，指针是哥哥，引用是弟弟，在实践中他们相辅相成，功能有重叠性，但是各有自己的特点，互相不可替代。

• 语法概念上引用是⼀个变量的取别名不开空间，指针是存储一个变量地址，要开空间。
• 引用在定义时必须初始化，指针建议初始化，但是语法上不是必须的。
• 引用在初始化时引用一个对象后，就不能再引用其他对象；而指针可以在不断地改变指向对象。
• 引用可以直接访问指向对象，指针需要解引用才是访问指向对象。
• sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节，64位下是8byte)
• 指针很容易出现空指针和野指针的问题，引用很少出现，引用使用起来相对更安全一些。
• 引用表面好像是传值，其本质也是传地址，只是这个工作由编译器来做

或者简略点说

引用和指针的不同点

• 引用概念上定义一个变量的别名，指针存储一个变量的地址
• 引用在定义时必须初始化，指针没有要求
• 引用在初始化时引用一个实体后，就不能在引用其他实体，而指针可在任何时候指向任何一个同类型实体
• 没有空引用，但有NULL指针
• 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数
• 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
• 有多级指针，但没有多级引用