为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 C++11新特性学习入门教程

C++11新特性学习入门教程

标签：
C++
概述

本文介绍了C++11新特性的学习内容，涵盖了自动类型推断、范围for循环、Lambda表达式、原子类型与多线程支持、智能指针等新特性。C++11新特性不仅使代码更加简洁易读，还提高了程序的运行效率和安全性。这些新特性包括auto关键字、范围for循环、std::unique_ptr和std::shared_ptr等，帮助开发者更好地管理和优化代码。

C++11新特性学习入门教程

1. C++11简介

1.1 C++11的特点与优势

C++11是C++语言的一次重大更新，它引入了许多新特性，增强了语言的表达力和可用性。C++11的主要特点包括：

  • 自动类型推断：通过auto关键字简化变量声明。
  • 新的语法糖：如范围for循环、lambda表达式等，使代码更加简洁和易读。
  • 更好的类型支持：新增了一些内置类型和关键字，如nullptr、constexpr等。
  • 多线程支持：引入了std::thread和原子类型，支持多线程编程。
  • 智能指针：提供了std::unique_ptr和std::shared_ptr，帮助管理动态分配的内存。
  • 泛型编程增强：如decltype关键字、constexpr函数等，提高了模板元编程的灵活性。

这些新特性不仅使代码更简洁易读，而且提高了编译器的优化能力，使得程序运行更加高效。

1.2 C++11相较于早期版本的主要改进

C++11带来了许多改进，使得旧代码可以被重写为更现代的形式。以下是一些主要改进：

  • 语法简化：引入auto关键字可以自动推断变量类型，减少了冗长的类型声明。
  • 内存管理改善：使用智能指针（如std::unique_ptr和std::shared_ptr）来管理动态分配的内存，减少了资源泄露的风险。
  • 多线程支持加强：新增了std::thread和原子类型，使得编写多线程程序变得更加简单和安全。
#include <iostream>

void oldFunction() {
    // 旧的代码风格
    int array[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; ++i) {
        std::cout << array[i] << " ";
    }
    std::cout << std::endl;
}

void newFunction() {
    // 新的代码风格
    int array[] = {1, 2, 3, 4, 5};
    for (int elem : array) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;
}

int main() {
    oldFunction();
    newFunction();
    return 0;
}

2. 自动类型推断

2.1 auto关键字的使用

auto关键字是C++11引入的一个功能强大的特性，它可以自动推断变量的数据类型。auto关键字可以根据变量的初始化表达式自动推断出变量的数据类型。以下是一些使用auto的关键点：

  • 简化变量声明：无需显式指定变量类型，编译器会根据初始化表达式推断类型。
auto x = 10;     // x 的类型是 int
auto y = 3.14;   // y 的类型是 double
auto z = true;   // z 的类型是 bool
  • 简化复杂的类型声明：对于复杂的类型声明，使用auto可以大大简化代码。
std::vector<int> vec = {1, 2, 3, 4, 5};
auto it = vec.begin();   // it 的类型是 std::vector<int>::iterator
2.2 decltype关键字的使用

decltype关键字用于获取表达式的类型。它是auto的一个补充，可以用于获取表达式的类型，而auto只能用于变量声明。以下是一些使用decltype的关键点：

  • 获取表达式的类型：decltype关键字可以获取表达式的类型，而无需先获取表达式的值。
int a = 10;
int b = 20;
decltype(a + b) sum = a + b;  // sum 的类型是 int
  • 处理复杂类型：decltype可以处理更复杂的类型。
std::vector<int> vec = {1, 2, 3};
decltype(vec[0]) val = vec[0];  // val 的类型是 int
2.3 实例与代码解析

以下是一些使用auto和decltype的实例代码，展示了它们的实际用法：

#include <iostream>
#include <vector>

int main() {
    auto x = 10;  // x 的类型是 int
    auto y = 3.14;  // y 的类型是 double
    auto z = true;  // z 的类型是 bool

    std::vector<int> vec = {1, 2, 3, 4, 5};
    auto it = vec.begin();  // it 的类型是 std::vector<int>::iterator

    int a = 10;
    int b = 20;
    decltype(a + b) sum = a + b;  // sum 的类型是 int

    std::vector<int> vec2 = {1, 2, 3};
    decltype(vec2[0]) val = vec2[0];  // val 的类型是 int

    std::cout << "x: " << x << std::endl;
    std::cout << "y: " << y << std::endl;
    std::cout << "z: " << z << std::endl;
    std::cout << "sum: " << sum << std::endl;
    std::cout << "val: " << val << std::endl;

    return 0;
}

