C++：命名空间，缺省参数，函数重载，引用，内联函数

个人主页 ： 个人主页
个人专栏 ： 《数据结构》 《C语言》《C++》

---

前言

本篇博客作为C++知识总结，我们来认识命名空间，缺省参数，函数重载，引用，内联函数。

---

一、命名空间

那么在介绍命名空间时，我们先用C++的方式打印"hello world"。

#include <iostream>
using namespace std;

int main()
{
    
    
	cout << "hello world" << endl;

	return 0;
}

其中，using namespace std; 就是一种命名空间的使用。

---

在C++中，变量，函数和后面要学习到的类都是大量存在的，这些变量，函数，类的名称都存在全局作用域中，可能会造成命名冲突，使用，命名空间的目的是对标识符的名称进行本地化，以避免命名冲突或命名污染，namespace关键词的出现就是针对这种问题。

比如：在C时，我们定义变量time时，有包含了头文件<time.h>，这就会造成命名冲突。但在C++，我们可以将变量time定义在一个命名空间内从而避免这一情况发生。

这会使编译器发出 error C2063: “time”: 不是一个函数的警告。

命名空间的定义

定义命名空间，需要使用namespace关键词，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
命名空间中可以定义变量，函数，类型

namespace test
{
    
    
	//变量
	int time = 0;

	//函数
	int Add(int left, int right)
	{
    
    
		return left + right;
	}
	
	//类型
	struct Stu
	{
    
    
		char name[20];
		char sex[5];
		int age;
	};
}

---

命名空间可以嵌套定义

namespace test
{
    
    
	int time = 0;

	int Add(int left, int right)
	{
    
    
		return left + right;
	}

	struct Stu
	{
    
    
		char name[20];
		char sex[5];
		int age;
	};

	//嵌套定义test1命名空间
	namespace test1
	{
    
    
		int time1 = 1;

		int sub(int a, int b)
		{
    
    
			return a - b;
		}
	}
}

---

一个工程中允许定义多个相同的命名空间，编译器会将多个相同的命名空间合并为一个

命名空间的使用

• 命名空间名称及作用域限定词( :: )

#include <iostream>
using namespace std;

namespace test
{
    
    
	int time = 0;

	int Add(int left, int right)
	{
    
    
		return left + right;
	}

	struct Stu
	{
    
    
		char name[20];
		char sex[5];
		int age;
	};

}

int main()
{
    
    
	cout << test::time << endl;

	cout << test::Add(1, 2) << endl;

	struct test::Stu s;
	return 0;
}

---

• 使用using将命名空间中某个成员引入(部分引入)

#include <iostream>
using namespace std;

namespace test
{
    
    
	int time = 0;
	int a = 10;

	int Add(int left, int right)
	{
    
    
		return left + right;
	}

	struct Stu
	{
    
    
		char name[20];
		char sex[5];
		int age;
	};

}

using test::Add;
using test::a;

int main()
{
    
    
	//此处time是函数名，表示函数的地址 
	//不能using test :: time 会造成冲突，time变量只能test::time访问
	cout << time << endl;
	cout << a << endl;
	cout << Add(1, 2) << endl;

	struct test::Stu s;
	return 0;
}

---

• 使用using namespace 命名空间名称 引入

#include <iostream>
using namespace std;

namespace test
{
    
    
	//全部引入时，time变量与time函数会冲突
	//int time = 0;
	int a = 10;

	int Add(int left, int right)
	{
    
    
		return left + right;
	}

	struct Stu
	{
    
    
		char name[20];
		char sex[5];
		int age;
	};

}

using namespace test;

int main()
{
    
    
	cout << a << endl;
	cout << Add(1, 2) << endl;

	return 0;
}

二、缺省参数

缺省参数概念

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

• 缺省参数不能同时出现在定义与声明中
• 缺省值必须是常量或者全局变量

如下展示：函数func的参数a就是缺省参数。

#include <iostream>
using namespace std;

void func(int a = 10)
{
    
    
	cout << a << endl;
}

int main()
{
    
    
	func();
	func(1);
	
	return 0;
}

结果如下：

缺省参数分类

• 全缺省参数

#include <iostream>
using namespace std;

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

}

int main()
{
    
    
	func();
	cout << endl;

	func(1);
	cout << endl;

	func(1, 2);
	cout << endl;

	return 0;
}

结果如下：

• 半缺省参数

• 半缺省参数必须从右往左依次来给，不能间隔的给

#include <iostream>
using namespace std;


void func(int a, int b = 1, int c = 2)
{
    
    
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
}

