【1C++】入门，命名空间、缺省参数、函数重载、引用详解

---

前言

C语言是结构化和模块化的语言，适合处理小规模的程序。对于复杂的问题，规模较大的程序，需要高度的抽象和建模时，C语言则不合适了。
C++是在C语言的基础上引入并扩充了面向对象的概念，它既可以进行C语言的过程化设计，又可以进行以抽象数据类型为特点的基于对象的程序设计，还可以进行面向对象的程序设计。

一、C++的第一个程序、命名空间

1	#include <iostream>

2	using namespace std;

3	int main()
4	{
5		cout << "hello word!" << endl;
6		return 0;
7	}

1.1、代码讲解

第一行代码类似于C语言里面的stdio.h头文件，将一些IO输入输出的头文件展开；namespace是C++的关键字，定义一个命名空间，而using namespace std则是全部展开std的命名空间，包含（定义的变量，函数，结构体…）。

1.2、命名空间的作用：

在C/C++中，变量、函数和类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或名字的污染。

1.3、定义命名空间

使用namespace关键字。定义下面的命名空间：
（1）命名空间里面可以定义变量、函数、结构体…
(2)命名空间可以进行嵌套
（3）同一个工程中允许存在多个相同名称的命名空间，编译器最后会合成在同一命名空间中

#include <iostream>

using namespace std;

//定义一个YP的命名空间
namespace YP
{
	int rand = 10;
	int Add(int a, int b)
	{
		return a + b;
	}
	namespace ZS
	{
		int rand = 10;
		int Add(int a, int b)
		{
			return a + b;
		}
	}
}

namespace YP
{
	int a = 1;
	int Mul(int a, int b)
	{
		return a* b;
	}

}
int main()
{
	cout << "hello word!" << endl;
	return 0;
}

1.4、使用命名空间

使用命名空间有三种使用方法：

• 加命名空间名称及作用域限定符
• 使用using将命名空间中成员引入
• 使用using namespace命名空间名称引入

#include <iostream>

using namespace std;

//定义一个YP的命名空间
namespace YP
{
	int rand = 10;
	int Add(int a, int b)
	{
		return a + b;
	}
}
//2、使用using将命名空间的成员引入
//using YP::Add;
//3、使用using namespace命名空间名称引入
//using namespace YP;
int main()
{
	//1、加命名空间的名称+作用限定符
	printf("%d\n", YP::rand);
	
	return 0;
}

二、缺省参数

1、缺省参数的概念

• 缺省参数是声明或者定义函数时为函数的参数指定的一个默认值。在调用函数时，如果没有指定实参则采用该默认值，否则使用指定的实参。

#include<iostream>

using namespace std;

void test(int a = 0)
{
	cout << a << endl;
}
int main()
{
	test();
	test(10);
	return 0;
}

• 全缺省参数

 void test(int a = 0,int b = 10,int c = 20)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

• 半缺省参数

void test(int a ,int b = 10,int c = 20)
{
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

• 实例
  这里缺省参数可以有效的帮助初始化栈空间内存的大小

 #include <iostream>
#include <stdlib.h>
using namespace std;

namespace YP
{
	//定义栈结构体
	typedef struct Stack
	{
		int* a;
		int top;
		int capcity;
	}ST;
	//栈的初始化
	void StackInit(ST* ps, int a = 4)
	{
		ps->a = (int*)malloc(sizeof(int) * a);
		ps->top = 0;
		ps->capcity = a;
	}
	//.....
}
using namespace YP;
int main()
{
	ST st;
	StackInit(&st);
	return 0;
}

三、函数重载

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

#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()
{
	Add(3, 5);
	Add(3.1, 6.5);
	return 0;
}

这样就能使用同名函数，处理不同数据类型的功能，C语言则不行，C语言如果处理此类问题，必须定义俩个不同名的函数来处理

四、引用

• 引用概念：引用不是定义一个变量，而是给已经存在变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间
• 使用方法：类型& 引用变量名（对象名）= 引用实体

 #include <iostream>

using namespace std;

int main()
{
	int a = 3;
	int& b = a;//定义引用类型

	cout << a << endl;
	cout << b << endl;

	return 0;
}

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

#include <iostream>

using namespace std;

int main()
{
	int a = 3;
	int& b = a;//定义引用类型
	int& c = a;
	cout << a << endl;
	cout << b << endl;

	return 0;
}

• 常引用

int main()
{
	int a = 3;
	const int& b = a;//定义引用类型
	int& c = a;
	cout << a << endl;
	cout << b << endl;

	return 0;
}

• 实例
  做参数，此处的形参是实参的别名，形参的改变相当于改变实参的值。

#include <iostream>

using namespace std;

void swap(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 3, b = 5;
	swap(a, b);
	return 0;
}

• 以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，因此用值作为参数或者返回值类型，效率是非常低的，尤其是当参数或者返回值的类型非常大的时，效率更低。
• 引用和指针的区别：在语法概念上引用就是一个别名，没有独立的空间，和它引用的实体共用一块空间，在底层实现上实际上是有空间的，因为引用是按照指针的方式来实现的。下图的汇编代码证明

 #include<stdio.h>
#include<iostream>
using namespace std;

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	int* pa = &a;
	*pa = 20;
	return 0;
}

• 引用与指针的不同点
  1、引用在定义时必须初始化，指针没有要求
  2、引用在初始化时引用一个实体后，就不能再引用其他的实体，而指针可以在任何时候指向任何一个同类型实体
  3、没有NULL引用，但有NULL指针
  4、在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占的字节个数
  5、引用自加是引用实体增加1，指针自加是指针向后偏移一个类型的大小
  6、有多级指针，但是没有多级引用
  7、访问实体方式不同，指针需要显示解引用，引用编译器自己处理
  8、引用比指针使用起来更安全