首页手记 C++11新特性资料入门教程

C++11新特性资料入门教程

标签：

C++

概述

本文深入介绍了C++11新特性资料，包括自动类型推导、范围for循环、智能指针、线程支持和Lambda表达式等重要改进。这些新特性极大地增强了语言的安全性、性能和可读性，为现代软件开发提供了坚实的基础。C++11版本的发布标志着C++语言的一个重要转折点，使得编程更加现代化和易于使用。

C++11版本发布概述

C++11是C++标准委员会发布的第一个重大版本，于2011年发布。它引入了许多新特性和改进，极大地增强了语言的现代性和可读性。C++11版本的发布标志着C++语言的一个重要转折点，它为程序开发带来了更多的灵活性和效率。C++11是ISO/IEC 14882:2011标准的正式名称。此版本的目标包括提高语言的安全性、性能和可读性，提供新的编程模式，并引入新的库功能。版本的发布也使得C++语言更加现代化和易于使用，尤其是在面向对象编程和泛型编程方面。

C++11的主要改进方向

C++11版本引入了许多新特性，这些特性主要集中在以下几个方面：

自动类型推导和constexpr：新引入的auto关键字可以自动推断变量类型，而constexpr则允许在编译时计算常量表达式。
范围for循环：新的范围for循环简化了数组和容器的遍历。
智能指针和内存管理：新的智能指针类型如std::unique_ptr和std::shared_ptr增强了内存管理。
线程支持：提供了基本的线程支持和原子操作。
Lambda表达式：新的Lambda表达式提供了更简洁的函数对象定义方法。
新库功能：引入了新的库，如<thread>和<atomic>，增强了多线程和并发编程支持。

这些改进使C++11成为了一种更强大、更易使用的编程语言，为现代软件开发提供了坚实的基础。

自动类型推导与constexpr

auto关键字详解

auto关键字在C++11中被重新定义，用来自动推断变量类型。这使得代码更加简洁且易于维护。auto的关键在于它能够根据初始化表达式的类型来推断变量的类型，从而避免了显式指定类型所带来的繁琐和易错。

以下是auto关键字的一些基本用法：

auto variable1 = 10;            // variable1 的类型是 int
auto variable2 = 10.5;          // variable2 的类型是 double
auto variable3 = "Hello";       // variable3 的类型是 const char*
auto variable4 = true;          // variable4 的类型是 bool

通过使用auto关键字，编译器会根据初始化表达式的类型自动推断变量的类型。这样不仅减少了代码冗余，也降低了错误的概率。

constexpr关键字的应用

constexpr关键字用于声明常量表达式，允许在编译时计算表达式的值，常用于在编译时计算确定的值。constexpr可以应用于变量、返回值以及函数。这种特性使得代码更加高效，因为它允许在编译时完成计算，而不是在运行时。

以下是一些使用constexpr的例子：

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

constexpr int result = add(5, 10);  // result 在编译时计算为 15

constexpr int value = 42;
constexpr int square = value * value;  // square 在编译时计算为 1764

constexpr关键字可以在任何允许常量表达式出现的地方使用，如数组大小、数组初始化等。这种特性使得代码不仅更简洁，也提高了运行效率。

基本的线程操作

C++11引入了线程支持库，使得多线程编程变得更加简单和高效。主要的头文件是<thread>，它提供了基本的线程创建和管理功能。

以下是一个简单的线程创建示例：

#include <iostream>
#include <thread>

void threadFunction() {
    std::cout << "Hello from thread" << std::endl;
}

int main() {
    std::thread t(threadFunction);  // 创建一个线程来执行 threadFunction
    t.join();  // 等待线程结束
    return 0;
}

这段代码创建了一个新线程来执行threadFunction函数，并通过join函数等待该线程完成。

原子类型简介

原子操作是C++11中为了实现线程安全而引入的重要特性之一。<atomic>头文件提供了原子类型，这些类型可以确保操作是原子的，即在多线程环境下不会被中断。

以下是一个使用原子类型的示例：

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

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

void incrementCounter() {
    for (int i = 0; i < 100000; ++i) {
        ++counter;
    }
}

