一、面向对象编程概述

1.1、面向过程

面向过程是一种计算机编程思想，它主要关注程序的执行流程和数据处理，强调程序由一系列相互依赖的函数或子程序组成，并且这些函数按照特定的顺序执行以完成特定的任务。在面向过程编程中，将问题分解为多个小部分，并对每个小部分进行具体实现和优化，最终整合起来形成一个完整的程序。

面向过程编程通常包括以下步骤：

1. 定义问题：确定要解决的问题或任务；
2. 分析问题：将问题分解为多个小部分并确定其相互依赖关系；
3. 设计方案：根据需要选择适当的数据结构和算法，并定义各个子程序或函数；
4. 编写代码：实现各个子程序或函数，并按照设计方案组合起来形成完整的程序；
5. 调试测试：对程序进行测试、调试和优化，确保其能够正确地运行。

面向过程编程思想的核心：功能分解、自顶向下、逐层细化（程序=数据结构+算法）。
面向过程的主要缺点是不符合人的思维习惯、重用性低、维护困难等。

1.2、面向对象

面向对象编程（Object Oriented Programming，简称OOP）是一种编程思想，它将程序看作一个由各种独立的对象组成的集合。每个对象都有自己的属性和方法，并且可以与其他对象进行交互，共同完成任务。在面向对象编程中，通过类和实例来描述具体事物，类定义了一类事物的通用属性和方法，而实例则是具体某个事物的一个具体表现。

面向对象编程主要包括以下特点：

1. 封装性：将数据和行为封装到一个对象中，并通过接口对外提供访问权限。
2. 继承性：通过继承机制，在已有类的基础上派生出新的类，从而减少重复代码。
3. 多态性：不同的对象对同一消息作出响应时呈现出不同的行为形式。
4. 抽象性：提取公共部分形成抽象类或接口，并在子类中实现其具体细节。

面向对象编程常见应用场景包括图形界面开发、游戏开发、Web应用程序开发等领域。采用面向对象编程思想可以增强代码的可读性、可维护性以及代码复用性，并且更加符合人们对于问题解决方式的认知。

二、作用域运算符 :: （双冒号）

C++作用域运算符 :: 主要解决归属问题（谁是谁的谁）。

而且，C++的作用域运算符 ::（双冒号）用于访问全局命名空间、类的成员以及命名空间中的成员。

在全局命名空间中，可以使用 :: 来访问定义在该作用域中的变量和函数。例如：

#include <iostream>
using namespace std;

int x = 10;

int main() {
    int x = 5;
    cout << "local x: " << x << endl;   // 输出 local x: 5
    cout << "global x: " << ::x << endl;   // 输出 global x: 10
    return 0;
}

在类的成员函数中，可以使用 :: 来访问同名但不同作用域下的变量或函数。例如：

#include <iostream>
using namespace std;

int a = 1;

class Test {
public:
    int a = 2;
    static int b;

    void print(int a) {
        cout << "a in function parameter: " << a << endl;   // 输出 a in function parameter: 3
        cout << "a in class member variable: " << this->a << endl;   // 输出 a in class member variable: 2
        cout << "a in global variable scope: " << ::a << endl;   // 输出 a in global variable scope: 1
    }
};

int Test::b = 4;

int main() {
    Test t;
    t.print(3);
    return 0;
}

在命名空间中，也可以使用 :: 来访问其他命名空间或者全局命名空间中的变量和函数。例如：

#include <iostream>
using namespace std;

namespace ns1 {
    int x = 10;
}

namespace ns2 {
    int x = 20;
}

int main() {
    cout << "ns1::x: " << ns1::x << endl;   // 输出 ns1::x: 10
    cout << "ns2::x: " << ns2::x << endl;   // 输出 ns2::x: 20
    return 0;
}

三、命名空间 namespace

创建名字是程序设计工程中一项最基本的活动，当一个项目很大时就可能包含大量的名字，C++允许对名字的产生和名字的可见性进行控制。

C++中名称可以是符号常量、变量、函数、结构、枚举、类和对象等等，工程越大，名称互相冲突的可能性越大。另外，使用多个类库时，也可能导致名称冲突。为了避免在大规模程序设计中以及在程序员使用各种各样C++库时，这些标识符的名称发生冲突，标准C++引入了关键字namespace，可以更好的控制标识符的作用域。

C++命名空间（namespace）是一种将标识符封装起来的机制，以避免命名冲突和全局污染。通过在命名空间中定义变量、函数、类等，可以使得这些标识符只在该命名空间内可见，从而避免与其他代码产生冲突。

3.1、命名空间使用语法

C++中的命名空间使用语法如下：

// 声明命名空间
namespace namespace_name {
    // 声明或定义变量、函数、类等
}

// 使用命名空间中的标识符
namespace_name::identifier;

其中，namespace_name为命名空间的名称，可以包含字母、数字和下划线，但不能以数字开头。在一个程序中可以定义多个不同名称的命名空间。

（1）创建一个命名空间：

namespace nameA{
	int a=10;
}

namespace nameB{
	int a=20;
}

void test()
{
	cout<<"A::a = "<<A::a<<endl;// 输出10
	cout<<"B::a = "<<B::a<<endl;// 输出20
}

（2）命名空间只能全局范围内定义。下面的做法是错误的：

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

所以，定义命名空间一定要在函数外面，不要在函数内部定义。

（3）命名空间可以嵌套命名空间：

