【C++入门】输入输出、命名空间、缺省参数、函数重载、引用、内联函数、auto、基于范围的for循环

命名空间

命名空间的定义

命名空间的使用

输入输出

命名空间

请看一段C语言的代码：

cpp 复制代码

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

int rand = 10;

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

运行结果：

这就是自己定义的变量和库里面的函数冲突了，C语言无法解决这类问题，C++中的命名空间就是为解决这一类问题而生的。

命名空间存在的重要意义就是为了避免命名冲突。接下来我们先了解命名空间的定义，再使用命名空间去解决这类问题。

命名空间的定义

命名空间的定义需要用到关键字namespace，格式为：

namespace 命名空间的名字

{

/ /......

}

例如：

cpp 复制代码

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

命名空间中可以定义变量、函数、类等。

命名空间的使用

首先，用命名空间来解决上述命名冲突的问题。

cpp 复制代码

namespace pcz
{
	int rand = 20;//把变量放到自己的命名空间里
}

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

运行结果：

这回就没问题了。上述代码中的符号 :: 是作用域限定符，因为在**我们定义一个命名空间时，就定义了一个新的作用域，**限定符前面的内容就是在告诉编译器到哪去找相应的变量、函数以及类。如果作用域限定符前面啥也没写，那么就默认到局部和全局中去找对应的变量，不会到命名空间里找。

命名空间支持嵌套。

cpp 复制代码

namespace pcz
{
	int rand = 20;

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

int main()
{
	printf("%d ", pcz::rand);
	printf("%d ", pcz::ch::Add(1, 2));
	return 0;
}

命名空间的三种使用方式

一、用作用域限定符进行访问

二、全局展开------using namespace std;

三、部分展开------using std::cout;

输入输出

使用标准输出对象cout（控制台）和标准输入对象（键盘）时，必须包含头文件<iostream>，以及对应的命名空间。

cpp 复制代码

#include <iostream>
using namespace std;

int main()
{
	int i = 0;
	cin >> i;
	cout << i;
	return 0;
}

<< : 流插入运算符

>> : 流提取运算符

cin、cout的可以自动识别类型，不用在像C语言一样需要占位符%d、%f等。

缺省参数

缺省参数是声明或定义函数时为函数的参数指定一个缺省值（默认值）。在调用该函数时，如果没有指定实参则采用该形参的缺省值，否则使用指定的实参。缺省参数可以分为全缺省参数和半缺省参数两种。

例如：

cpp 复制代码

#include <iostream>
using namespace std;

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

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

缺省值的使用应注意以下几个事项：

一、半缺省参数必须依次从右往左给，不能间隔给

正确写法：

cpp 复制代码

#include <iostream>
using namespace std;

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

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

错误写法：

cpp 复制代码

#include <iostream>
using namespace std;

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

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

二、缺省参数不能再函数声明和定义是同时出现，如果遇到声明和定义分离，那就在声明时给缺省值

三、缺省值必须是常量或者全局变量

四、C语言不支持

函数重载

函数重载是C++的一个特性，允许在同一个作用域中定义多个同名函数，但这些函数的参数列表必须不同。编译器通过函数的参数列表来区分各个重载的函数。参数列表不同包括：参数个数不同、参数类型不同、参数顺序不同。

通过函数名修饰后，同名但不同参数列表的函数经修饰后的函数名不同，这样编译器就可以区分重载函数。C语言不支持重载函数，C语言函数名的存储是直接转换使用函数名，所以不支持重载。而C++是通过函数修饰规则来区分，只要参数不同，修饰出来的名字就不一样，就支持了重载。

cpp 复制代码

#include <iostream>
using namespace std;

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

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

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

引用

引用是给已存在变量取了一个别名，引用改变，实体也跟着改变，格式为：类型& 。注意，引用类型必须和引用实体是同种类型。

示例：

cpp 复制代码

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

引用的特性

一、引用在定义时必须初始化

二、一个变量可以有多个引用

三、引用一旦引用一个实体，再也不能引用其他实体了

第一个特性的演示：

cpp 复制代码

int main()
{
	int a = 1;
	int& b; //未初始化引用
	return 0;
}

第三个特性演示：

cpp 复制代码

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

	int c = 20;
	b = c;//此处不是在改变b的引用实体，而是把c的值赋给a

	cout << a << endl;

	return 0;
}

常引用

cpp 复制代码

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

运行结果：

这里涉及到了权限的问题。

在指针和引用中，赋值或者初始化时，权限可以保持或缩小，但不能放大。

正确写法：

cpp 复制代码

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

引用的使用场景

一、做参数

cpp 复制代码

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;

二、做返回值

cpp 复制代码

int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}

如果出了函数作用域，返回对象还未还给操作系统，则可以用引用返回。否则，使用传值返回。

三、传值和传引用的效率分析

作为函数参数时，如果传值，函数不会直接传递实参本身，而是传递实参的一份临时拷贝。

作为返回值时，如果传值，也不会将变量直接返回，而是返回它的一份临时拷贝。

因此，传值的效率是比较低的，尤其是参数和返回值类型较大的时候。

如果传引用，因为引用是被引用实体的别名，不会进行拷贝，所以效率较高。

引用和指针的不同点

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

二、引用在定义是必须初始化，指针没有要求。

三、引用在初始化时引用一个实体后，就不能再引用其他实体了，而指针可以在任何时候改变指向。

四、没有NULL引用，但有NULL指针。

五、在sizeof中含义不同，引用结果为引用类型的大小，但指针始终是地址空间所占的字节数。

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

七、有多级指针，但没有多级引用。

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

九、引用比指针使用起来更安全。

内联函数

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，提升程序运行的效率。缺点是：可能会使目标文件变大。

inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同。

适用：函数规模小、非递归、频繁调用。

内联函数不建议声明和定义分离，因为内联函数会在调用的地方展开，没有地址，如果声明和定义分离，那么在链接的时候会报错。

auto

自动推到类型。

cpp 复制代码

int main()
{
	auto i = 10;
	cout << i << endl;
	return 0;
}

注意事项：

使用auto定义变量时，必须对其进行初始化，编译器会根据初始化表达式自动推到它的实际类型，然后会用实际类型替换auto。

auto与指针和引用结合起来使用：

cpp 复制代码

int main()
{
	int x = 0;
	auto a = &x;
	auto* b = &x;
	auto& c = x;

	return 0;
}

用auto声明指针类型时，auto和auto*没有区别，但声明引用时，必须加上&。

cpp 复制代码

int main()
{
	auto a = 1, b = 2, 4;
	return 0;
}

以上这种写法是错误的。在同一行定义多个变量时，这些变量必须是相同的类型，否则编译器会报错。因为编译器实际只对第一个类型进行推导，然后用推导出来的类型定义其他变量。

auto不能作为函数的参数。

auto不能用来声明数组。

基于范围的for循环

传统遍历数组的方式：

cpp 复制代码

int main()
{
	int array[] = { 1,2,3,4,5,6 };
	int n = sizeof(array) / sizeof(int);
	for (int i = 0; i < n; i++)
	{
		cout << array[i] << endl;
	}

	return 0;
}

范围for：

cpp 复制代码

int main()
{
	int array[] = { 1,2,3,4,5,6 };
	int n = sizeof(array) / sizeof(int);
	for (auto e : array)
	{
		cout << e << endl;
	}

	return 0;
}

for循环后的括号由：分成两部分，第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。

完