目录

#include <iostream>

// 多行宏定义，反斜杠后面必须紧跟着回车
#define MAIN int main()\
{\
    LOG("Hello!");\
    LOGX("Hello!");\
\
    std::cin.get();\
}

#define HW_DEBUG 2

// 较好的定义方式
#if HW_DEBUG == 1 // 如果条件 HW_DEBUG == 1 满足，则
#define LOGX(x) std::cout << x << std::endl
#elif HW_DEBUG == 2 // 否则如果条件 HW_DEBUG == 2 满足，则
#define LOGX(x) std::cout << "value: " << x << std::endl;
#else // 否则
#define LOGX(x)
#endif // 用来结束分支语句 #else

#define HW_DEBUG

// 常见的定义方式
#ifdef HW_DEBUG // 如果定义了宏 HW_DEBUG，则
#define LOG(x) std::cout << x << std::endl
#elif defined HW_DEBUGX //或者定义了宏 HW_DEBUGX，则
#define LOG(x) std::cout << "value: " << x << std::endl;
#else // 否则
#define LOG(x)
#endif // 用来结束分支语句 #else

// 使用多行宏定义 MAIN，等价于：
//int main()
//{
// 	  LOG("Hello!");
//    LOGX("Hello!");
//
//    std::cin.get();
//}
MAIN

#include <iostream>

// 声明定义的方式，在数据段上创建变量（和初始化）
int var1;
int var2 = 1;

// 在堆上创建变量（和初始化）
int* var3 = new int;
int* var4 = new int(1);

class Class
{
public:
    int value;
    // 构造函数
    Class()
    {
        // 对成员变量 value 初始化
        value = 1;
        std::cout << "Value is " << value << std::endl;
    }
};

int main()
{
    // 声明定义的方式，在堆上创建变量（和初始化）
    int var3;
    int var4 = 1;
    
    // 类或结构体类型的变量创建时，会调用它的构造函数，可能对成员变量进行初始化
    Class class1; // 实例创建时，成员变量创建，随后调用构造函数 >> Value is 1
    Class* class2 = new Class(); // >> value is 1

    std::cin.get();
}

// 基本类型
int intValue = 0;

// 指针
// 关于指针，需要注意 “* 其实是和 intPointer 放在一起的”
// 例如：int* a, b 得到的其实是指向 int 类型变量的指针 a 和 int 类型的变量 b
// 因此编写代码时，强烈建议将 “多个变量的定义分行书写”
int* intPointer = &intValue;

// 数组，一维数组 intArray、二维数组 intArray2D
int intArray[5]{ 1, 2, 3, 4, 5 }; // 列表初始化（C++ 11）
int intArray2D[5][5]{{ 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }};

// 字符串
const char* str1 = "Hello"; // 原始字符串
std::string str2 = "Hello"; // 其实是一个对象

// 类和结构体
class Circle {
public:
    double radius;
    Circle(double r) : radius(r) {}
};
Circle circle1(5.0); // 构造函数
Circle circle2{ 5.0 }; // 也是列表初始化（C++ 11）

// 基本类型
int* intValue = new int(0);

// 数组
// 数组，一维数组 intArray、二维数组 intArray2D
// 对于数组，要注意它类型转换为的是 “指向数组首个元素的指针” 
// 因此一维数组使用 int*，二维数组使用 int(*)[n]
int* intArray = new int[5]{ 1, 2, 3, 4, 5 }; // 列表初始化（C++ 11）
int (*intArray2D)[5] = new int[5][5]{{ 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }, { 1, 2, 3, 4, 5 }};

// 字符串
const char* str1 = new char[6]{'H', 'e', 'l', 'l', 'o'};
std::string* str2 = new std::string("Hello"); // 其实是一个对象

// 类和结构体
class Circle {
public:
    double radius;
    Circle(double r) : radius(r) {}
};
Circle* circle = new Circle(5.0); // 构造函数
Circle* circle2 = new Circle{5.0}; // 也是列表初始化（C++ 11）