namespace nameA{
	int a=10;
	namespace nameB{
		int a=20;
	}
}



void test()
{
	cout<<"A::a = "<<A::a<<endl;// 输出10
	cout<<"B::a = "<<A::B::a<<endl;// 输出20
}

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

// 初始的成员
namespace nameA{
	int a=10;
}
// 第二次添加成员
namespace nameA{
	void func(){
		cout<<"nameA func"<<endl;
	}
}

void test()
{
	cout<<"A::a = "<<A::a<<endl;
	A::func();
}

（5）声明和实现可分离：

namespace mynamespace{
	void func1();
	void func2(int num);
}
void mynamespace::func1()
{
	cout<<"mynamespace::func1"<<endl;
}
void mynamespace::func2(int num)
{
	cout<<"mynamespace::func2 num = "<<num<<endl;
}

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

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

void test()
{
	cout<<"a = "<<a<<endl;
	func();
}

（7）命名空间别名。

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

void test()
{
	namespace shortName=longName;
	cout<<"shortName::a = "<<shortName::a<<endl;
	cout<<"longName::a = "<<longName::a<<endl;
	longName::func();
	shortName::func();
}

3.2、using声明命名空间中的成员可用

using声明命名空间中的成员可用是指在使用using关键字声明了一个命名空间后，可以直接使用该命名空间中的类、结构体、函数等成员，无需使用完全限定名称。例如：

namespace longName{
	int helloInt=10;
	char helloChar='c';
	float helloFloat=12.7f;
	void func(){
		cout<<"hello namespace longName"<<endl;
	}
}



void test()
{
	// 通过命名空间域运算符访问（推荐）
	cout<<"longName::helloInt = "<<longName::helloInt<<endl;
	// using声明成员可用
	using longName::helloInt;
	using longName::func;
	cout<<"longName::helloInt = "<<helloInt<<endl;
	// cout<<"longName::helloChar = "<<helloChar<<endl;//不可访问
	func();
	// int helloInt=20;//相同作用域，同名冲突
}

注意：using声明命名空间中的成员可用虽然不要加作用域符号了，但是可能会和已有的变量产生同名冲突。

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

namespace longName{
	int helloInt=10;
	char helloChar='c';
	float helloFloat=12.7f;
	void func(){
		cout<<"hello namespace longName"<<endl;
	}
	void func(int num){
		cout<<"hello namespace longName num = "<<num<<endl;
	}
	int func(int num1,int num2){
		cout<<"hello namespace longName num1+num2 = "<<num1+num2<<endl;
		return num1+num2;
	}
}
void test()
{
	using longName::func;
	func();
	func(10);
	func(10,20);
}

3.3、using声明整个命名空间可用

如果命名空间有成千上百个成员，一个个声明就显得非常不方便；C++提供可以整个命名空间可用的方式。
这时编译器会先查找局部范围内的变量或函数，没有才去命名空间中查找；不会产生二义性。

namespace NameA{
	int helloInt=10;
	char helloChar='c';
	float helloFloat=12.7f;
	void func(){
		cout<<"hello namespace NameA"<<endl;
	}
	int func2(int num1,int num2){
		cout<<"hello namespace NameA num1+num2 = "<<num1+num2<<endl;
		return num1+num2;
	}
}
namespace NameB{
	int helloInt=10;
	char helloChar='c';
	float helloFloat=12.7f;
	void func(){
		cout<<"hello namespace NameA"<<endl;
	}
	int func2(int num1,int num2){
		cout<<"hello namespace NameA num1+num2 = "<<num1+num2<<endl;
		return num1+num2;
	}
}
void test()
{
	using namespace NameA;
	cout<<helloInt<<endl;
	cout<<helloChar<<endl;
	func();
	func2(10,20);
	// 不会产生二义性，编译器会优先查找局部内的变量，当找不到时才去命名空间中去查找。
	int helloInt=30;
	cout<<helloInt<<endl;
}
void test2()
{
	using namespace NameA;
	using namespace NameB;
	// 产生问题，不知道调用哪个的命名空间的变量，这时最好用上命名空间名+作用域符号+变量名的方式
	cout<<helloInt<<endl;//error
	// 正确访问：
	cout<<NameA::helloInt<<endl;
	cout<<NameB::helloInt<<endl;
	
}

四、总结

C++命名空间(namespace)是一种将全局作用域划分为若干个小的作用域的机制，可以避免不同库之间或者同一项目中的命名冲突问题。以下是C++命名空间的一些总结：

1. 命名空间使用关键字namespace来定义。
2. 可以在命名空间中定义变量、常量、函数、类等。
3. 通过“::”（作用域解析运算符）来访问命名空间中的成员，例如namespace_name::member_name。
4. 也可以使用using声明语句将整个命名空间引入到当前作用域中，从而直接使用其中的成员，例如using namespace namespace_name;。
5. 在一个文件中可以定义多个命名空间，并且一个命名空间可以嵌套在另一个命名空间内。
6. C++标准库中的所有类和函数都被包含在了std命名空间中，因此在使用这些类和函数时需要加上std前缀，或者使用using声明语句将整个std命名空间引入到当前作用域中。
7. 命名空间对于代码的可读性和维护性非常重要，在大型项目中应该充分利用它来避免名称冲突和提高代码的可读性。

C++命名空间是一个非常有用的特性，可以有效避免命名冲突问题，提高代码的可维护性和可读性。在实际开发中应该充分利用命名空间来组织代码结构，并且避免滥用using声明语句。