C++11资料：新手入门教程

C++11 是 C++ 语言的一个重要更新，发布于 2011 年，增加了自动类型推断、范围 for 循环、智能指针等新特性，极大提升了代码的简洁性和效率。本文详细介绍了这些新特性的具体应用和示例代码，帮助读者更好地理解和使用 C++11 资料。

C++11版本发布背景

C++11 是 C++ 语言的一个重要更新，发布于 2011 年。它旨在改进语言的现代化特性，增加新的语法和库功能，从而提高开发效率和代码的可读性。C++11 的发布使得 C++ 语言能够更好地适应现代高性能计算的需求，同时保持了 C++ 语言原有的高效性。

C++11的主要新特性

C++11 引入了许多新的特性，包括自动类型推断、范围 for 循环、新的数字类型、lambda 表达式、智能指针等。这些新特性使得 C++ 代码编写更加简洁和高效，同时增强了 C++ 的现代化特性。

自动类型推断 (auto)

自动类型推断 (auto) 是 C++11 引入的一个重要特性。它允许编译器根据初始化表达式的类型来推断变量的类型。这在处理复杂数据类型时显得尤为重要，可以减少冗长的类型声明，使代码更加简洁。

示例代码

#include <iostream>

int main() {
    auto x = 42;          // x 被推断为 int
    auto y = 3.14f;       // y 被推断为 float
    auto z = "Hello";     // z 被推断为 const char*

    std::cout << x << std::endl;
    std::cout << y << std::endl;
    std::cout << z << std::endl;

    return 0;
}

范围 for 循环

范围 for 循环 (range-based for loop) 是 C++11 引入的另一个重要特性。它允许开发者以更加简洁的方式遍历容器中的元素，无需手动管理迭代器。

示例代码

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    for (auto num : numbers) {
        std::cout << num << std::endl;
    }

    return 0;
}

新的数字类型 (long long, unsigned long long)

C++11 引入了 long long 和 unsigned long long 这两个新的整数类型，用于表示更大的整数值。这对于需要处理大范围整数的应用非常有用。

示例代码

#include <iostream>

int main() {
    long long bigInt = 9223372036854775807LL;
    unsigned long long bigUInt = 18446744073709551615ULL;

    std::cout << "long long: " << bigInt << std::endl;
    std::cout << "unsigned long long: " << bigUInt << std::endl;

    return 0;
}

lambda 表达式

lambda 表达式是 C++11 引入的一种局部匿名函数。它允许在代码中定义一个函数对象，并且可以在需要时传递给其他函数作为参数。lambda 表达式使得代码更加灵活和简洁。

示例代码

#include <iostream>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> numbers = {5, 3, 8, 1, 10};

    // 使用 lambda 表达式对向量进行排序
    std::sort(numbers.begin(), numbers.end(), [](int a, int b) {
        return a < b;
    });

    for (auto num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

unique_ptr

unique_ptr 是 C++11 引入的一种智能指针类型，用于管理动态分配的对象。与普通指针不同，unique_ptr 会在其生命周期结束时自动释放所指向的对象，从而避免了内存泄漏问题。

示例代码

#include <iostream>
#include <memory>

int main() {
    std::unique_ptr<int> ptr(new int(42));

    std::cout << *ptr << std::endl;

    // unique_ptr 被销毁时，会自动释放内存
    // 无需手动 delete
    return 0;
}

shared_ptr

shared_ptr 是另一种智能指针类型，允许多个指针共享同一个动态分配的对象。shared_ptr 使用引用计数机制来管理对象的生命周期，当最后一个 shared_ptr 被销毁时，所指向的对象也会被自动释放。

示例代码

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> ptr1(new int(42));
    std::shared_ptr<int> ptr2 = ptr1;

    std::cout << *ptr1 << std::endl;
    std::cout << *ptr2 << std::endl;

    // 当 ptr1 和 ptr2 都被销毁时，所指向的内存会被释放
    return 0;
}

常用算法与容器介绍

C++11 增加了许多新的算法和容器，增强了标准库的功能。例如，std::for_each、std::transform、std::find_if 等算法可以更方便地处理容器中的数据。

示例代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <numeric>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};

    // 使用 std::for_each 为每个元素加上 10
    std::for_each(numbers.begin(), numbers.end(), [](int& n) {
        n += 10;
    });

    // 使用 std::transform 将向量中的元素平方
    std::transform(numbers.begin(), numbers.end(), numbers.begin(), [](int n) {
        return n * n;
    });

    // 使用 std::accumulate 求和
    int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

    for (auto num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;
    std::cout << "Sum: " << sum << std::endl;

    return 0;
}

异常处理

C++11 对异常处理机制进行了一些改进，使得异常处理更加灵活和强大。例如，新的 noexcept 关键字可以用来声明函数不会抛出异常，这有助于编译器进行更优的优化。

示例代码

#include <iostream>

void safeFunction() noexcept {
    // 假设这是安全的函数，不会抛出异常
    int result = 42;
    std::cout << "Result: " << result << std::endl;
}

void unsafeFunction() {
    throw std::runtime_error("An error occurred");
}

int main() {
    try {
        safeFunction();
    } catch (...) {
        std::cerr << "Caught an exception in safeFunction" << std::endl;
    }

    try {
        unsafeFunction();
    } catch (const std::runtime_error& e) {
        std::cerr << "Caught a runtime_error: " << e.what() << std::endl;
    } catch (...) {
        std::cerr << "Caught an unknown exception" << std::endl;
    }

    return 0;
}

实际应用案例

在实际应用中，C++11 的新特性可以显著提高代码的性能和可读性。例如，使用 std::thread 可以轻松实现多线程编程，而不需要烦琐的线程管理。

示例代码

#include <iostream>
#include <thread>
#include <chrono>

void printHello() {
    std::cout << "Hello from thread " << std::this_thread::get_id() << std::endl;
}

int main() {
    std::thread thread1(printHello);
    std::thread thread2(printHello);

    std::this_thread::sleep_for(std::chrono::seconds(1));

    thread1.join();
    thread2.join();

    return 0;
}

常见错误与调试技巧

在使用 C++11 的新特性时，可能会遇到一些常见的错误和调试问题。例如，使用 auto 类型推断时，如果类型推断不正确，可能会导致编译错误。使用智能指针时，如果引用计数管理不当，也可能造成意外的内存泄漏或崩溃。

示例代码

#include <iostream>
#include <memory>

int main() {
    auto ptr1 = std::make_shared<int>(42);
    auto ptr2 = ptr1;

    // 释放 ptr1 所有权，ptr1 变为 null
    ptr1.reset();

    // 这里会访问一个已释放的指针，会造成崩溃
    if (ptr1) {
        std::cout << *ptr1 << std::endl;
    } else {
        std::cout << "ptr1 is null" << std::endl;
    }

    std::cout << *ptr2 << std::endl;

    return 0;
}

#include <iostream>
#include <cassert>

int main() {
    int x = 10;
    assert(x > 0);  // 断言 x > 0

    int y = -5;
    assert(y > 0);  // 这个断言会失败

    return 0;
}

通过这些示例和代码示范，可以更好地理解 C++11 的新特性和改进，提高代码的性能和可读性。