int add1(int a, int b)
{
    return a + b;
}
const int sum1 = add1(5, 10); // 创建常量变量，运行时，sum1 赋值为 15 后，不允许修改

// 通常配合 constexpr 函数使用
constexpr add2(int a, int b)
{
    return a + b;
}
constexpr int sum2 = add2(5, 10); // 创建常量表达式，编译时求值优化为 constexpr int sum2 = 15

int variableInt = 1;

// 基本类型、数组、结构体
const int CONST_INT = 1;

// 指针
// const 在 * 前表示指针指向常量；const 在 * 后表示这是常量指针。eg：
const int* pointerToConstInt = &CONST_INT; // 一个指向 int 常量的指针
int* const CONST_POINTER_TO_INT = &variableInt; // 一个指向 int 变量的常量指针
const int* const CONST_POINTER_TO_CONST_INT = &CONST_INT; // 一个指向 int 常量的常量指针

#include <iostream>

// 声明并定义
void print(const char* message)
{
    std::cout << message << std::endl;
}

int main()
{
    print("Hello"); // >> Hello

    std::cin.get();
}

#include <iostream>

// 声明函数 globalPrint 存在于某个翻译单元，请允许使用
void globalPrint(const char* message);

int main()
{
    // 声明函数 localPrint 存在于某个翻译单元，请允许使用
	void localPrint(const char* message);
    
    globalPrint("Global"); // >> Global
    localPrint("Local"); // >> Local
    
    std::cin.get();
}

#include <iostream>

void globalPrint(const char* message)
{
    std::cout << message << std::endl;
}

void localPrint(const char* message)
{
    std::cout << message << std::endl;
}

#include <iostream>

// 犹如为变量 a 起了别名 int& target = a，以及创建了变量 b 的副本 int source = b
void addTo(int& target, int source) 
{
    source++;
    target += source;
    std::cout << target << std::endl;
}

int main()
{
    int a = 10;
    int b = 5;
    addTo(a, b); // >> 16
    std::cout << a << std::endl; // 使用引用，所以 a 变了 >> 16
    std::cout << b << std::endl; // 创建副本，所以 b 没变 >> 5
}

int add(int a, int b)
{
    return a + b;
}

int main()
{
    // 起类型别名
    typedef int(*AddFunction)(int, int);

    int(*function1)(int, int) = add; // function1 函数指针
    AddFunction function2 = add; // function2 函数指针

    int a = 1;
    int* ptr1 = &a; // 对变量做取地址运算
    int* ptr2 = new int; // 使用动态分配的地址
}

#include <iostream>

int add(int a, int b)
{
    return a + b;
}

int main()
{
    int(*function)(int, int) = add; // 隐式类型转换，原始函数指针
     
    std::cout << function(1, 5) << std::endl; // 像函数一样使用 >> 6

    std::cin.get();
}

#include <iostream>
#include <memory>

class Entity {
public:
    std::shared_ptr<Entity> ptr;
    Entity() { std::cout << "Entity created" << std::endl; }
    ~Entity() { std::cout << "Entity destroyed" << std::endl; }
};

int main() {
    {
        // 使用 unique_ptr
        std::unique_ptr<Entity> uniquePtr = std::make_unique<Entity>();

        // 使用 shared_ptr
        std::shared_ptr<Entity> sharedPtr1 = std::make_shared<Entity>();
        {
            std::shared_ptr<Entity> sharedPtr2 = sharedPtr1; // 共享变量所有权，引用计数加 1
            std::cout << "sharedPtr1 count: "
                << sharedPtr1.use_count() << std::endl; // >> 2

            std::weak_ptr<Entity> weakPtr = sharedPtr1; // 共享变量所有权，但引用计数不变
        }
        // sharedPtr2、weakPtr 离开作用域，引用计数只减 1
        std::cout << "sharedPtr1 count: " << sharedPtr1.use_count() << std::endl; // >> 1
    } // 离开作用域，所有智能指针释放内存

    // 循环引用，导致内存泄漏
    std::shared_ptr entity1 = std::make_shared<Entity>();
    std::shared_ptr entity2 = std::make_shared<Entity>();
    entity1->ptr = entity2;
    entity2->ptr = entity1;

    std::cin.get();
    return 0;
}