3. 范围for循环

3.1 范围for循环的基本语法

范围for循环是C++11引入的一个新特性，它提供了一种更简洁的遍历容器（如数组、向量、列表等）的方法。以下是一些基本语法：

  • 遍历数组：
int arr[] = {1, 2, 3, 4, 5};
for (auto& elem : arr) {
    std::cout << elem << std::endl;
}
  • 遍历向量：
std::vector<int> vec = {1, 2, 3, 4, 5};
for (const auto& elem : vec) {
    std::cout << elem << std::endl;
}
  • 遍历列表：
std::list<int> lst = {1, 2, 3, 4, 5};
for (auto& elem : lst) {
    std::cout << elem << std::endl;
}
3.2 范围for循环的应用场景

范围for循环的应用场景非常广泛，常见于遍历容器中的元素。以下是一些应用场景：

  • 遍历数组进行操作
int arr[] = {1, 2, 3, 4, 5};
for (auto& elem : arr) {
    elem *= 2;  // 将数组中的每个元素翻倍
}
  • 筛选满足条件的元素
std::vector<int> vec = {1, 2, 3, 4, 5};
for (const auto& elem : vec) {
    if (elem % 2 == 0) {
        std::cout << elem << " is even" << std::endl;
    }
}
3.3 示例代码展示

以下是一些使用范围for循环的实际代码示例：

#include <iostream>
#include <vector>
#include <list>

int main() {
    // 遍历数组
    int arr[] = {1, 2, 3, 4, 5};
    for (auto& elem : arr) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 遍历向量
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (const auto& elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 遍历列表
    std::list<int> lst = {1, 2, 3, 4, 5};
    for (auto& elem : lst) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

4. Lambda表达式

4.1 Lambda表达式的定义

Lambda表达式是C++11引入的一个特性，它允许在代码中定义匿名函数。Lambda表达式的定义包括三个部分：

  1. 捕获列表：指定函数体可以访问的变量。
  2. 参数列表：指定函数的参数。
  3. 函数体：指定函数的行为。

以下是一些基本的Lambda表达式定义：

auto lambda1 = []() {
    std::cout << "Hello, World!" << std::endl;
};

auto lambda2 = [](int a, int b) {
    return a + b;
};

auto lambda3 = [x, y]() {
    return x + y;
};
4.2 Lambda表达式的使用场景

Lambda表达式的使用场景非常广泛，常见于需要短期、临时使用的函数定义。以下是一些应用场景：

  • 排序
std::vector<int> vec = {3, 1, 4, 1, 5, 9};
std::sort(vec.begin(), vec.end(), [](int a, int b) {
    return a < b;
});

for (int elem : vec) {
    std::cout << elem << " ";
}
std::cout << std::endl;
  • 过滤
std::vector<int> vec = {1, 2, 3, 4, 5};
std::vector<int> filtered;
std::copy_if(vec.begin(), vec.end(), std::back_inserter(filtered), [](int a) {
    return a % 2 == 0;
});

for (int elem : filtered) {
    std::cout << elem << " ";
}
std::cout << std::endl;
4.3 Lambda表达式的实例分析

以下是一些使用Lambda表达式的实际代码示例：

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

int main() {
    // 定义一个简单的Lambda表达式
    auto lambda1 = []() {
        std::cout << "Hello, World!" << std::endl;
    };
    lambda1();

    // 定义一个带有参数的Lambda表达式
    auto lambda2 = [](int a, int b) {
        return a + b;
    };
    std::cout << "Sum: " << lambda2(1, 2) << std::endl;

    // 定义一个捕获外部变量的Lambda表达式
    int x = 10;
    int y = 20;
    auto lambda3 = [x, y]() {
        return x + y;
    };
    std::cout << "Sum: " << lambda3() << std::endl;

    // 使用Lambda表达式进行排序
    std::vector<int> vec = {3, 1, 4, 1, 5, 9};
    std::sort(vec.begin(), vec.end(), [](int a, int b) {
        return a < b;
    });
    for (int elem : vec) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    // 使用Lambda表达式进行过滤
    std::vector<int> vec2 = {1, 2, 3, 4, 5};
    std::vector<int> filtered;
    std::copy_if(vec2.begin(), vec2.end(), std::back_inserter(filtered), [](int a) {
        return a % 2 == 0;
    });
    for (int elem : filtered) {
        std::cout << elem << " ";
    }
    std::cout << std::endl;

    return 0;
}

5. 原子类型与std::thread

5.1 原子类型的基本概念

原子类型是C++11引入的一种特性，用于实现线程安全的变量操作。原子类型提供了线程安全的读写操作，避免了多线程环境下的数据竞争问题。

原子类型的基本概念包括：

  • atomic<T>：模板类，提供了线程安全的读写操作。
  • atomic_flag：提供简单的线程互斥操作。

以下是一些基本的原子类型示例：

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

std::atomic<int> counter(0);

void increment() {
    for (int i = 0; i < 1000000; ++i) {
        ++counter;
    }
}

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

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

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

    return 0;
}
5.2 std::thread的使用方法

std::thread是C++11引入的多线程支持的一部分，它提供了一种简单的接口来创建和管理线程。以下是使用std::thread的基本步骤：

  1. 创建线程：使用std::thread构造函数创建线程。
  2. 传递参数：可以通过构造函数传递参数给线程。
  3. 等待线程结束：使用join()方法等待线程结束。
  4. 线程局部存储：线程局部存储用于线程独享的数据。

以下是一些基本的std::thread示例：

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

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

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.push_back(std::thread(print_id, i));
    }

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

    return 0;
}
5.3 多线程编程实例

