这片土地的旧时光 · 详解 C++98 与新版 C++ 的不同

C++ 是一门历史悠久的语言。从 1983 年 Bjarne Stroustrup 发明它开始，到 1998 年 ISO 正式标准化（C++98），再到如今的 C++23，这门语言经历了翻天覆地的变化。

如果你曾经接触过老派的 C++ 教材，或者维护过年代久远的代码库，可能会发现它们与现代 C++ 有着天壤之别。让我们来看看，这片土地上发生过怎样的沧桑巨变。

---

内存管理的进化

在 C++98 时代，动态内存管理是一场噩梦：

// C++98 风格：手动管理内存
class OldStyle
{
    int* data;
public:
    OldStyle() : data(new int[100]) {}
    ~OldStyle() { delete[] data; }
    
    // 必须手动实现拷贝构造和赋值，否则会 double free！
    OldStyle(const OldStyle& other) : data(new int[100])
    {
        for (int i = 0; i < 100; ++i)
            data[i] = other.data[i];
    }
    
    OldStyle& operator=(const OldStyle& other)
    {
        if (this != &other)
        {
            delete[] data;
            data = new int[100];
            for (int i = 0; i < 100; ++i)
                data[i] = other.data[i];
        }
        return *this;
    }
};

现代 C++ 使用智能指针，一切变得简单：

// C++11 及以后：智能指针自动管理
#include <memory>
#include <array>

class ModernStyle
{
    std::unique_ptr<std::array<int, 100>> data;
public:
    ModernStyle() : data(std::make_unique<std::array<int, 100>>()) {}
    // 不需要析构函数、拷贝构造、赋值运算符！
    // 编译器自动生成正确的版本
};

---

auto_ptr 的消亡

C++98 有一个叫 auto_ptr 的智能指针，但它有严重的设计缺陷：

// C++98：auto_ptr 的陷阱
void oldDanger()
{
    std::auto_ptr<int> p1(new int(42));
    std::auto_ptr<int> p2 = p1;  // p1 变成 null！
    
    // 使用 p1 将导致未定义行为
    // *p1 = 10;  // 崩溃！
}

C++11 废弃了 auto_ptr，引入了语义清晰的智能指针家族：

// C++11：现代智能指针
void modernSafety()
{
    // unique_ptr：独占所有权，不能复制
    std::unique_ptr<int> u1 = std::make_unique<int>(42);
    // std::unique_ptr<int> u2 = u1;  // 编译错误！
    std::unique_ptr<int> u2 = std::move(u1);  // 显式转移
    
    // shared_ptr：共享所有权
    std::shared_ptr<int> s1 = std::make_shared<int>(42);
    std::shared_ptr<int> s2 = s1;  // 引用计数 +1
}

---

类型推断的革命

C++98 要求显式写出所有类型：

// C++98：冗长的类型声明
std::map<std::string, std::vector<int> >::const_iterator it = myMap.begin();
// 注意 >> 之间必须有空格，否则会被解析为右移运算符！

C++11 引入 auto 关键字，代码变得简洁：

// C++11：让编译器推断类型
auto it = myMap.begin();  // 自动推断迭代器类型
auto value = 42;          // int
auto name = "hello"s;     // std::string (C++14 字面量后缀)

// C++14：泛型 lambda
auto add = [](auto a, auto b) { return a + b; };

---

初始化的统一

C++98 的初始化方式混乱不堪：

// C++98：多种初始化语法
int a = 5;           // 拷贝初始化
int b(5);            // 直接初始化
int arr[] = {1, 2};  // 聚合初始化
std::vector<int> v;  // 默认初始化
v.push_back(1);      // 必须逐个添加
v.push_back(2);

C++11 统一使用花括号初始化：

// C++11：统一初始化
int a{5};
int b = {5};
int arr[]{1, 2, 3};
std::vector<int> v{1, 2, 3, 4, 5};  // 初始化列表！
std::map<std::string, int> m{{"one", 1}, {"two", 2}};

---

范围 for 循环

遍历容器在 C++98 中很繁琐：

// C++98：传统 for 循环
std::vector<int> v;
for (std::vector<int>::iterator it = v.begin(); it != v.end(); ++it)
{
    std::cout << *it << std::endl;
}

C++11 的范围 for 循环简洁明了：

