【C++】C++入门基础知识

---

前言

介绍 C++ 基础知识，包括：命名空间、输入/输出、缺省参数、函数重载、引用。

一、命名空间

在写代码的时候，我们所定义的全局变量可能会与其他的变量名或者库里面的冲突，例如：

#include<iostream>
using namespace std;

int rand = 6;

int main()
{
	cout << rand << endl;
	return 0;
}

此时我们定义的全局变量rand与std库里的函数重名了，以下是报错：

此时使用命名空间就很好了解决这种问题，将一些变量定义在命名空间内，很好的避免了命名冲突。

1.命名空间的定义

命名空间的定义就是namespace关键字 + 命名空间的名字，使用如下：

namespace wcm
{
	//.....
}

在命名空间里面定义变量就不怕与其他地方重名冲突了，比如：

#include<iostream>
using namespace std;

namespace wcm
{
	//.....
	int rand = 6;
}

int main()
{
	cout << wcm::rand << endl;
	return 0;
}

此时的rand就不会与std库里的函数重名了！
另外命名空间内也可以定义诸如变量、函数、类型等。
命名空间也支持嵌套，比如：

#include<iostream>
using namespace std;

namespace wcm1
{
	//.....
	int rand = 6;
	namespace wcm2
	{
		int rand = 8;
	}
}

int main()
{
	cout << wcm1::wcm2::rand << endl;
	return 0;
}

如果同一个工程中，存在同名的命名空间，那么最后会合成为同一个命名空间。
ps：一个命名空间就定义了一个新的作用域，该空间中的所有内容都局限于该命名空间内。

2.命名空间的使用

那么定义了命名空间，空间内的成员该如何使用呢？
有三种访问的方法：
1）将命名空间整个展开：
语法：using namespace 名字；
相当于把命名空间内的全部成员都展开到当前文件内，此时如果当前文件内有与命名空间重名的函数或变量会产生冲突，推荐个人练习时使用，而 using namespace std； 就是把std整个命名空间全部展开。
比如：

#include<iostream>
using namespace std;

namespace wcm1
{
	//.....
	int num = 6;
}

using namespace wcm1;

int main()
{
	cout << num << endl;
	return 0;
}

2）展开命名空间的部分：
语法：using + 命名空间名字 + ：：（域作用限定符） + 需要展开的函数、变量名
不仅可以展开命名空间的全部，也可以选择一部分常用的展开，相对于全部展开，更好一些。
比如：

#include<iostream>
using std::cout;
using std::endl;

int main()
{
	cout << 6 << endl;
	return 0;
}

3）直接在要使用的成员前加上命名空间名称以及域作用限定符
语法：命名空间名称 + ：： + 成员名称
使用起来安全性最高，不会出现展开后重名冲突的情况，但是使用起来不是特别方便，甚至有点小烦！
比如：

#include<iostream>

int main()
{
	std::cout << 6 << std::endl;
	return 0;
}

二、cout、cin

1.cout输出

在 C++ 中进行输出，一般用cout，使用很简单，借助流插入运算符（<<）即可，不需要像printf中在指定格式输出了，cout会自动识别你的变量类型并进行输出。
比如：

#include<iostream>
using namespace std;

int main()
{
	cout << 6.6 << endl;
	cout << "Hello World" << endl;
	cout << 100 << endl;
	return 0;
}

endl：表示换行的意思。

2.cin输入

cin使用需配合流提取运算符（>>），使用时也不需要考虑输入的数据类型和取地址了。
比如：

#include<iostream>
using namespace std;

int main()
{
	int i = 0;
	int d = 0.0;

	cin >> i;
	cin >> d;

	return 0;
}

非常的简单好用，ps： 使用cout、cin、endl必须包含 #include、using namespace std；using namespace std； 只是一种使用std这个命名空间的方式，也可以使用其他的使用命名空间的方式。

三、缺省参数

缺省参数即为，在声明或定义函数时，可以考虑给函数的参数缺省值，在调用该函数时，如果参数有缺省值，并且在调用该函数时没用主动传参的话，那么使用时会使用所提供的缺省值，也可以称为默认值。

1.全缺省参数

全缺省顾名思义就是该参数的全部参数都给缺省值。
比如：

#include<iostream>
using namespace std;

int Add(int a = 1, int b = 2, int c = 3)
{
	return a + b + c;
}

int main()
{
	cout << Add() << endl;
	return 0;
}

