首页手记 C++11 入门教程：轻松掌握新手必学特性

C++11 入门教程：轻松掌握新手必学特性

标签：

C++

概述

本文介绍了C++11版本的新特性和改进，包括自动类型推断、范围for循环、lambda表达式等，这些特性极大地增强了C++语言的灵活性和效率。C++11还新增了多线程支持和标准库扩展，使得编写高质量、高效率的C++代码变得更加容易。文章详细探讨了C++11中的新语法和数据类型，并提供了示例代码来帮助理解。

C++11 入门教程：轻松掌握新手必学特性

C++11 简介

C++11 版本发布背景

C++11 是 ISO C++ 标准委员会于2011年发布的C++语言的最新版本。在此之前，C++ 最新的版本是C++98。C++98自1998年发布以来，已经过去了近13年，计算机硬件和软件环境已经发生了巨大的变化。为了使C++更好地适应新的硬件环境，同时也为了更好地支持软件开发中的现代编程模式，C++11应运而生。C++11引入了许多新的特性，如自动类型推断、范围for循环、lambda表达式等，这些特性不仅提高了代码的可读性和简洁性，还带来了更好的性能和更安全的编程模型。

新特性概览

C++11带来了许多新的特性，其中一些主要的新特性包括：

变量类型推断：提供更简洁的变量声明方式。
范围for循环：简化数组和容器的遍历操作。
右值引用与移动语义：提高资源转移和性能优化的效率。
lambda表达式：支持内联函数定义。
初始化列表：支持更加灵活的初始化方式。
智能指针：管理和释放内存更加方便。
多线程支持：引入了线程管理和异步操作的库。
标准库扩展：增加了许多新的标准库容器和算法。

C++11的这些新特性极大地增强了C++语言的表现力和灵活性，使得编写高质量、高效率和安全的C++代码变得更加容易。

基础语法改进

自动类型推断 `auto`

C++11引入了auto关键字，可以自动推断变量的类型。auto关键字使得变量声明更加简洁和灵活。这种特性可以显著简化代码，特别是在处理复杂的类型时。

示例代码

auto i = 10;               // i 的类型为 int
auto j = 3.14f;           // j 的类型为 float
auto result = i + j;      // result 的类型为 double
auto str = "Hello";       // str 的类型为 const char*

使用auto关键字，可以节省大量的类型声明代码，同时提高代码的可读性。但是，为了确保代码的正确性，谨慎使用auto关键字，特别是在复杂的表达式中。

范围for循环

C++11引入了范围for循环，使得遍历容器或数组变得更加简洁。这个特性极大地简化了代码，提升了代码的可读性和可维护性。

示例代码

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5};
    for (auto& num : numbers) {
        num *= 2;  // 修改每个元素的值
    }

    // 输出修改后的元素值
    for (const auto& num : numbers) {
        std::cout << num << " ";
    }
    std::cout << std::endl;

    return 0;
}

这段代码使用了范围for循环遍历并修改了一个std::vector中的元素。这使得代码更加简洁和易读。

新增的数据类型

原子操作类型 `std::atomic`

C++11引入了std::atomic类型，用于原子操作。原子类型提供了一种机制，使变量操作不可分割，并且可以被多线程安全地访问。这种类型对于并发编程非常重要，可以避免数据竞争和死锁等问题。

示例代码

#include <iostream>
#include <atomic>
#include <thread>

std::atomic<int> counter{0};

void increment_counter() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;
    }
}

int main() {
    std::thread t1(increment_counter);
    std::thread t2(increment_counter);

    t1.join();
    t2.join();

    std::cout << "Counter: " << counter << std::endl;

    return 0;
}

这段代码中，我们创建了一个std::atomic<int>类型的变量counter，并在其上并发地执行了两个线程来递增计数器。由于counter是原子类型的，因此操作是线程安全的，不会出现数据竞争。

标准容器 `std::array` 和 `std::vector`

C++11提供了新的标准库容器std::array和std::vector，这些容器提供了更强大和更安全的内存管理方式。

示例代码

#include <iostream>
#include <array>
#include <vector>