// C++11：范围 for
std::vector<int> v{1, 2, 3, 4, 5};
for (int x : v)
{
    std::cout << x << std::endl;
}

// 引用方式遍历
for (auto& x : v)
{
    x *= 2;  // 修改原值
}

---

nullptr 的引入

C++98 使用 NULL 或 0 表示空指针，这会导致重载歧义：

// C++98：NULL 的问题
void foo(int n);
void foo(char* p);

foo(NULL);  // 调用哪个？取决于 NULL 的定义！

C++11 引入类型安全的 nullptr：

// C++11：nullptr
void foo(int n);
void foo(char* p);

foo(nullptr);  // 明确调用 foo(char*)
foo(0);        // 调用 foo(int)

---

移动语义的诞生

C++98 没有移动语义，复制临时对象非常低效：

// C++98：不必要的复制
std::vector<int> createVector()
{
    std::vector<int> v;
    for (int i = 0; i < 10000; ++i)
        v.push_back(i);
    return v;  // 可能产生深拷贝
}

std::vector<int> result = createVector();  // 又一次复制

C++11 的移动语义避免了不必要的复制：

// C++11：移动语义
std::vector<int> createVector()
{
    std::vector<int> v;
    for (int i = 0; i < 10000; ++i)
        v.push_back(i);
    return v;  // 移动，不是复制！
}

// 显式移动
std::vector<int> v1{1, 2, 3};
std::vector<int> v2 = std::move(v1);  // v1 的资源转移给 v2

---

Lambda 表达式

C++98 需要为每个简单操作定义函数对象：

// C++98：繁琐的函数对象
struct IsEven
{
    bool operator()(int n) const
    {
        return n % 2 == 0;
    }
};

std::vector<int> v;
// ... 填充 v ...
std::count_if(v.begin(), v.end(), IsEven());

C++11 的 lambda 让一切变得简单：

// C++11：lambda 表达式
std::vector<int> v{1, 2, 3, 4, 5, 6};
auto count = std::count_if(v.begin(), v.end(), 
    [](int n) { return n % 2 == 0; });

---

constexpr：编译期计算

C++98 的编译期计算只能通过模板元编程：

// C++98：模板元编程计算阶乘
template<int N>
struct Factorial
{
    enum { value = N * Factorial<N-1>::value };
};

template<>
struct Factorial<0>
{
    enum { value = 1 };
};

int result = Factorial<5>::value;  // 120

C++11/14 的 constexpr 让编译期计算变得自然：

// C++11/14：constexpr 函数
constexpr int factorial(int n)
{
    return n <= 1 ? 1 : n * factorial(n - 1);
}

constexpr int result = factorial(5);  // 编译期计算为 120

// C++14：更复杂的 constexpr
constexpr int fibonacci(int n)
{
    if (n <= 1) return n;
    int a = 0, b = 1;
    for (int i = 2; i <= n; ++i)
    {
        int c = a + b;
        a = b;
        b = c;
    }
    return b;
}

---

变参模板

C++98 处理可变数量参数非常困难：

// C++98：需要为每种参数数量写重载
template<typename T1>
void print(T1 a1) { std::cout << a1; }

template<typename T1, typename T2>
void print(T1 a1, T2 a2) { std::cout << a1 << a2; }

// 需要写很多重载...

C++11 的变参模板优雅地解决了这个问题：

// C++11：变参模板
template<typename... Args>
void print(Args... args)
{
    (std::cout << ... << args) << std::endl;  // C++17 折叠表达式
}

print(1, " ", 2.5, " ", "hello");  // 输出：1 2.5 hello

---

总结：旧时光与新纪元

特性	C++98	现代 C++
内存管理	new/delete 手动管理	智能指针自动管理
类型声明	完全手写	auto 自动推断
空指针	NULL 或 0	nullptr
初始化	多种语法	统一的 {} 语法
循环	迭代器	范围 for
函数对象	手写类	lambda 表达式
编译期计算	模板元编程	constexpr
移动语义	无	右值引用

现代 C++ 不仅仅是语法上的改进，更是编程理念的革新。它让 C++ 从一门"专家语言"变成了一门更加安全、高效、易用的语言。

如果你还在使用 C++98 风格编程，是时候拥抱现代 C++ 了！