int main()
{
    int a = 1;
    int& ref1 = a; // 为变量 a 起了一个别名 ref1
    
    std::cin.get();
}

#include <iostream>

int main()
{
    int a = 1;

    int& refToA = a;
    int* ptrToA = &a;
    
    // refToA 使用上等价于 *ptrToA
    std::cout << refToA << std::endl; // >> 1
    std::cout << *ptrToA << std::endl; // >> 1
}

#include <iostream>
#include <string>
#include <memory>

class String {
private:
    char* m_Buffer;
    int m_Size;
public:
    String(const char* string)
    {
        m_Size = strlen(string);
        m_Buffer = new char[m_Size + 1];
        memcpy(m_Buffer, string, m_Size);
        m_Buffer[m_Size] = 0;
    }

    ~String()
    {
        delete[] m_Buffer;
    }

    // 希望使用引用传递返回值，且可以确保返回的引用不会在对象销毁前销毁
    // 因此使用 char& 替代 char
    char& operator[](unsigned int index)
    {
        return m_Buffer[index];
    }
};

int main() {
    
    String string = "Hello!";
    
    // 使用引用，犹如为 string.m_Buffer[1] 起了个别名 string[1]：
    // char& string[1] = string.m_Buffer[1]
    string[1] = 'a'; 
    
    std::cin.get();
}

#include <iostream>

enum EnumInt
{
    A, B, C // A，B，C 的值分别是 0，1，2，作用域为全局
};

struct Struct
{
    enum EnumUChar : unsigned char // 使用继承的语法，设置值的类型为 unsigned char
    {
        A = 1, B = 5, C // A，B，C 的值分别是 1，5，6，作用域为 Struct
    };
};

enum class EnumClassInt
{
    A = 1, B, C // A, B, C 的值分别为 1, 2, 3，作用域被限制在 EnumClassInt 中
};

int main()
{
    // 枚举的值，其作用域在枚举所在的整个作用域，因此 EnumInt 中值 B 的作用域为全局
    EnumInt value1 = B;
    if (value1 == B)
    {
        std::cout << "value1 is B!" << std::endl;
    }

    // 枚举的值，其作用域在枚举所在的整个作用域，因此 EnumUChar 中值 B 的作用域为 Struct
    Struct::EnumUChar value2 = Struct::B;
    if (value2 == Struct::B)
    {
        std::cout << "value2 is Struct::B!" << std::endl;
    }

    // 枚举类的值，其作用域为枚举类自身，因此 EnumClassInt 中值 B 的作用域为 EnumClassInt
    EnumClassInt value3 = EnumClassInt::B;
    if (value3 == EnumClassInt::B)
    {
        std::cout << "value3 is EnumClassInt::B!" << std::endl;
    }

    int anInt1 = EnumInt::B; // 能隐式转换
    // int anInt2 = EnumClassInt::B; // 不能隐式转换

    std::cin.get();
}

#include <iostream>

class Log // struct Log 与之完全等价
{
// public 成员变量
public:
    const int LogLevelError = 0;
    const int LogLevelWarning = 1;
    const int LogLevelInfo = 2;
// private 成员变量
private:
    int m_LogLevel = LogLevelInfo;

// public 成员函数
public:
    void setLevel(int level)
    {
        m_LogLevel = level;
    }

    void error(const char* message)
    {
        if (m_LogLevel >= LogLevelError)
        {
            std::cout << "[ERROR]:" << message << std::endl;
        }
    }

    void warn(const char* message)
    {
        if (m_LogLevel >= LogLevelWarning)
        {
            std::cout << "[WARNING]:" << message << std::endl;
        }
    }

