C++基础

C++基础 第一个C++程序

输出Hello World

#include 

int main()
{
	std::cout << "Hello World" << std::endl;

	return 0;
}

另一种方式输出Hello World

#include 
using namespace std;

int main()
{
	cout << "Hello World" << endl;

	return 0;
}

上述的两种方式，都能很好的输出Hello World，不同于c语言中的输入输出方式**C++**中没有定义输入输出语句。

基本的输入输出

这里只是简单的提及最基本的输入输出方式。

在iostream库中有，cin和cout为标准输入输出 。

相较于C语言，使用scanf printf等函数进行输入输出，在传递参数的时候，需要指定不同参数的类型，但是cin 和 cout进行输入输出的时候，能够自动识别变量的类型！

使用cin 和 cout的时候，要包含对应的头文件iostream，i代表的是input，o代表的是output。

c++中把输入和输出的数据当作"流"来处理，输入即为"输入流"，输出即为"输出流"，一个"流"是一个字符序列，随着时间的变化，"流"是顺序生成和消耗的。

<< 和 >> 分别是流插入 *** 作符和流提取 *** 作符。

演示数据的输入和输出

#include 

int main()
{
	int a = 10, b = 20;
	float c = 1.1f;

	// 输入a,b,c
	std::cin >> a >> b;
	std::cin >> c;

	// 输出a,b,c
	std::cout << a << " " << b << std::endl;
	std::cout << c << std::endl;

	return 0;
}

然而，为什么在cin 和 cout前面加上std::？这就涉及到域的概念了。

域

在C语言的学习中，有作用域的概念，通俗一点讲，就是一个变量的作用范围，即在这个范围内，该变量是有效的。

在某个工程中，同名的变量不能同时定义在一个域中，不然编译器会报错。

命名空间

c++中有命名空间的概念，命名空间中可以定义变量，函数，结构体…

命名空间还可以进行嵌套。

在使用的时候，只要加上特定的前缀，也就是表示来自特定的命名空间中即可，这样一来，即使是相同的变量，定义在不同的命名空间中也就没有什么问题。

需要注意的是：

一个工程中，如果在不同的文件中定义了相同名字的命名空间，最终都会在一个同名的命名空间中。

定义命名空间

语法：

namespace space
{
    // 定义变量，函数，结构
}

#include 

namespace space1
{
	int a = 10;
	int b = 20;
}

namespace space2
{
	int a = 100;
	int b = 200;
}

int main()
{
	std::cout << space1::a << " " << space1::b << std::endl;
	std::cout << space2::a << " " << space2::b << std::endl;

	return 0;
}