此时Add这个函数就是全缺省参数，可以看到调用时没有给任何一个参数，那么此时调用时a、b、c就是用的缺省值，即a=1，b=2，c=3，那么结果必然是6，当然如果此时我们给其传参的话，那么其就是对应我们所传的值，注意，传参的话也不一定要传完所有参数的值，可以传一个，也可以传两个，没有传参的那个参数就是用的缺省值，比如：

#include<iostream>
using namespace std;

int Add(int a = 1, int b = 2, int c = 3)
{
	return a + b + c;
}

int main()
{
	cout << Add(10,20) << endl;
	return 0;
}

此时我们传了两个参数，那么就是传给了a、b，c用的还是缺省值，那么结果加起来必然就是33。

2.半缺省参数

半缺省参数，就是可以只给一部分参数缺省值，也就是可以选择有些参数给缺省值，一些参数不给缺省值，必须传参，需要注意的是，半缺省参数必须从右往左的给缺省值，不能间隔给，必须连续，比如：

#include<iostream>
using namespace std;

int Add(int a, int b = 2, int c = 3)
{
	return a + b + c;
}

int main()
{
	cout << Add(1) << endl;
	return 0;
}

可以看到，半缺省的话，你可以c、b都给缺省值，a不给，但是你不能间隔的给，也就是你不能c、a给缺省值，这样是不行的，而且你也不能a、b都给缺省值，而c不给，这样也不行，因为你必须要从右往左的给，不能从左往右的给！

错误示范：
间隔的给：

#include<iostream>
using namespace std;

int Add(int a = 1, int b, int c = 3)
{
	return a + b + c;
}

int main()
{
	cout << Add(1) << endl;
	return 0;
}

没有从右往左连续的给：

#include<iostream>
using namespace std;

int Add(int a = 1, int b = 2, int c)
{
	return a + b + c;
}

int main()
{
	cout << Add(1) << endl;
	return 0;
}

以上都是错误的给半缺省参数！
注意：如果一个函数声明和定义分离的话，那么只需要在声明或者定义一个地方给缺省参数就可以了，建议声明的时候给缺省参数就好了。

四、函数重载

函数重载指的是可以定义多个重名函数，只要满足函数的参数的类型不同、参数的类型顺序不同、参数的个数不同的其中一点即可，函数重载对于返回值没有要求。
1）类型不同：

#include<iostream>
using namespace std;

int Add(int a, int b)
{
	return a + b;
}

double Add(double a, double b)
{
	return a + b;
}

int main()
{
	int ret = Add(1, 2);
	return 0;
}

类型不同即参数的类型不全相同，很好理解。

2）个数不同：

#include<iostream>
using namespace std;

int Add(int a, int b)
{
	return a + b;
}

double Add(int a, int b, int c)
{
	return a + b + c;
}

int main()
{
	int ret = Add(1, 2);
	return 0;
}

个数不同即字面意思。

3）顺序不同：

#include<iostream>
using namespace std;

int Add(int a, char b)
{
	return a + b;
}

int Add(char a, int b)
{
	return a + b;
}

int main()
{
	int ret = Add(1, 'a');
	cout << ret << endl;
	return 0;
}

顺序不同，即参数列表的参数的类型的顺序不同。

五、引用

引用不是新定义一个变量，而是给已有变量取得一个 “别名” ，它的本质还是那个变量，只不过名字不一样了，正如现实生活中，一个人有真名，可能还有别人给起的外号，虽然称呼不同了，但指的都是同一个人。所以对引用的修改，会改变被引用变量！
引用的使用是在类型后面加一个——&
比如：

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& b = a;
	return 0;
}

引用和指针的区别：

• 引用必须初始化，即引用定义时必须是另一个变量的别名；指针可以不初始化。
• 引用一旦成为了一个变量的别名，就不能再更改成为别的变量的别名；指针可以随意改变自己的指向（在不加const的前提下）。
• 引用本身不开辟额外的空间，引用就是指向引用的变量的空间；指针也是一个变量，会开辟空间。

常引用：
加const的引用就是常引用。
要引用一个被const修饰的变量时，引用必须也加上const，引用一个不被const修饰的变量时，可以加const也可以不加，即引用对于被引用变量的权限只能相等或者缩小，不能放大。
1）权限相等

#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& b = a;

	const int c = 20;
	const int& d = c;
	return 0;
}

2）权限缩小

#include<iostream>
using namespace std;

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

3）权限放大（不允许）

#include<iostream>
using namespace std;

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

总结

温故而知新。