C++基础语法（二）-C++对C的扩展：【命名空间】【引用（reference）：引用就是起别名（引用：int &b = a）（取地址：int b = &a）】、【函数重载(overload)】

旧城等待， 2023-09-28 09:29 6阅读 0赞

## 一、::作用域运算符 ##

通常情况下，如果有两个同名变量，一个是全局变量，另一个是局部变量，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。

//全局变量
    int a = 10;
    void test(){
       
        
    	//局部变量
    	int a = 20;
    	//全局a被隐藏
    	cout << "a:" << a << endl;
    }

程序的输出结果是a:20。在test函数的输出语句中，使用的变量a是test函数内定义的局部变量，因此输出的结果为局部变量a的值。

作用域运算符可以用来解决局部变量与全局变量的重名问题

//全局变量
    int a = 10;
    //1. 局部变量和全局变量同名
    void test(){
       
        
    	int a = 20;
    	//打印局部变量a
    	cout << "局部变量a:" << a << endl;
    	//打印全局变量a
    	cout << "全局变量a:" << ::a << endl;
    }

这个例子可以看出，作用域运算符可以用来解决局部变量与全局变量的重名问题，即在局部变量的作用域内，可用::对被屏蔽的同名的全局变量进行访问。

## 二、名字控制 ##

创建名字是程序设计过程中一项最基本的活动，当一个项目很大时，它会不可避免地包含大量名字。c++允许我们对名字的产生和名字的可见性进行控制。

我们之前在学习c语言可以通过static关键字来使得名字只得在本编译单元内可见，在c++中我们将通过一种通过命名空间来控制对名字的访问。

### 1、C++命名空间(namespace) ###

在c++中，名称（name）可以是符号常量、变量、函数、结构、枚举、类和对象等等。工程越大，名称互相冲突性的可能性越大。另外使用多个厂商的类库时，也可能导致名称冲突。

为了避免，在大规模程序的设计中，以及在程序员使用各种各样的C++库时，这些标识符的命名发生冲突，标准C++引入关键字namespace（命名空间/名字空间/名称空间），可以更好地控制标识符的作用域。

### 2、命名空间使用语法 ###

 创建一个命名空间:

namespace A{
       
        
    	int a = 10;
    }
    namespace B{
       
        
    	int a = 20;
    }
    void test(){
       
        
    	cout << "A::a : " << A::a << endl;
    	cout << "B::a : " << B::a << endl;
    }

 命名空间只能全局范围内定义（以下错误写法）

void test(){
       
        
    	namespace A{
       
        
    		int a = 10;
    	}
    	namespace B{
       
        
    		int a = 20;
    	}
    	cout << "A::a : " << A::a << endl;
    	cout << "B::a : " << B::a << endl;
    }

 命名空间可嵌套命名空间

namespace A{
       
        
    	int a = 10;
    	namespace B{
       
        
    		int a = 20;
    	}
    }
    void test(){
       
        
    	cout << "A::a : " << A::a << endl;
    	cout << "A::B::a : " << A::B::a << endl;
    }

 命名空间是开放的，即可以随时把新的成员加入已有的命名空间中

namespace A{
       
        
    	int a = 10;
    }
    
    namespace A{
       
        
    	void func(){
       
        
    		cout << "hello namespace!" << endl;
    	}
    }
    
    void test(){
       
        
    	cout << "A::a : " << A::a << endl;
    	A::func();
    }

 声明和实现可分离

#pragma once
    
    namespace MySpace{
       
        
    	void func1();
    	void func2(int param);
    }

void MySpace::func1(){
       
        
    	cout << "MySpace::func1" << endl;
    }
    void MySpace::func2(int param){
       
        
    	cout << "MySpace::func2 : " << param << endl;
    }

 无名命名空间，意味着命名空间中的标识符只能在本文件内访问，相当于给这个标识符加上了static，使得其可以作为内部连接

namespace{
       
        
    	
    	int a = 10;
    	void func(){
       
         cout << "hello namespace" << endl; }
    }
    void test(){
       
        
    	cout << "a : " << a << endl;
    	func();
    }

 命名空间别名

namespace veryLongName{
       
        
    	
    	int a = 10;
    	void func(){
       
         cout << "hello namespace" << endl; }
    }
    
    void test(){
       
        
    	namespace shortName = veryLongName;
    	cout << "veryLongName::a : " << shortName::a << endl;
    	veryLongName::func();
    	shortName::func();
    }

### 3、using声明 ###

using声明可使得指定的标识符可用。

namespace A{
       
        
    	int paramA = 20;
    	int paramB = 30;
    	void funcA(){
       
         cout << "hello funcA" << endl; }
    	void funcB(){
       
         cout << "hello funcA" << endl; }
    }
    
    void test(){
       
        
    	//1. 通过命名空间域运算符
    	cout << A::paramA << endl;
    	A::funcA();
    	//2. using声明
    	using A::paramA;
    	using A::funcA;
    	cout << paramA << endl;
    	//cout << paramB << endl; //不可直接访问
    	funcA();
    	//3. 同名冲突
    	//int paramA = 20; //相同作用域注意同名冲突
    }

using声明碰到函数重载

namespace A{
       
        
    	void func(){
       
        }
    	void func(int x){
       
        }
    	int  func(int x,int y){
       
        }
    }
    void test(){
       
        
    	using A::func;
    	func();
    	func(10);
    	func(10, 20);
    }

如果命名空间包含一组用相同名字重载的函数，using声明就声明了这个重载函数的所有集合。

### 4、using编译指令 ###

using编译指令使整个命名空间标识符可用.

namespace A{
       
        
    	int paramA = 20;
    	int paramB = 30;
    	void funcA(){
       
         cout << "hello funcA" << endl; }
    	void funcB(){
       
         cout << "hello funcB" << endl; }
    }
    
    void test01(){
       
        
    	using namespace A;
    	cout << paramA << endl;
    	cout << paramB << endl;
    	funcA();
    	funcB();
    
    	//不会产生二义性
    	int paramA = 30;
    	cout << paramA << endl;
    }
    
    namespace B{
       
        
    	int paramA = 20;
    	int paramB = 30;
    	void funcA(){
       
         cout << "hello funcA" << endl; }
    	void funcB(){
       
         cout << "hello funcB" << endl; }
    }
    
    void test02(){
       
        
    	using namespace A;
    	using namespace B;
    	//二义性产生，不知道调用A还是B的paramA
    	//cout << paramA << endl;
    }

注意：使用using声明或using编译指令会增加命名冲突的可能性。也就是说，如果有名称空间，并在代码中使用作用域解析运算符，则不会出现二义性。

### 5、命名空间使用 ###

我们刚讲的一些东西一开始会觉得难一些，这些东西以后还是挺常用，只要理解了它们的工作机理，使用它们非常简单。

需要记住的关键问题是当引入一个全局的usin