域作用限定符(:😃

由上可以看出，指定的命名空间的名字后面要加上::域作用限定符，表示变量是来自于哪个命名空间中的。

由此可见cin 和 cout是定义在命名空间std中的，其实标准库中的所有名字都是定义在命名空间std中的。

利用using引入命名空间

利用using有两种引入方式：

1. 将命名空间中的全部内容引入.
2. 引用命名空间中特定的成员引入.

引用到底有什么用？

简单来说的话，一旦你对命名空间进行了引用，相当于消除了命名空间，没有了指定域的限定

• 全部引入

#include 

namespace space
{
	int a = 0;
	int b = 1;
	int c = 2;
}

using namespace space;
// 将命名空间的内容全部引入，可以直接使用其中的东西

int main()
{
	std::cout << a << std::endl;
	std::cout << b << std::endl;
	std::cout << c << std::endl;

	return 0;
}

• 引用指定成员

#include 

namespace space
{
	int a = 10;
	int b = 20;

	int Add(int x, int y)
	{
		return x + y;
	}
}

using space::Add;

int main()
{
	// error
	// 没有引入的成员不能直接使用，必须要加上相应的域以及域作用限定符
	//std::cout << a << std::endl;
	//std::cout << b << std::endl;

	// right
	std::cout << space::a << std::endl;
	std::cout << space::b << std::endl;

	std::cout << Add(10, 20) << std::endl;

	return 0;
}

• 嵌套命名空间的引入

需要记住的是：一次using进行的全部引用只是相当于去掉了最外面的域

#include 

namespace space1
{
	int a = 1;
	int b = 2;
	namespace space2
	{
		int c = 3;
		int d = 4;
	}
}

using namespace space1;

int main()
{
	// right
	std::cout << a << " " << b << std::endl;
	
	// error
	// 只解除了一层域
	//std::cout << c << " " << d << std::endl;
	return 0;
}

缺省参数

缺省值即默认值

缺省参数的意思是参数部分可以设定一个默认值，如果对应位置没有传入参数的话，实参就使用设定的默认值。

缺省参数分为两类：

1. 全缺省参数：函数定义部分，其中所有的形参都有指定的默认值。
2. 半缺省参数：函数定义部分，其中只有部分的形参具有默认值。

• 全缺省参数

实例：数据结构-栈，在进行初始化的时候，c中没有缺省参数，每次调用初始化函数的时候都是初始化的大小都是一个默认值，如果实际所需的空间比我们开辟的空间小那还好说；一旦实际所需的空间大于默认初始化时给定的空间，这时又要进行扩容，降低了程序运行的效率。

有了缺省参数，在不知道栈空间的大小时，传递参数的时候可以不传；知道的话，可以传指定的大小，不会造成过多空间的浪费。

#include 

void PrintDate(int year = 1, int month = 1, int day = 1)
{
    std::cout << year << " " << month << " " << day << std::endl;
}
int main()
{
    // 传参个数 0,1,2,3
    PrintDate();
    PrintDate(2022);
    PrintDate(2022, 10);
    PrintDate(2022, 10, 1);

    return 0;
}

• 半缺省参数

函数的参数中只有部分缺省值，必须是从右往左连续缺省

#include 

void PrintDate(int year, int month = 10, int day = 1)
{
	std::cout << year << " " << month << " " << day << std::endl;
}

int main()
{
	// 传参个数 1,2,3
	PrintDate(2022);
	PrintDate(2022, 9);
	PrintDate(2022, 9, 25);

	return 0;
}

函数重载

c语言中在一个文件中不允许出现同名函数，但是c++支持同一个域中出现多个同名函数。

同名函数必须要满足的条件是：参数不同，与函数的返回值无关

参数不同又分为3中情况，同名函数中的参数至少满足其中的一个就行。

1. 参数类型不同
2. 参数顺序不同
3. 参数个数不同

这种支持同名函数的方式称之为函数重载。

一个求两个函数相加的函数，可以根据传参时类型的不同自动调用相应的函数。

#include 

int Add(int x, int y)
{
	return x + y;
}

double Add(double x, double y)
{
	return x + y;
}

int main()
{
	std::cout << Add(1, 2) << std::endl;
	std::cout << Add(1.5, 2.6) << std::endl;

	return 0;
}

函数重载也可以根缺省参数结合在一起

但是要清楚的知道，像下面的这种情况，语法上并没有问题，但是在进行函数调用的时候会出现二义性，导致运行错误。

int Add(int x, int y)
{
    return x + y;
}

int Add(int x = 10, int y = 20)
{
    return x + y;
}

引用

引用并不是用来定义变量，而是给变量取别名的

就像人类社会中，一个人刚生下来拥有父母取的名字，还有自己的小名，不管是那种名字，代表的都是这个人。

引用一个变量，相当于给一个变量取别名，改变别名的值，相当于改变变量的值，这种改变值的方式和指针相似。

引用需要注意的事项：

1. 引用的同时必须初始化，表明是那个实体的引用
2. 一个变量可以拥有多个引用
3. 一个引用一旦引用了一个实体之和，就不能更换引用的实体
4. 在引用时，权限可以平移，可以缩小，但是绝对不能够放大

语法

Type &alias = OriginalName

#include 

int main()
{
	int a = 10;
	int& ra = a;
	int& rra = a;

	return 0;
}

引用权限

#include 

int main()
{
	int a = 10;
	const int b = 20;

	// 权限平移
	int& ra = a;
	// 权限缩小
	const int& rra = a;

	// 权限放大
	// 错误
	int& rb = b;

	return 0;
}