    void info(const char* message)
    {
        if (m_LogLevel >= LogLevelInfo)
        {
            std::cout << "[INFO]:" << message << std::endl;
        }
    }
};

int main() 
{
    // 实例化
    Log log;
    log.setLevel(log.LogLevelWarning);
    log.error("FBI OPEN THE DOOR!");
    log.warn("FBI OPEN THE DOOR!");
    log.info("FBI OPEN THE DOOR!");

    std::cin.get();
}

#include <iostream>

// 声明类
class Class
{
public:
    // 同时向编译器声明了它的成员变量 value、count
    int value;
    static int count;
    // int count; // 不允许再次声明，提示重定义错误
};
int Class::count;

// 用作变量创建
Class aClass;

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;
    static int count;

    // 构造函数
    Person()
        : name("Unknown"), age(0)
    {
        count++;
    }

    Person(const std::string& name, int age)
        : name(name), age(age)
    {
        count++;
    }

    void printName()
    {
        std::cout << name << std::endl;
    }
};
// 在类先完成创建
int Person::count;

int main() {
    // 默认构造函数实例化对象
    Person person1; // 或 Person person1 = Person()
    person1.printName();

    // 有参构造函数实例化对象
    Person person2("Alice", 30); // 或 Person person2 = Person("Alice", 30)
    person2.printName();

    // 默认构造函数列表初始化（C++ 11）
    Person person3{}; // 或 Person person3 = {}，或 Person person3Too = Person{};
    person3.printName();

    // 有参构造函数列表初始化（C++ 11）
    Person person4{ "Bob", 25 }; // 或 Person person4 = { "Bob", 25 }，或 Person person4 = Person{ "Bob", 25 }
    person4.printName();
    
    // 使用栈内存省略

    std::cin.get();
}

#include <iostream>

class Entity
{
private:
    float m_X, m_Y;
public:
    // 默认构造函数
    Entity()
    {
        m_X = 0.0f;
        m_Y = 0.0f;
    };

    // 有参构造函数
    Entity(float x, float y)
    {
        m_X = x;
        m_Y = y;
    };

    void print()
    {
        std::cout << m_X << ", " << m_Y << std::endl;
    }
};

int main()
{
    // 调用默认构造函数
    Entity e1; // 不可以带有小括号“()”
    e1.print(); // >> 0, 0
    Entity* e2 = new Entity(); // 可以带有也可以不带有小括号“()”
    e2->print(); // >> 0, 0
    
    // 调用有参构造函数
    Entity e3(5.0f, 5.0f);
    e3.print(); // >> 5, 5
    Entity* e4 = new Entity(5.0f, 5.0f);
    e4->print(); // >> 5, 5

    std::cin.get();
}

#include <iostream>

class Wheel
{
public:
    float m_Length;
    float m_Width;

    Wheel()
        : m_Length(0.0f), m_Width(0.0f)
    {
        std::cout << "Wheel created default!" << std::endl;
    }

    Wheel(float length, float width)
        : m_Length(length), m_Width(width)
    {
        std::cout << "Wheel created!" << std::endl;
    }

    void print()
    {
        std::cout << m_Length << " * " << m_Width << std::endl;
    }
};

// 使用初始化列表
class Car1
{
public:
    Wheel m_Wheel;

    Car1()
        : m_Wheel(10.0f, 5.0f) // 使用初始化列表
    {
        m_Wheel.print();
    }

};

// 不使用初始化列表
class Car2
{
public:
    Wheel m_Wheel;

    Car2()
    {
        m_Wheel = Wheel(10.0f, 5.0f); // 不使用初始化列表，在构造函数中赋值
        m_Wheel.print();
    }

};

class Entity {
    int x;
    int y;
public:
    Entity(int a, int b) : y(b), x(y + a) {} // 这里 x 将先于 y 初始化，可能导致未定义行为
};

