C++ 入门

前言 c++的发展史：

C++的起源可以追溯到1979年，当时Bjarne Stroustrup在贝尔实验室开始开发一种名为“C with Classes”的语言。以下是C++发展的几个关键阶段：

1. 1979年：Bjarne Stroustrup在贝尔实验室开始开发“C with Classes”。
2. 1983年：语言正式命名为C++，添加类、继承、函数重载等特性。
3. 1985年：发布《The C++ Programming Language》一书，标志C++的正式发布。
4. 1998年：发布第一个国际标准版本C++98。
5. 2011年：发布C++11，加入自动类型推导、lambda表达式、智能指针等新特性。
6. 2014年：发布C++14，进行小幅改进。
7. 2017年：发布C++17，新增结构化绑定、std::optional等特性。
8. 2020年：发布C++20，引入概念、协程、模块等重大更新。

C++的演进不断增加新特性，提升性能和编程效率，适应现代开发需求。

一 命名空间：

在C语言中我们定义变量函数rand但是它是<stdli.b>库里面的函数，这时编译器无法区分它到底是库里面的函数还是全局变量rand，那么它们发生就会冲突，因为C语言规定定义的变量不能与库里面的函数和那32个关键字一样，如果我因为某种需求需要定义一样的变量那这时候就会出错，这时候c++中的namespace就是为了针对此类问题

namespace：

定义：namespace 是 C++ 中的一个关键字，用于定义命名空间。命名空间是一个逻辑上分组的机制，主要用来解决命名冲突问题。通过使用命名空间，可以将相同名称的标识符（如变量、函数、类等）放在不同的命名空间中，从而避免冲突。

命名空间定义：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
namespace bit
{
	int rand = 10;
}
	

int main()
{
	printf("%d", bit::rand);
	return 0;
}

输出：

首先我们来定义一个命名空间需要使用到namespace关键字后面需要跟一个命名空间(结束后不需要加;)，其中命名空间可以是函数变量类型。要访问命名空间中的成员，可以使用 :: 运算符

using命名：

我们在程序中频繁的使用命名空间里面的特定变量那需要输出多少个就需要多少个::运算符(作用域解析运算符)，那c++用using可以直接访问a而不需要bit::前缀。就很好的解决了这个问题

#include <stdio.h>
#include <stdlib.h>

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

输出：

如果我们用被注释过的代码呢，你们觉得它会不会报错？答案是“会” 原因是rand本来是库函数但是它在命名空间里面所以不会报错，但是现在using想让rand变为全局变量那这不又与库函数冲突了嘛

using namespace 命名：

上面using命名规则就是把你a变量给释放出来而这个就是不管你三七二十一全给它释放出来，但是
但是在编写项目的过程中就容易发生冲突了，所以我还是推荐用什么释放什么，或者带着 :: 来明确指定变量是来自哪个 namespace 的

#include <stdio.h>
#include <stdlib.h>

namespace bit
{
	int rand = 250;
	int a = 300;
}
using namespace::bit;
int main()
{
	printf("%d\n",rand);
	printf("%d", a);
	return 0;
}

输出

命名空间嵌套：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>

namespace bit
{
	int rand = 10;
	namespace abt
	{
		int b = 11;
	}
}
	

int main()
{
	printf("%d\n", bit::rand);
	printf("%d", bit::abt::b);
	return 0;
}

输出：

在同一个工程文件中如果有多个相同的命名空间那到最后都会和到一起的

二 c++中输入输出：

#include <iostream>
using namespace std;
int main()
{
	cout << "Hello World" << endl;
	return 0;
}

在初识c++时是不是总是以为最上面的两行代码是每次写代码都要加上去，其实是因为要在 C++ 中执行任何输入和输出操作，我们需要使用 iostream 头文件。如果没有 <iostream> 头文件，我们就无法从用户那里获取输入或打印任何输出。第二行中我们只是不知道为什么要写个std 