以下是一个使用std::thread和原子类型进行多线程编程的实例：

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

std::atomic<int> counter(0);

void increment(int id) {
    for (int i = 0; i < 100000; ++i) {
        ++counter;
    }
    std::cout << "Thread " << id << " finished" << std::endl;
}

int main() {
    std::vector<std::thread> threads;
    for (int i = 0; i < 5; ++i) {
        threads.push_back(std::thread(increment, i));
    }

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

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

    return 0;
}

6. 智能指针

6.1 std::unique_ptr与std::shared_ptr的使用

智能指针是C++11引入的一种特性，用于自动管理动态分配的内存，避免了内存泄露的问题。以下是两种常用的智能指针：

  • std::unique_ptr：独占所有权的智能指针，不允许复制和共享。
  • std::shared_ptr：共享所有权的智能指针，允许多个指针共享同一对象。

以下是一些基本的std::unique_ptr和std::shared_ptr的使用示例：

#include <iostream>
#include <memory>

void print(const std::shared_ptr<int>& ptr) {
    std::cout << "Value: " << *ptr << std::endl;
}

int main() {
    // 使用 std::unique_ptr
    std::unique_ptr<int> uniq_ptr = std::make_unique<int>(10);
    std::cout << "Value: " << *uniq_ptr << std::endl;

    // 使用 std::shared_ptr
    std::shared_ptr<int> shared_ptr = std::make_shared<int>(20);
    print(shared_ptr);

    return 0;
}
6.2 智能指针的优点与应用场景

智能指针的优点包括：

  • 自动管理内存：避免了手动释放内存可能导致的内存泄露。
  • 避免资源竞争：智能指针可以自动管理对象的生命周期，避免资源竞争问题。

智能指针的应用场景包括：

  • 独占所有权：使用std::unique_ptr管理独占所有权的对象。
  • 共享所有权：使用std::shared_ptr管理共享所有权的对象。
6.3 智能指针的实例解析

以下是一些使用std::unique_ptr和std::shared_ptr的实例代码：

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

void print_unique(const std::unique_ptr<int>& ptr) {
    std::cout << "Value: " << *ptr << std::endl;
}

void print_shared(const std::shared_ptr<int>& ptr) {
    std::cout << "Value: " << *ptr << std::endl;
}

int main() {
    // 使用 std::unique_ptr
    std::unique_ptr<int> uniq_ptr = std::make_unique<int>(10);
    print_unique(uniq_ptr);

    // 使用 std::shared_ptr
    std::shared_ptr<int> shared_ptr = std::make_shared<int>(20);
    print_shared(shared_ptr);

    // 使用 std::shared_ptr 进行共享
    std::shared_ptr<int> shared_ptr1 = std::make_shared<int>(30);
    std::shared_ptr<int> shared_ptr2 = shared_ptr1;

    print_shared(shared_ptr1);
    print_shared(shared_ptr2);

    return 0;
}
点击查看更多内容
发表于 2024.10.25 15:59， 共 45 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

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

评论

作者其他优质文章

正在加载中

芜湖不芜

手记
篇
粉丝
76
获赞与收藏
338

关注作者，订阅最新文章

相关文章推荐

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消