int main()
{
    Car1 car1;
    // 避免了二次实例化
    // >> Wheel created!
    // >> 10 * 5
    Car2 car2;
    // 二次实例化！
    // >> Wheel created default!
    // >> Wheel created!
    // >> 10 * 5
}

#include <iostream>

class Entity
{
private:
    const char* m_Name;
public:

    Entity(const char* name)
        : m_Name(name) {}

    ~Entity()
    {
        std::cout << "Entity " << m_Name << " destroyed!" << std::endl;
    }
};

void createEntity()
{
    Entity e1("e1");
}

int main()
{
    createEntity(); // >> Entity e1 destroyed! （函数结束后）

    Entity* e2 = new Entity("e2");
    delete e2; // >> Entity e2 destroyed! 

    std::cin.get();
}

#include <iostream>
#include <string>
#include <memory>

class String {
private:
    char* m_Buffer;
    int m_Size;
public:
    String(const char* string)
    {
        m_Size = strlen(string);
        m_Buffer = new char[m_Size + 1];
        memcpy(m_Buffer, string, m_Size);
        m_Buffer[m_Size] = 0;
    }

    // 实现拷贝构造函数（深拷贝）
    String(const String& other)
        :m_Size(other.m_Size)
    {
        m_Buffer = new char[m_Size + 1];
        memcpy(m_Buffer, other.m_Buffer, m_Size + 1);
    }

    ~String()
    {
        delete[] m_Buffer; // 浅拷贝将导致二次释放内存错误
    }

    char& operator[](unsigned int index)
    {
        return m_Buffer[index];
    }

    friend std::ostream& operator<<(std::ostream& stream, const String& string);
};

std::ostream& operator<<(std::ostream& stream, const String& string)
{
    stream << string.m_Buffer;
    return stream;
}

void printString(const String& string) // 总是使用常量引用来传递对象
{
    // 即使是要创建拷贝，也应该在函数中手动创建
    // Stirn copy = string;
    std::cout << string << std::endl;
}

int main() {
    
    String string = "Hello!";
    String second = string; // 使用拷贝构造函数，也是一种隐式转换

    second[1] = 'a';

    std::cout << string << std::endl; // >> Hello!（浅拷贝将导致 string 也变为 Hallo!）
    std::cout << second << std::endl; // >> Hallo!

    std::cin.get();
    // 程序结束，销毁两个对象时，浅拷贝将导致二次释放内存错误
}

#include <iostream>

class String {
private:
    char* m_Data;
    size_t m_Size;
public:
    // 构造函数
    String(const char* string) {
        printf("Created!\n");
        m_Size = strlen(string);
        m_Data = new char[m_Size];
        memcpy(m_Data, string, m_Size);
    }

    // 移动构造函数
    String(String&& other) noexcept {
        printf("Moved!\n");
        m_Size = other.m_Size;
        m_Data = other.m_Data;
        // 避免 other 销毁时释放数据
        other.m_Size = 0;
        other.m_Data = nullptr;
    }

    // 赋值运算符函数
    String& operator=(String&& other) noexcept {
        printf("Move Assgined!\n");

        // 赋值自己则不执行操作
        if (this != &other) {
            // 释放自己的数据
            delete[] m_Data;
            // 移来 other 中的数据
            m_Size = other.m_Size;
            m_Data = other.m_Data;
            // 避免 other 销毁时释放数据
            other.m_Size = 0;
            other.m_Data = nullptr;
        }

        return  *this;
    }

    ~String() {
        printf("Destroyed!\n");
        delete m_Data;
    }
};

int main() {
    // >> Created!
    // >> Moved!
    String string = "Name is Entity";
    // 右值引用本身是一个左值，因此需要将它转换为右值后，才能触发移动构造函数的隐式类型转换
    String another = std::move(string);
    // 使用赋值运算符函数
    another = "Name is Entity";

    std::cin.get();
};

#include <iostream>

class Base
{
private:
    int m_Value;
public:

    Base()
        : m_Value(0) {}

    Base(int value)
        : m_Value(value) {}