int main() {
    std::thread t1(incrementCounter);
    std::thread t2(incrementCounter);
    t1.join();
    t2.join();
    std::cout << "Final counter value: " << counter.load() << std::endl;
    return 0;
}

在这个例子中，incrementCounter函数在两个线程中分别执行，同时对counter进行递增操作。由于counter是一个原子类型，因此递增操作是原子的，避免了可能出现的数据竞争问题。

范围for循环的新用法

范围for循环的优势

C++11引入了范围for循环，使得遍历数组和容器变得更加简单和直观。这种循环通过迭代器来遍历范围内的每个元素，简化了代码并提高了可读性。

以下是一个使用范围for循环遍历数组的示例：

#include <iostream>

int main() {
    int array[] = {1, 2, 3, 4, 5};
    for (int value : array) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    return 0;
}

这段代码使用范围for循环遍历数组，并将每个元素输出到标准输出。这种方式不仅简洁，而且易于理解。

接下来，使用范围for循环遍历一个std::vector：

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (int value : vec) {
        std::cout << value << " ";
    }
    std::cout << std::endl;
    return 0;
}

这段代码同样使用范围for循环遍历了std::vector中的元素，并输出。这种循环方式更易于理解，特别是在处理容器类型的数据结构时。

智能指针与内存管理

智能指针的使用

C++11引入了多种智能指针类型，包括std::unique_ptr、std::shared_ptr和std::weak_ptr，这些类型提供了更安全和灵活的内存管理方式。

std::unique_ptr

std::unique_ptr是独占所有权的智能指针，它确保指针的所有权只能归一个对象或函数所有。当std::unique_ptr的生命周期结束时，它会自动删除所指向的对象。

以下是一个使用std::unique_ptr的示例：
```
#include <iostream>
#include <memory>

int main() {
   std::unique_ptr<int> p(new int(10));
   std::cout << "Value: " << *p << std::endl;
   return 0;
}
```
在这个例子中，std::unique_ptr自动管理了内存，当p超出作用域时会自动删除所指向的int对象。
std::shared_ptr

std::shared_ptr是一种共享所有权的智能指针，它允许多个智能指针共享同一个对象的所有权。当最后一个std::shared_ptr销毁时，它会释放所指向的资源。

以下是一个使用std::shared_ptr的示例：
```
#include <iostream>
#include <memory>

int main() {
   std::shared_ptr<int> p1(new int(10));
   std::shared_ptr<int> p2 = p1;
   std::cout << "Value: " << *p1 << std::endl;
   return 0;
}
```
在这个例子中，p1和p2共享同一个int对象的所有权。当最后一个std::shared_ptr销毁时，所指向的int对象会被释放。
std::weak_ptr

std::weak_ptr是一种弱指针，它不会影响所指向对象的引用计数。这种指针常用于避免循环引用的问题。

以下是一个使用std::weak_ptr的示例：
```
#include <iostream>
#include <memory>

int main() {
   std::shared_ptr<int> p1(new int(10));
   std::weak_ptr<int> wp(p1);
   if (auto p2 = wp.lock()) {
       std::cout << "Value: " << *p2 << std::endl;
   }
   return 0;
}
```
在这个例子中，std::weak_ptr不会影响p1的引用计数。当p1释放时，std::weak_ptr不会阻止对象被删除。

常见问题与解决办法

内存泄漏

使用智能指针可以避免内存泄漏问题。例如，使用std::shared_ptr可以确保对象的生命周期由引用计数管理，当没有引用计数时，对象将被自动删除。

以下是一个避免内存泄漏的示例：
```
#include <iostream>
#include <memory>

void function() {
   std::shared_ptr<int> p(new int(10));
   // p 的生命周期将由 shared_ptr 管理
}

int main() {
   function();
   return 0;
}
```

循环引用问题

使用std::weak_ptr可以避免循环引用问题。例如，当两个std::shared_ptr互相持有对方的引用时，会导致对象永远不会被释放。使用std::weak_ptr可以打破这种循环引用。

以下是一个解决循环引用问题的示例：

#include <iostream>
#include <memory>

class Example {
public:
   std::shared_ptr<Example> ptr;
   std::weak_ptr<Example> weakPtr;

   Example(std::shared_ptr<Example> p) : ptr(p), weakPtr(p) {}
};

