前言：这篇文章将带您了解C++基础中的知识点——命名空间、引用、内联、缺省、重载

😘我的主页：OMGmyhair-CSDN博客

一、命名空间namespace

1.可以嵌套定义，但是只能定义在全局

namespace ly
{
	int student = 1;
	int age = 21;
	void Print(void)
	{
		printf("ly::Print");
	}
	namespace sister
	{
		int num = 2;
		void Print(void)
		{
			printf("sister::Print");
		}
	}
}

2.多文件中定义的同名namespace会被认为是同一个

3.C++标准库都是放在一个叫做std（standard）的命名空间。例如endl、cin、cout都是里面的。

使用方式

当我们想使用命名空间中的变量或者函数的时候，有三种方式：

1.指定命名空间进行使用

在下面代码中，当我们想访问age时，就可以在前面加上ly::进行指定命名空间

namespace ly
{
	int student = 1;
	int age = 21;
	void Print(void)
	{
		printf("ly::Print");
	}
	
}


}
int main()
{
	printf("ly的年龄：%d\n", ly::age);
	return 0;
}

2.将某一成员进行展开

namespace ly
{
	int student = 1;
	int age = 21;
	void Print(void)
	{
		printf("ly::Print");
	}
	
}

using ly::age;

int main()
{
	//1.
	/*printf("ly的年龄：%d\n", ly::age);*/

	//2.
	printf("ly的年龄:%d\n", age);
	printf("ly学生数量:%d\n", ly::student);
	return 0;
}

3.将该命名空间全部展开

namespace ly
{
	int student = 1;
	int age = 21;
	void Print(void)
	{
		printf("ly::Print");
	}
	
}

//using ly::age;
using namespace ly;
int main()
{
	//1.
	/*printf("ly的年龄：%d\n", ly::age);*/

	//2.
	/*printf("ly的年龄:%d\n", age);
	printf("ly学生数量:%d\n", ly::student);*/

	//3
	printf("ly的年龄:%d\n", age);
	printf("ly学生数量:%d\n",student);
	return 0;
}

---

二、缺省

1.全缺省

void func(int a = 1, int b=2, int c = 3)
{
	printf("3\n");
}

2.半缺省

void func(int a, int b, int c = 3)
{
	printf("1\n");
}

关于缺省的小规则

1.不能跳跃给缺省值或者给实参

（1）跳跃给缺省值（X）

void func(int a=1, int b, int c = 3)
{
	printf("1\n");
}

只能从右往左给缺省值（√）

void func(int a, int b=2, int c = 3)
{
	printf("2\n");
}

（2）跳跃给实参（X）

void func(int a=1, int b, int c = 3)
{
	printf("1\n");
}
int main()
{
	func(, 2, );
	return 0;
}

2.当函数的定义与声明分离时，不能同时给定义和声明缺省值，只能在声明中给缺省值

---

三、引用

引用，用普遍的理解是起别名，其底层和指针相同。但是我们在理解时，引用不会再开辟空间，指针会再开辟空间。

引用的特性

1.引用在定义时必须初始化

2.一个变量可以有多个引用

3.引用一旦引用了一个实体，就不能在引用别的实体。

传引用返回

用下面的代码进行举例，在传值引用中，在最后的传值过程中，传值引用会将你想返回的值拷贝给一个临时对象，而原本的对象在出了函数之后就会被销毁。在下面的代码中，x出了函数就会被销毁，而x的值会赋给一个临时对象。

int fun(int x)
{
	x++;
	return x;
}

但是在传引用返回中，就省去了这一中间商过程。因为x出了函数并不会被销毁，x只是一个别名。

int& fun(int& x)
{
	x++;
	return x;
}

我们还可以通过传引用返回修改被引用的实体

struct Stack
{
	int arr[5];
};
Stack& funcReVerse(Stack &rarr)
{
	for (int i = 0; i < 5; i++)
	{
		rarr.arr[i] = 5 - i;
	}
	return rarr;
}

int main()
{
	Stack s;
	for (int i = 0; i < 5; i++)
	{
		s.arr[i] = i + 1;
	}

	cout << funcReVerse(s).arr[0] << endl;
	funcReVerse(s).arr[0] = 999;
	for (int i = 0; i < 5; i++)
	{
		cout << s.arr[i] << " ";
	}
	cout << endl;
	return 0;
}

权限放大

什么是权限放大呢？我们照例举一个例子：