int main()
{
    
    
	func(0);
	cout << endl;


	func(0, 10);
	cout << endl;

	func(0,10,20);
	cout << endl;

	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()
{
    
    
	cout << Add(1, 2) << endl;
	cout << Add(1.1, 2.2) << endl;


	return 0;
}

---

参数个数不同

#include <iostream>
using namespace std;

void func()
{
    
    
	cout << "void func()" << endl;
}

void func(int i, int j)
{
    
    
	cout << "void func(int i, int j)" << endl;
}

//注意无参函数的重载函数，不能有全缺省类型的函数，会造成函数调用的二义性
//void func(int i = 1, int j = 1, int k = 1)
//{
    
    
//	cout << "void func(int i = 1, int j = 1, int k = 1)" << endl;
//}

int main()
{
    
    
	func();
	func(1, 1);

	return 0;
}

---

参数类型顺序不同

#include <iostream>
using namespace std;

void func(int i, double j)
{
    
    
	cout << "void func(int i, double j)" << endl;
}

void func(double i, int j)
{
    
    
	cout << "void func(double i, int j)" << endl;
}

int main()
{
    
    
	func(1, 1.1);
	func(1.1, 1);

	return 0;
}

四、引用

引用的概念

引用并不是新定义的变量，而是给已有变量取了一个别名(类似于给人取一个外号)，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块空间。

类型 + & + 引用对象名 = 引用实体

#include <iostream>
using namespace std;

int main()
{
    
    
	int i = 0;

//定义引用类型
// 类型  & 对象名  引用实体
	int  &  ri  =  i;
	
	cout << &i << endl;
	cout << &ri << endl;
	return 0;
}

---

引用特性

• 引用在定义时必须初始化
• 一个变量可以有多个引用
• 引用一旦引用一个实体，就不能再引用其它实体
• 引用的权限可以平移，缩小，不能放大

引用在定义时必须初始化

---

一个变量可以有多个引用

#include <iostream>
using namespace std;

int main()
{
    
    
	int i = 0;

	int& ri = i;
	int& rri = i;
	int& rrri = i;

	cout << &i << endl;
	cout << &ri << endl;
	cout << &rri << endl;
	return 0;
}

---

引用一旦引用一个实体，就不能再引用其它实体

---

引用的权限可以平移，缩小，不能放大

---

引用的使用场景

1.做参数
引用做返回值 与 指针作用类似，都可以通过形参直接改变实参，但引用使用更舒服。

#include <iostream>
using namespace std;

void swap(int& i, int& j)
{
    
    
	int tmp = i;
	i = j;
	j = tmp;
}

int main()
{
    
    
	int i = 0;
	int j = 10;

	cout << " i = " << i << " j = " << j << endl;
	swap(i, j);
	cout << " i = " << i << " j = " << j << endl;

	return 0;
}

---

2.做返回值

• 如果函数返回时，出了函数作用域，如果返回对象存在，则可以使用引用返回，如果已经返回系统了，则必须使用传值返回。

如下：(1) , (2) , (3)的结果是什么？

int& Add(int a, int b)
{
    
    
	int c = a + b;

	return c;
}

int main()
{
    
    
	int& ret = Add(1, 2);
	cout << "Add(1,2) = " << ret << endl;// (1)
	Add(3, 4);

	cout << "Add(1,2) = " << ret << endl;// (2)
	cout << "Add(1,2) = " << ret << endl;// (3)

	return 0;
}

为什么是这个结果？ret不是只接受了一次函数函数返回值吗？
这就是因为变量c的生命周期是随着函数栈帧的创建而创建，栈帧的销毁而销毁(栈帧的销毁并不会真的销毁空间，C变量空间的值并不会改变，只是esp 与 ebp的指向变了)。《函数栈帧的创建与销毁》
ret也是指向变量C的空间，第一次打印ret的值，变量C空间的值不变，可以打印出3。当第二次调用Add(3, 4)函数时，main函数栈帧上并未有其它栈帧存在，此时Add(3,4)的栈帧位置与Add(1,2)的栈帧位置相同，那么ret指向变量C的空间就被这次变量C的空间覆盖，变量空间的值就变成7。当第二次打印ret的值时，ret的值就是7，此时cout << "Add(1,2) = " << ret << endl;也是一个函数调用，会覆盖变量C的空间，使变量C的空间变成随机值，所以第三次打印ret的值就是随机值。

---

引用与指针的区别

在语法概念上引用就是一个别名，没有独立空间。但在底层实现上，引用实际是有空间的，因为引用就是按照指针方式来实现的。

#include <iostream>
using namespace std;

int main()
{
    
    
	int i = 0;

	int& ri = i;
	int* pi = &i;

	return 0;
}

可以看到在底层实现方面，引用与指针并无不同。

那引用与指针有区别吗？

• 引用概念上定义一个变量的别名，指针存储一个变量的地址。
• 引用在定义时必须初始化，指针没有要求
• 引用在初始化时引用一个实体后，就不能再引用其它实体，而指针可以在任何时候指向任何一个同类型实体
• 没有NULL引用，但有NULL指针(在C++中是nullptr)
• 在sizeof中含义不同：引用结果为引用类型大小，指针始终是地址空间所占字节数(4 / 8)
• 引用的值改变即引用的实体本身的值改变，指针的值改变则指向了不同的变量
• 有多级指针，没有多级引用
• 访问实体方式不同，指针需要显示解引用，引用编译器会自己处理
• 引用比指针更安全

五、内联函数

在C语言中，有时我们要提高程序效率，会将一些简单的函数写成宏的形式，来提供程序效率。但对于宏函数而言，它出错时并不好调试检查。于是C++对与这一情况提出来内联函数的概念。

以inline修饰的函数叫做内联函数，编译时C++编译器会在调用内联函数的地方展开，没有函数调用创建栈帧的开销，内联函数就可以代替宏函数。
如下：Add函数被inline修饰后，在调用时就没有call指令，而是直接进行相加。

#include <iostream>
using namespace std;

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

int main()
{
    
    
	int ret = 0;

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

特性

• inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能使目标文件变大
• inline对于编译器而言只是一个建议，不同编译器关于inline实现机制不同，一般建议：将函数规模较小，不是递归，且频繁调用的函数用inline修饰，否则编译器有可能会忽视inline的特性
• inline不建议声明和定义分离，分离会导致链接错误，因为inline被展开，就没有函数地址了，在链接阶段，编译器依据符号表就找不到函数地址。

---

总结

以上就是我对于C++中命名空间，缺省参数，函数重载，引用，内联函数的总结。感谢支持！！！