int main() {
   auto p1 = std::make_shared<Example>(nullptr);
   p1->ptr = p1;

   // 使用 weakPtr 避免循环引用
   auto wp = p1->weakPtr;
   if (auto p2 = wp.lock()) {
       std::cout << "WeakPtr is valid" << std::endl;
   }
   return 0;
}

资源所有权问题

使用std::unique_ptr可以确保资源的所有权，避免资源被意外释放。例如，当一个对象不再需要时，使用std::unique_ptr可以确保资源被正确释放。

以下是一个使用std::unique_ptr确保资源所有权的示例：

#include <iostream>
#include <memory>

void useResource(std::unique_ptr<int> p) {
   std::cout << "Using resource: " << *p << std::endl;
}

int main() {
   auto p = std::make_unique<int>(10);
   useResource(p);
   // p 的生命周期结束时，所指向的资源将被自动释放
   return 0;
}

通过使用智能指针，可以有效避免内存泄漏、循环引用和资源所有权问题。

Lambda表达式的定义

Lambda表达式是C++11引入的一种新的语法，它允许在代码中简洁地定义匿名函数。Lambda表达式可以用于各种场景，如函数对象、事件处理、延迟执行等。

Lambda表达式的基本语法如下：

[捕获列表] (参数列表) -> 返回类型 {
    函数体
}

以下是几个使用Lambda表达式的示例：

简单Lambda表达式

以下是一个简单的Lambda表达式，用于计算两个整数的和：

#include <iostream>

int main() {
   auto sum = [](int a, int b) -> int {
       return a + b;
   };

   std::cout << "Sum: " << sum(5, 10) << std::endl;
   return 0;
}

带捕获列表的Lambda表达式

以下是一个带有捕获列表的Lambda表达式，捕获一个变量并在Lambda函数中使用：

#include <iostream>

int main() {
   int x = 10;
   auto lambda = [x]() {
       std::cout << "x: " << x << std::endl;
   };

   lambda();
   return 0;
}

带默认捕获的Lambda表达式

以下是一个使用默认捕获列表的Lambda表达式，捕获所有外部变量：

#include <iostream>

int main() {
   int x = 10;
   int y = 20;
   auto lambda = [&, y]() {
       std::cout << "x: " << x << ", y: " << y << std::endl;
   };

   lambda();
   return 0;
}

Lambda表达式作为函数参数

以下是一个将Lambda表达式作为函数参数传递的示例：

#include <iostream>

void executeLambda(const std::function<int(int, int)>& func) {
   std::cout << "Result: " << func(5, 10) << std::endl;
}

int main() {
   executeLambda([](int a, int b) {
       return a + b;
   });
   return 0;
}

Lambda表达式的应用场景

Lambda表达式在很多场景中都非常有用，如排序、过滤、事件处理等。

排序

以下是一个使用Lambda表达式排序数组的示例：

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

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

   for (int value : vec) {
       std::cout << value << " ";
   }
   std::cout << std::endl;
   return 0;
}

过滤

以下是一个使用Lambda表达式过滤数组的示例：

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

int main() {
   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 value : filtered) {
       std::cout << value << " ";
   }
   std::cout << std::endl;
   return 0;
}

事件处理

以下是一个使用Lambda表达式处理事件的示例：

#include <iostream>

void handleEvent() {
   std::cout << "Event handled" << std::endl;
}

int main() {
   int event = 1;
   auto handler = [event]() {
       if (event == 1) {
           handleEvent();
       }
   };

   handler();
   return 0;
}

通过使用Lambda表达式，可以简单高效地处理各种编程场景，提高代码的可读性和简洁性。

点击查看更多内容

为 TA 点赞

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

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

POPMUISE

手记
篇

粉丝

80

获赞与收藏

425

关注作者，订阅最新文章

阅读免费教程

Android Studio 编辑器教程

40个小节 11962 247

后端通用面试教程

41个小节 31437 350

网络编程入门教程

20个小节 12893 243

推荐

评论

收藏

共同学习，写下你的评论



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

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

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

支付方式

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

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

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

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

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

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

作者：

免费赠送

兑换码：1111222211 复制

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

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

热搜

最近搜索清空