C++学习笔记-命名空间

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>

namespace apple {
    void print(const char* text)
    {
        std::cout << "apple: " << text << std::endl;
    }
}

namespace orange {
    void print(const char* text)
    {
        std::cout << "orange: " << text << std::endl;
    }
}

int main()
{
    apple::print("Hello");
    orange::print("Hello");
    
    // 使用作用域解析运算符::来访问命名空间中的成员
    std::cout << "This uses std namespace" << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

#include <iostream>
#include <string>

// 基本命名空间定义
namespace MyLibrary
{
    int version = 1;
    
    void PrintVersion()
    {
        std::cout << "MyLibrary version: " << version << std::endl;
    }
    
    class Calculator
    {
    public:
        int Add(int a, int b) { return a + b; }
        int Subtract(int a, int b) { return a - b; }
    };
    
    namespace Internal  // 嵌套命名空间
    {
        void DebugPrint(const std::string& message)
        {
            std::cout << "[DEBUG] " << message << std::endl;
        }
    }
}

// 命名空间可以在多个地方定义（会合并）
namespace MyLibrary
{
    void PrintInfo()
    {
        std::cout << "MyLibrary - A simple math library" << std::endl;
    }
}

// 匿名命名空间（文件作用域）
namespace
{
    int fileLocalVariable = 42;
    
    void fileLocalFunction()
    {
        std::cout << "This function is only visible in this file" << std::endl;
    }
}

int main()
{
    // 使用完全限定名
    MyLibrary::PrintVersion();
    MyLibrary::PrintInfo();
    
    // 使用嵌套命名空间
    MyLibrary::Internal::DebugPrint("Testing nested namespace");
    
    // 使用命名空间中的类
    MyLibrary::Calculator calc;
    std::cout << "5 + 3 = " << calc.Add(5, 3) << std::endl;
    
    // 使用匿名命名空间中的内容
    fileLocalFunction();
    std::cout << "File local variable: " << fileLocalVariable << std::endl;
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#include <iostream>
#include <vector>
#include <string>

namespace Graphics
{
    class Point
    {
    public:
        int x, y;
        Point(int x, int y) : x(x), y(y) {}
        void Print() const { std::cout << "Point(" << x << ", " << y << ")" << std::endl; }
    };
    
    class Color
    {
    public:
        int r, g, b;
        Color(int r, int g, int b) : r(r), g(g), b(b) {}
        void Print() const { std::cout << "Color(" << r << ", " << g << ", " << b << ")" << std::endl; }
    };
    
    void DrawLine(const Point& start, const Point& end)
    {
        std::cout << "Drawing line from ";
        start.Print();
        std::cout << " to ";
        end.Print();
    }
}

namespace Math
{
    const double PI = 3.14159;
    
    double CalculateArea(double radius)
    {
        return PI * radius * radius;
    }
    
    class Vector
    {
    public:
        double x, y;
        Vector(double x, double y) : x(x), y(y) {}
        void Print() const { std::cout << "Vector(" << x << ", " << y << ")" << std::endl; }
    };
}

int main()
{
    std::cout << "=== Using Declarations and Directives ===" << std::endl;
    
    // 1. 不使用using，完全限定名
    Graphics::Point p1(10, 20);
    Graphics::Color red(255, 0, 0);
    p1.Print();
    red.Print();
    
    // 2. using声明 - 引入特定的名称
    using Graphics::Point;
    using Math::PI;
    
    Point p2(30, 40);  // 现在可以直接使用Point
    p2.Print();
    std::cout << "PI = " << PI << std::endl;
    
    // 3. using指令 - 引入整个命名空间
    {
        using namespace Math;  // 局部作用域中使用
        
        Vector v(1.0, 2.0);
        v.Print();
        
        double area = CalculateArea(5.0);
        std::cout << "Circle area: " << area << std::endl;
    }
    
    // 4. 标准库的using
    using std::cout;
    using std::endl;
    using std::string;
    
    cout << "Using std declarations" << endl;
    string message = "Hello, World!";
    cout << message << endl;
    
    // 5. using namespace std（不推荐在头文件中使用）
    {
        using namespace std;
        vector<int> numbers = {1, 2, 3, 4, 5};
        cout << "Vector size: " << numbers.size() << endl;
    }
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#include <iostream>

namespace VeryLongLibraryNameForGraphics
{
    namespace Rendering
    {
        namespace OpenGL
        {
            void InitializeContext()
            {
                std::cout << "OpenGL context initialized" << std::endl;
            }
            
            void RenderFrame()
            {
                std::cout << "Rendering OpenGL frame" << std::endl;
            }
        }
        
        namespace DirectX
        {
            void InitializeContext()
            {
                std::cout << "DirectX context initialized" << std::endl;
            }
            
            void RenderFrame()
            {
                std::cout << "Rendering DirectX frame" << std::endl;
            }
        }
    }
}

int main()
{
    std::cout << "=== Namespace Aliases ===" << std::endl;
    
    // 创建命名空间别名
    namespace Graphics = VeryLongLibraryNameForGraphics;
    namespace GL = VeryLongLibraryNameForGraphics::Rendering::OpenGL;
    namespace DX = VeryLongLibraryNameForGraphics::Rendering::DirectX;
    
    // 使用别名
    GL::InitializeContext();
    GL::RenderFrame();
    
    DX::InitializeContext();
    DX::RenderFrame();
    
    // 也可以为标准库创建别名
    namespace chrono = std::chrono;
    
    return 0;
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169

#include <iostream>
#include <vector>
#include <memory>

// 公司/项目级别的命名空间
namespace MyCompany
{
    // 产品级别的命名空间
    namespace GameEngine
    {
        // 功能模块级别的命名空间
        namespace Graphics
        {
            class Renderer
            {
            public:
                void Initialize() { std::cout << "Graphics renderer initialized" << std::endl; }
                void Render() { std::cout << "Rendering frame" << std::endl; }
            };
            
            class Texture
            {
            private:
                std::string m_Path;
                
            public:
                Texture(const std::string& path) : m_Path(path) {}
                void Load() { std::cout << "Loading texture: " << m_Path << std::endl; }
            };
        }
        
        namespace Audio
        {
            class AudioEngine
            {
            public:
                void Initialize() { std::cout << "Audio engine initialized" << std::endl; }
                void PlaySound(const std::string& soundFile)
                {
                    std::cout << "Playing sound: " << soundFile << std::endl;
                }
            };
        }
        
        namespace Physics
        {
            class RigidBody
            {
            private:
                float m_Mass;
                
            public:
                RigidBody(float mass) : m_Mass(mass) {}
                void ApplyForce(float force)
                {
                    std::cout << "Applying force " << force << " to body with mass " << m_Mass << std::endl;
                }
            };
        }
        
        // 内部实现细节
        namespace Internal
        {
            void LogMessage(const std::string& message)
            {
                std::cout << "[ENGINE] " << message << std::endl;
            }
            
            class MemoryManager
            {
            public:
                static void* Allocate(size_t size)
                {
                    std::cout << "Allocating " << size << " bytes" << std::endl;
                    return malloc(size);
                }
                
                static void Deallocate(void* ptr)
                {
                    std::cout << "Deallocating memory" << std::endl;
                    free(ptr);
                }
            };
        }
    }
    
    // 工具库命名空间
    namespace Utils
    {
        namespace String
        {
            std::string ToUpper(const std::string& str)
            {
                std::string result = str;
                std::transform(result.begin(), result.end(), result.begin(), ::toupper);
                return result;
            }
            
            std::vector<std::string> Split(const std::string& str, char delimiter)
            {
                std::vector<std::string> tokens;
                std::stringstream ss(str);
                std::string token;
                
                while (std::getline(ss, token, delimiter))
                {
                    tokens.push_back(token);
                }
                
                return tokens;
            }
        }
        
        namespace Math
        {
            const double PI = 3.14159265359;
            
            double DegreeToRadian(double degree)
            {
                return degree * PI / 180.0;
            }
            
            double RadianToDegree(double radian)
            {
                return radian * 180.0 / PI;
            }
        }
    }
}

// 使用别名简化长命名空间
namespace Engine = MyCompany::GameEngine;
namespace Graphics = MyCompany::GameEngine::Graphics;
namespace Audio = MyCompany::GameEngine::Audio;
namespace Physics = MyCompany::GameEngine::Physics;
namespace Utils = MyCompany::Utils;

int main()
{
    std::cout << "=== Project Namespace Organization ===" << std::endl;
    
    // 初始化引擎组件
    Graphics::Renderer renderer;
    Audio::AudioEngine audioEngine;
    
    renderer.Initialize();
    audioEngine.Initialize();
    
    // 创建游戏对象
    Graphics::Texture playerTexture("player.png");
    playerTexture.Load();
    
    Physics::RigidBody playerBody(75.0f);
    playerBody.ApplyForce(100.0f);
    
    // 使用工具函数
    std::string message = "hello world";
    std::string upperMessage = Utils::String::ToUpper(message);
    std::cout << "Original: " << message << std::endl;
    std::cout << "Upper: " << upperMessage << std::endl;
    
    double angle = Utils::Math::DegreeToRadian(90.0);
    std::cout << "90 degrees = " << angle << " radians" << std::endl;
    
    // 使用内部命名空间（通常不推荐在外部使用）
    Engine::Internal::LogMessage("Game started");
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

#include <iostream>
#include <string>

// 1. 避免在头文件中使用 using namespace
// 好的做法：在.cpp文件中使用
namespace GoodPractice
{
    void Function1()
    {
        using namespace std;  // 仅在函数作用域中使用
        cout << "This is okay in implementation files" << endl;
    }
    
    void Function2()
    {
        using std::cout;      // 更好：只引入需要的名称
        using std::endl;
        cout << "This is even better" << endl;
    }
}

// 2. 命名空间命名约定
namespace my_company      // 小写，下划线分隔
{
    namespace graphics_engine  // 模块名
    {
        namespace v2          // 版本号
        {
            class Renderer { /* ... */ };
        }
    }
}

// 3. 避免命名冲突
namespace Library1
{
    void Process() { std::cout << "Library1::Process" << std::endl; }
}

namespace Library2
{
    void Process() { std::cout << "Library2::Process" << std::endl; }
}

// 4. 使用匿名命名空间替代static
namespace
{
    // 这些只在当前文件中可见
    const int INTERNAL_CONSTANT = 42;
    
    void InternalHelper()
    {
        std::cout << "Internal helper function" << std::endl;
    }
}

// 5. 条件命名空间
#ifdef DEBUG
namespace Debug
{
    void Log(const std::string& message)
    {
        std::cout << "[DEBUG] " << message << std::endl;
    }
}
#else
namespace Debug
{
    void Log(const std::string& message) { /* 空实现 */ }
}
#endif

int main()
{
    std::cout << "=== Namespace Best Practices ===" << std::endl;
    
    // 明确指定命名空间避免冲突
    Library1::Process();
    Library2::Process();
    
    // 使用匿名命名空间中的内容
    InternalHelper();
    std::cout << "Internal constant: " << INTERNAL_CONSTANT << std::endl;
    
    // 条件编译的命名空间
    Debug::Log("This is a debug message");
    
    // 局部using声明
    {
        using Library1::Process;
        Process();  // 调用Library1::Process
    }
    
    // 命名空间别名的使用
    namespace gfx = my_company::graphics_engine::v2;
    // gfx::Renderer renderer;  // 如果有实现的话
    
    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

#include <iostream>

// C++17之前的写法
namespace Company
{
    namespace Product
    {
        namespace Module
        {
            namespace Version
            {
                void Function()
                {
                    std::cout << "Old style nested namespace" << std::endl;
                }
            }
        }
    }
}

// C++17的简化写法
namespace Company::Product::Module::Version::New
{
    void Function()
    {
        std::cout << "C++17 style nested namespace" << std::endl;
    }
    
    class MyClass
    {
    public:
        void DoSomething()
        {
            std::cout << "MyClass in nested namespace" << std::endl;
        }
    };
}

int main()
{
    std::cout << "=== C++17 Nested Namespaces ===" << std::endl;
    
    Company::Product::Module::Version::Function();
    Company::Product::Module::Version::New::Function();
    
    Company::Product::Module::Version::New::MyClass obj;
    obj.DoSomething();
    
    // 使用别名简化长命名空间
    namespace NewNS = Company::Product::Module::Version::New;
    NewNS::MyClass obj2;
    obj2.DoSomething();
    
    return 0;
}