    int getValue()
    {
        return m_Value;
    }

    void basePrint()
    {
        std::cout << "[Base]: Value is " << getValue() << std::endl;
    }

    // 同名函数
    void who()
    {
        std::cout << "Base" << std::endl;
    }
};

class AnotherBase
{
public:
    void where()
    {
        std::cout << "Here" << std::endl;
    }
};

class Derived : public Base, public AnotherBase // 多重继承
{
private:
    int m_Key;
public:
    Derived()
        : m_Key(0) {}

    Derived(int key)
        : m_Key(key) {}

    int getKey()
    {
        return m_Key;
    }

    void derivedPrint()
    {
        // std::cout << "[Derived]: Dict is { " << m_Value << ", " << getKey() << " }" << std::endl; // 直接访问 private 成员，出现不可访问错误
        std::cout << "[Derived]: Dict is { " << getValue() << ", " << getKey() << " }" << std::endl; // 通过 getValue 函数间接访问
    }

    // 同名函数
    void who()
    {
        std::cout << "Derived" << std::endl;
    }
};

int main()
{
    // 多重继承
    Derived derived;
    derived.where(); // >> Here

    // 限定作用域来指定调用子类还是父类的函数
    derived.Derived::who(); // >> Derived
    derived.Base::who(); // >> Base

    // 对象切割问题
    Base derived1 = Derived();
    Base* derived2 = new Derived();

    std::cin.get();
}

#include <iostream>

class Base
{
private:
    int m_Value;
public:

    Base()
        : m_Value(0) {}

    Base(int value)
        : m_Value(value) {}

    int getValue()
    {
        return m_Value;
    }

    // 声明为虚函数，允许重写
    virtual void print()
    {
        std::cout << "[Base]: Value is " << getValue() << std::endl;
    }

    // 声明为虚函数，保证安全
    virtual ~Base() { }
};

class Derived : public Base
{
public:
    // 声明重写，主要是提供代码检查
    void print() override
    {
        std::cout << "[Derived]: Value is " << getValue() << std::endl;
    }
};

int main()
{
    Derived* derived = new Derived();
    derived->print(); // >> [Derived]: Value is 0

    Base* base = new Base();
    base->print(); // >> [Base]: Value is 0

    Base* derivedToo = new Derived();
    derivedToo->print(); // >> [Derived]: Value is 0

    std::cin.get();
}

#include <iostream>

class Base
{
private:
    int m_Value;
public:

    Base()
        : m_Value(0) {}

    Base(int value)
        : m_Value(value) {}

    int getValue()
    {
        return m_Value;
    }

    // 声明为纯虚函数
    virtual void print() = 0;
};

class Derived : public Base
{
public:
    // 重写父类的纯虚函数
    void print() override
    {
        std::cout << "[Derived]: Value is " << getValue() << std::endl;
    }
};

int main()
{
    Derived* derived = new Derived();
    derived->print(); // >> [Derived]: Value is 0

    // Base* base = new Base(); // 无法再实例化

    Base* derivedToo = new Derived();
    derivedToo->print(); // >> [Derived]: Value is 0

    std::cin.get();
}

#include <iostream>

// 类型模板参数 T，即模板参数类型为类型名称（它接受的值是各种类型名称）
template<typename T>
void print(T value)
{
    std::cout << value << std::endl;
}

int main() {
    print<int>(1); // 出现 int 类型的函数调用，模板参数值为 int，编译器将生成一个接收 int 类型参数的 print 函数
    print<const char*>("Hello!"); // const char* 也是如此
    
    // 当编译器可以推断模板参数时，可以省略不写
    print<>(1.0f); 
    print(2l);

    std::cin.get();
}

#include <iostream>

// 编译器自动生成的四个 print 函数的定义
void print(int value)
{
    std::cout << value << std::endl;
}

void print(const char* value)
{
    std::cout << value << std::endl;
}

void print(float value)
{
    std::cout << value << std::endl;
}