std:: 是个命名空间标示符，C++标准库中的函数或者对象都是在命名空间std中定义的，所以我们要使用标准函数库中的函数或对象都要使用std来限定。如果说需要调用要调用C++标准库时，要写上std::

三 缺省参数：

缺省参数是指在函数声明时，为参数指定一个默认值。在调用该函数时，如果省略了该参数，编译器会自动使用默认值。

#include <iostream>
using namespace std;
void Fun(int a = 10)
{
	cout << a << endl;
}
int main()
{
	//cout << "Hello World" << endl;
	Fun();//没传参数就用形参的指定默认值
	Fun(100);//传参数就用实参的值
	return 0;
}

输出：

全缺省参数：

完整默认参数，也称为完全默认参数，是指为函数的所有参数分配默认值。这意味着，如果函数的调用者省略了任何参数，则将使用相应的默认值。

#include <iostream>
using namespace std;
void Fun(int a = 10 , int b = 200 , int c = 300)
{
	cout << a  << endl;
	cout << b << endl;
	cout << c << endl;
}
int main()
{
	//cout << "Hello World" << endl;
	Fun();
	return 0;
}

半缺省参数：

部分默认参数涉及仅为函数参数的子集分配默认值。其余参数没有默认值，必须由调用者提供。

#include <iostream>
using namespace std;
void Fun(int a = 10 , int b = 200 , int c)
{
	cout << a  << endl;
	cout << b << endl;
	cout << c << endl;
}
int main()
{
	//cout << "Hello World" << endl;
	Fun(100 , 20 , 30);
	return 0;
}

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

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

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

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

四 函数重载：

函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这 些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型 不同的问题。

参数类型不同：

#include <iostream>
using namespace std;
void Swap(int a , int b)
{
	cout << a  << endl;
	cout << b << endl;
}
void Swap(double a , float b)
{
	cout << a << endl;
	cout << b << endl;
}
int main()
{
	//cout << "Hello World" << endl;
	Swap(10 , 20);
	Swap(11.0 , 200.0);
	return 0;
}

输出：

参数个数不同：

#include <iostream>
using namespace std;
void Swap()
{
	cout << "f()" << endl;
}
void Swap(char b)
{
	cout << b << endl;
}
int main()
{
	//cout << "Hello World" << endl;
	Swap();
	Swap('b');
	return 0;
}

输出：

参数顺序不同：

#include <iostream>
using namespace std;
void Swap(int a, char b)
{
	cout << a << endl;
	cout << b << endl;
}
void Swap(char b, int a)
{
	cout << b << endl;
	cout << a << endl;
}
int main()
{
	//cout << "Hello World" << endl;
	Swap(10 , 'a');
	Swap('b', 200.0);
	return 0;
}

输出：

五 引用：

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

语法：

数据类型& 引用名  = 引用实体

#include <iostream>
using namespace std;

int main()
{
	int a = 200;
	int& b = a;//b是a的引用
	cout << a << endl;
	cout << b << endl;
	return 0;
}

引用类型和引用实体必须是同种类型又因为它们是共用同一块空间所以不管是a或b变量谁改变那都会一起改变

输出：

   地址:

  值：

引用在定义时必须要初始化

一个变量可以有多个引用

引用一旦引用一个实体就不能再引用另外一个实体

常引用：

#include <iostream>
using namespace std;
int mian()
{
 //权力的放大
const int a = 200;
int& b = a;//引用
cout << a << endl;
cout << b << endl;
return 0;
}

输出：

#include <iostream>
using namespace std;
int mian()
{
//权力的缩小
int i = 10;
const int& j = i;
cout << i << endl;
cout << j << endl;
return 0;
}

输出：

#include <iostream>
using namespace std;
int mian()
{
//权力的平移
const int q = 101;
const int& w = q;
cout << q << endl;
cout << w << endl;
return 0;
}

输出：

综上所述权力可以平移 缩小但是不能放大。

引用与指针的比较：

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

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何 一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32 位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全