int main()
{
	const int a = 30;
	int& ra = a;
	return 0;
}

本来a是不能被修改的，但是引用之后，我们却可以通过它的别名进行修改，此时就存在权限放大问题，上面的代码也会被编译器报错。

权限缩小

当理解了权限放大，那么理解权限缩小也就不是一个难事。

int main()
{
	int a = 30;
	const int& ra = a;
	return 0;
}

这段代码不会被编译器所报错，a本身还是可以修改的，但是当我们用别名取操作a时，却不能修改，此时就存在权限缩小的情况。

const引用

我们现在对const引用作进一步理解。

我们在这里引入一个知识点，临时对象具有常性。

接下来我们来看看下面三种引用：

int main()
{
	int a = 1;
	int b = 2;
	double d = 2.5;

	//1.
	const int& ra = 30;

	//2.
	const int& rab = (a + b);

	//3.
	const int& rd = d;
	return 0;
}

以上三种引用都必须加上const，不然编译器会报错。

在第一种情况中，我们是对常量进行引用，因此加上const是不难理解的。

在第二种情况中，a+b得到的值会被赋给一个临时变量，而rab引用的就是这个临时变量。临时对象具有常性，所以要加const。你可能会觉得奇怪，临时变量不是临时的吗，使用完之后不就被销毁了吗，那么rab的引用不就成了一种类似“野指针”的情况吗？

值得注意的是，当临时变量被引用时，它不会立即被销毁，它的生命周期将跟着这个引用，当引用rab被销毁时，这个被引用的临时变量也会跟着被销毁。

在第三种情况中，会发生隐式转换，d会被转换为一个类型为int的临时对象，所以在这里rd并不是对d进行引用，而是对那个类型为int的临时对象进行引用。临时对象具有常性，所以这里也要加上const。

我们可以用地址的方式，来测试rd到底是不是对d进行引用：

可以看到d和rd的地址并不相同。

---

四、重载

当参数不同，函数名相同就构成了函数重载，需要注意的是，返回值类型的不同不能构成函数重载。因为在c\c++中，函数的返回值可以被忽略。

1.参数个数不同

void func(int a, int b)
{
	cout << a << b << endl;
}

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

2.参数类型不同

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

void func(double a)
{
	cout << a << endl;
}

3.参数顺序不同

void func(int a, int b, double c)
{
	cout << a << b << c << endl;
}

void func(int a, double b, int c)
{
	cout << a << b << c << endl;
}

注意：当全局函数和类的成员函数同名时，并不算重载，因为它们作用域不同。

还有一种情况需要注意：

void Print(int a)
{
	cout << "Print int" << endl;
}

void Print(int a = 10)
{
	cout << "Print float" << endl;
}

int main()
{
	Print();
	return 0;
}

这两个函数存在重载，但是存在歧义，编译器会报错。

---

五、内联inline

好处：

1.内联可以替换宏代码，当我们在用宏代码写函数时，往往会发生一些意料不到的错误。相较于宏代码，内联函数更加安全，在调用时，编译器会对其进行检查。

2.内联函数代码直接替换函数调用，省去了函数调用的开销。

那是不是我们将每个函数都设置为内联更好呢？

并非如此

坏处：

1.内联是以代码膨胀为代价省去了函数调用的开销，当每一处内联函数都复制代码，那么总代码量会变得膨大，会消耗更多的内存空间。

2.当执行函数代码的时间对比函数调用的开销较大，使用内联的效率就不显得那么高了。

下面两种情况不适合使用内联：

1.函数内代码量大，使用内存代码消耗量很大

2.函数体内有循环，执行代码的时间比函数调用的开销大。

所以，有的编译器会根据函数定义体，自动取消内联。以及在vs的debug版本下默认不展开内联，方便调试。如果你想让内联在debug版本下展开需要设置以下两个地方。

1.右键你的项目，点击属性，来到下面这个页面，改为“程序数据库”

2.点击处于常规下面的优化，将内联函数扩展改为只适用于inline

注意，当使用内联时，不建议将声明和定义分开到两个文件中，会导致链接错误，因为inline被展开，就没有函数地址，链接时会出现报错。这时我们可以将内联函数的声明和定义都放在同一个头文件中。

---

---

---

如果这篇文章有帮助到你，请留下你珍贵的点赞收藏和评论，这对我会是极大的鼓励。学海无涯，我与你共勉！

---

---

---