void print(long value)
{
    std::cout << value << std::endl;
}

int main() {
    print(1);
    print("Hello!"); 
    print(1.0f); 
    print(2l);

    std::cin.get();
}

#include <iostream>

// 非类型模板参数 N，模板参数类型为 int（它接受的值是 int 常量表达式）
template<int N>
class Array
{
private:
    int m_Array[N];
public:
    int getSize()
    {
        return N;
    }
};

int main() {
    Array<5> array;

    std::cin.get();
}

#include <iostream>

// 编译器生成的类声明
class Array
{
private:
    int m_Array[5];
public:
    int getSize()
    {
        return 5;
    }
};

int main() {
    Array array;

    std::cin.get();
}

#include <iostream>
#include <vector>

class Entity
{
private:
    int _x;
public:

    Entity(int x)
        : _x(x)
    {
        std::cout << "Constructed!" << std::endl;
    }

    Entity(const Entity& other)
        : _x(other._x)
    {
        std::cout << "Copied!" << std::endl;
    }

    ~Entity()
    {
        std::cout << "Destroyed!" << std::endl;
    }
};

int main() {

    std::vector<Entity> vector;
    vector.reserve(10); // 增加容量到 10，避免扩容和复制

    vector.push_back({ 1 }); // >> Constructed! >> Copied! >> Destroyed!
    vector.push_back({ 2 });
    vector.push_back({ 3 });
    vector.push_back({ 4 });
    vector.push_back({ 5 });

    vector.emplace_back(1); // >> Constructed!
    vector.emplace_back(2);
    vector.emplace_back(3);
    vector.emplace_back(4);
    vector.emplace_back(5);

    std::cin.get();
}

#include <iostream>
#include <string>
#include <algorithm>

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

namespace orange {
    void print(const char* message) {
        std::string copy = message;
        std::reverse(copy.begin(), copy.end());
        std::cout << copy << std::endl;
    }
    // 嵌套的命名空间
    namespace correct {
        void print(const char* message) {
            std::cout << message << std::endl;
        }
    }
    // 内联的命名空间中的符号可以直接访问，相当于没有命名空间（雾）
    inline namespace justhello {
        void just_hello() {
            std::cout << "Hello?" << std::endl;
        }
    }
}

int main() {
    apple::print("Apple!");
    orange::print("Orange!");

    // 访问嵌套的命名空间
    orange::correct::print("Orange Correct!");
    // 为命名空间起别名
    namespace orangecrt = orange::correct;
    orangecrt::print("Orangecrt!");

    // 内联的命名空间中的符号可以直接访问，相当于没有命名空间（雾）
    orange::just_hello();

    std::cin.get();
}

#include <iostream>

#define Log(x) std::cout << x << std::endl

// -- 定义静态全局变量，在 Static.cpp 中也定义有同名静态全局变量，不会出现多重定义错误 --
static int staticVar = 11;
// -- 定义非静态全局变量，在 Static.cpp 中也定义有同名非静态全局变量，出现多重定义错误 --
// int commonVar = 33;

// -- 静态全局变量不允许使用 extern 修饰，不能单独声明 --
// -- 声明非静态全局变量，定义在 Static.cpp 中 --
extern int commonVar;

// -- 声明静态函数，定义在 Static.cpp 中 --
static void staticFunction();
// -- 声明非静态函数，同样定义在 Static.cpp 中 --
void commonFunction();

int main()
{
    // -- 表明静态全局变量的定义只对同一个翻译单元的成员可见 --
    // 输出的是 Main.cpp 自己定义的 staticVar，值为 11
    Log(staticVar);
    // 输出的是 Static.cpp 中定义的 commonVar，值为 44
    Log(commonVar);

    // -- 表明静态函数的定义只对同一个翻译单元的成员可见 --
    // 出现未定义错误
    // staticFunction();
    // 正常链接到 Static.cpp 中函数 commonFunction 的定义
    commonFunction();

    std::cin.get();
}