int main() {
    // 使用 std::array
    std::array<int, 5> arr = {1, 2, 3, 4, 5};
    std::cout << "Array size: " << arr.size() << std::endl;
    arr[2] = 10;
    std::cout << "Modified array: ";
    for (const auto& val : arr) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // 使用 std::vector
    std::vector<int> vec = {1, 2, 3, 4, 5};
    std::cout << "Vector size: " << vec.size() << std::endl;
    vec.push_back(6);
    std::cout << "Modified vector: ";
    for (const auto& val : vec) {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

这段代码展示了如何使用std::array和std::vector。std::array是一个固定大小的容器，而std::vector是一个动态大小的容器。两种容器都提供了丰富的接口来操作和管理数据。

函数特性增强

右值引用和移动语义

C++11引入了右值引用（rvalue references）和移动语义（move semantics），可以有效地优化资源管理和数据传递。右值引用允许我们对临时对象进行操作，而移动语义允许我们在不需要复制数据的情况下，将资源从一个对象转移到另一个对象。

示例代码

#include <iostream>
#include <string>
#include <utility>

class Resource {
public:
    Resource() : data(new int(0)) {}
    ~Resource() { delete data; }

    Resource(Resource&& other) noexcept : data(other.data) {
        other.data = nullptr;
    }

    Resource& operator=(Resource&& other) noexcept {
        if (this != &other) {
            delete data;
            data = other.data;
            other.data = nullptr;
        }
        return *this;
    }

private:
    int* data;
};

int main() {
    Resource res;
    Resource res2 = std::move(res);
    Resource res3(std::move(res2));

    return 0;
}

这段代码中，我们定义了一个Resource类，并使用右值引用和移动语义来优化资源的传递。在Resource类的移动构造函数和移动赋值运算符中，我们使用了右值引用other来转移资源，这样可以避免不必要的复制操作。

lambda 表达式

C++11引入了lambda表达式，可以方便地在代码中定义内联函数。lambda表达式提供了一种简洁的方式来处理临时函数，提升代码的灵活性和可读性。

示例代码

#include <iostream>
#include <vector>

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

    // 使用 lambda 表达式过滤偶数
    auto is_even = [](int n) { return n % 2 == 0; };
    for (const auto& num : numbers) {
        if (is_even(num)) {
            std::cout << num << " ";
        }
    }
    std::cout << std::endl;

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

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

    return 0;
}

这段代码中，我们使用lambda表达式定义了一个检查偶数的函数和一个排序函数。这些lambda表达式直接嵌入到代码中，使得代码更加简洁和易读。

并发编程支持

线程管理库 `std::thread`

C++11提供了std::thread类，使得编写多线程程序变得更加简单。std::thread类提供了一系列接口来创建、管理线程，并提供线程间同步的功能。

示例代码

#include <iostream>
#include <thread>

void print_thread_id(int id) {
    std::cout << "Thread " << id << " is running." << std::endl;
}

int main() {
    std::thread t1(print_thread_id, 1);
    std::thread t2(print_thread_id, 2);

    t1.join();
    t2.join();

    return 0;
}

这段代码中，我们使用std::thread类创建了两个线程，并使用join方法等待它们完成。这种方式提供了对线程的清晰控制，使得多线程编程变得更加方便。

异步操作 `std::async`

C++11还引入了std::async函数，用于异步执行任务。std::async可以方便地将任务异步执行，并返回一个std::future对象，通过std::future可以获取任务的执行结果。

示例代码

#include <iostream>
#include <future>
#include <chrono>

int calculate(int a, int b) {
    std::this_thread::sleep_for(std::chrono::seconds(1));  // 模拟耗时计算
    return a + b;
}

int main() {
    auto future_result = std::async(std::launch::async, &calculate, 5, 7);

    // 执行其他任务
    std::cout << "Doing other tasks..." << std::endl;

    // 等待异步任务完成并获取结果
    int result = future_result.get();
    std::cout << "Result: " << result << std::endl;

    return 0;
}

这段代码中，我们使用std::async异步执行了一个计算任务，并通过std::future获取了计算结果。这种方式使得异步编程变得更加简洁和灵活。

C++11 实战演练

综合案例分析

假设我们正在开发一个简单的图像处理应用，该应用需要支持并行处理多张图像。为了提高处理速度，我们可以使用C++11的多线程特性来并行处理这些图像。

示例代码

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

void process_image(const std::string& filename) {
    std::cout << "Processing image: " << filename << std::endl;
    // 模拟耗时操作
    std::this_thread::sleep_for(std::chrono::seconds(1));
}

int main() {
    std::vector<std::string> filenames = {"image1.jpg", "image2.jpg", "image3.jpg"};

    std::vector<std::thread> threads;
    for (const auto& filename : filenames) {
        threads.emplace_back(process_image, filename);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    return 0;
}

这段代码中，我们定义了一个process_image函数来处理图像，并使用一个std::vector来存储图像文件名。我们通过std::thread类创建了多个线程来并行处理这些图像，最后等待所有线程完成。

常见错误及解决办法

在使用C++11的新特性时，可能会遇到一些常见的错误。例如，使用auto关键字时，可能会因为表达式复杂导致类型推断错误；使用std::thread时，可能会因为线程间竞争导致数据不一致等问题。

示例代码

#include <iostream>
#include <thread>
#include <vector>

int counter = 0;

void increment_counter() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;  // 非原子操作，可能导致线程竞争
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Counter: " << counter << std::endl;

    return 0;
}

这段代码中，多个线程同时对同一个全局变量counter进行操作，由于counter不是原子类型，所以可能导致数据竞争。解决这个问题的方法是使用std::atomic<int>来声明counter，从而避免线程间的竞争。

#include <iostream>
#include <thread>
#include <vector>
#include <atomic>

std::atomic<int> counter{0};

void increment_counter() {
    for (int i = 0; i < 1000; ++i) {
        ++counter;  // 使用原子操作避免线程竞争
    }
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 10; ++i) {
        threads.emplace_back(increment_counter);
    }

    for (auto& thread : threads) {
        thread.join();
    }

    std::cout << "Counter: " << counter << std::endl;

    return 0;
}

通过使用std::atomic<int>，我们确保了对counter的操作是原子的，从而避免了线程间的竞争问题。

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

ITMISS

手记
篇

粉丝

51

获赞与收藏

244

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11846 244

后端通用面试教程

41个小节 30583 343

网络编程入门教程

20个小节 12561 237

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

C++11 入门教程：轻松掌握新手必学特性

C++11 版本发布背景

新特性概览

自动类型推断 auto

示例代码

范围for循环

示例代码

原子操作类型 std::atomic

示例代码

标准容器 std::array 和 std::vector

示例代码

右值引用和移动语义

示例代码

lambda 表达式

示例代码

线程管理库 std::thread

示例代码

异步操作 std::async

示例代码

综合案例分析

示例代码

常见错误及解决办法

示例代码

阅读免费教程

自动类型推断 `auto`

原子操作类型 `std::atomic`

标准容器 `std::array` 和 `std::vector`

线程管理库 `std::thread`

异步操作 `std::async`