c++11新特性随笔

1.统一初始化特性

c98中不支持花括号进行初始化，编译时会报错，在11当中初始化可以通过{}括号进行统一初始化。

c98编译报错

c++11: 

#include <iostream>
#include <set>
#include <string>
#include <vector>int main()
{std::string str = {"111"};std::vector<std::string> vec = {"aaa","bbb","cc"};std::cout<<"str = "<<str.c_str()<<std::endl;for(auto it : vec){std::cout<<"it = "<<it.c_str()<<std::endl;}return 0;
}

输出：

root@ubuntu:~/mySpace/other/ERT# ./a.out 
str = 111
it = aaa
it = bbb
it = cc
root@ubuntu:~/mySpace/other/ERT#

2.关键提auto自动推导变量类型

#include <iostream>
#include <set>
#include <string>
#include <vector>
#include <map>int main()
{std::vector<std::string> vec = {"aaa","bbb","cc"};//// 直接根据实际情况推导相关变量类型for(auto it : vec){std::cout<<"it = "<<it.c_str()<<std::endl;}std::map<std::string,std::string> m = {{"11","111"},{"33","333"}};for(auto &it : m){std::cout<<"first = "<<it.first.c_str()<<" "<<"second = "<<it.second.c_str()<<std::endl;}for(auto it = m.begin();it !=m.end();++it){std::cout<<"first = "<<it->first.c_str()<<" "<<"second = "<<it->second.c_str()<<std::endl;}//c++17.c++11不支持该属性// for (const auto& [key, value] : myMap) {//     std::cout << "Key: " << key << ", Value: " << value << std::endl;// }return 0;
}

 输出：

root@ubuntu:~/mySpace/other/ERT# ./a.out 
it = aaa
it = bbb
it = cc
first = 11 second = 111
first = 33 second = 333
first = 11 second = 111
first = 33 second = 333
root@ubuntu:~/mySpace/other/ERT#

3.Lambda表达式

        定义匿名函数对象，常用于简化代码，尤其是在需要传递函数作为参数的场景。在编译器编译过程中会将lambda表达式转化成一个匿名类，并且这个匿名类重载了operator()运算符，使得可以像函数一样被调用(类的仿制函数一样)。

        lamda表达式函数会自动推倒返回值无需编写,带返回值的写法，如下:

语法结构表达：

    // lamda表达式函数会自动推到返回值无需编写,带返回值的写法auto pFunRet = []() -> std::string {std::string s("rrrrr");return s;}; std::cout<<"pFunRet() = "<<pFunRet().c_str()<<std::endl;

a.无参表达

 // 无参Lamda函数表达式auto pFun = [](){std::cout<<"This is lamda fun"<<std::endl;};pFun();

输出：

root@ubuntu:~/mySpace/other/ERT# ./a.out 
This is lamda fun
root@ubuntu:~/mySpace/other/ERT#

如上表示无参数表达式，编译器会将上述函数转化成一个匿名累，如下,将函数转化成匿名类，直接像函数一样调用即可。

class __lambda_anonymous {
public:int operator()() const { std::cout<<"This is lamda fun"<<std::endl; }
};

b.有参数表达

   // 带参数auto pFunParams = [](int a,std::string s){std::cout<<"Params lamda="<<a<<"-"<<s.c_str()<<std::endl;};pFunParams(100,"LX");

输出:   

root@ubuntu:~/mySpace/other/ERT# ./a.out 
Params lamda=100-LX
root@ubuntu:~/mySpace/other/ERT#

 转化匿名类形式：

class __lambda_anonymous {
public:int operator()(int a,std::string s) const { std::cout<<"Params lamda="<<a<<"-"<<s.c_str()<<std::endl; }
};

c.值捕获

        (值捕获,捕获作用域所有值,=可以替换成某个具体的值,表示单个变量捕获)

  // 值捕获,捕获作用域所有值,=可以替换成某个具体的值,表示单个变量捕获int val_0 = 1;int val_2 = 2;auto pFunValue = [=](){// 值捕获都是只读权限,强行改变会编译报错,提醒read-only 'val_0'// val_0 += 1;// val_2 += 2;std::cout<<"val_0="<<val_0<<" val_2="<<val_2<<std::endl;};pFunValue();

输出: 

root@ubuntu:~/mySpace/other/ERT# ./a.out 
val_0=1 val_2=2
root@ubuntu:~/mySpace/other/ERT#

  编译器转化：

class __lambda_anonymous {
private:int val_0 = 1;int val_2 = 2;
public:__lambda_anonymous(int val_0,int val_2) : val_0(val_0),val_2(val_0) {}  // 构造函数int operator()() const { std::cout<<"val_0="<<val_0<<" val_2="<<val_2<<std::endl;; }
};

d.mutble关键字

        通过该关键字修饰等价于函数内部做了一份拷贝,之后再对拷贝进行操作,故而可以修改其捕获value2, 

   // 值捕获2int value2 = 100;std::cout<<"before modify value2="<<value2<<std::endl;auto pFunValue2 = [value2]() mutable { // mutable 修饰等价于函数内部做了一份拷贝,之后再对拷贝进行操作,故而可以修改其捕获value2,如下输出结果展示:// before modify value2=100// value2=211// after modify value2=100value2 += 111;std::cout<<"value2="<<value2<<std::endl;};pFunValue2();std::cout<<"after modify value2="<<value2<<std::endl;

输出:

root@ubuntu:~/mySpace/other/ERT# ./a.out 
before modify value2=100
value2=211
after modify value2=100
root@ubuntu:~/mySpace/other/ERT#

编译器匿名类：

class __lambda_unnamed {int value2 ;
public:__lambda_unnamed(int value2 ) : value2 (value2 ) {}int operator()(int value2) {  // 注意：不再是constvalue2 += 111;std::cout<<"value2="<<value2<<std::endl;}
};

e.引用捕获

        引用修改的是捕获的变量的本身,如下:

  // 引用捕获int quote = 100;std::cout<<"before modify quote="<<quote<<std::endl;auto pFunQuote = [&quote](){quote += 20; // 引用修改的是捕获的变量的本身,如下输出结果://before modify quote=100//quote=120//after modify quote=120std::cout<<"quote="<<quote<<std::endl;};pFunQuote();std::cout<<"after modify quote="<<quote<<std::endl;return 0;

输出:   

root@ubuntu:~/mySpace/other/ERT# ./a.out 
before modify value2=100
value2=211
after modify value2=100
root@ubuntu:~/mySpace/other/ERT#

 编译器转换：

class __lambda_anonymous {
private:int quote;  // 值捕获的成员变量
public:__lambda_anonymous(int quote) : quote(quote) {}  // 构造函数int operator()(int quote) const { quote += 1;std::cout<<"quote="<<quote<<std::endl;; }
};

4.并发编程

   a.创建线程：

#include <iostream>
#include <thread>void hello() {std::cout << "Hello from thread!\n";
}int main() {std::thread t(hello);  // 创建线程并启动t.join();              // 等待线程结束// 分离线程，线程结束后自动释放资源// 注意：分离后不能再join()// t.detach();  return 0;
}

   b.带参数线程处理函数

#include <iostream>
#include <thread>
void print(int id, const std::string& name) {std::cout << "ID: " << id << ", Name: " << name << "\n";
}int main() {std::thread t(print, 1, "Thread1");t.join();return 0;
}输出:
root@ubuntu:~/mySpace/other/ERT# ./a.out 
ID: 1, Name: Thread1
root@ubuntu:~/mySpace/other/ERT#

   c.参数引用传递

#include <iostream>
#include <thread>
void modify(int& x) { x *= 2; 
}int main() {int x = 10;std::thread t(modify, std::ref(x));t.join();std::cout << x <<std::endl;  // 输出20return 0;
}输出:
root@ubuntu:~/mySpace/other/ERT# ./a.out 
20
root@ubuntu:~/mySpace/other/ERT#

   d.线程id和当前线程

#include <iostream>
#include <thread>int main() {std::thread::id main_thread_id = std::this_thread::get_id(); // 当前线程std::thread t([&]() {if (std::this_thread::get_id() == main_thread_id) {std::cout << "This is the master thread\n";} else {std::cout << "This is a son thread\n";}});t.join();return 0;
}输出:
root@ubuntu:~/mySpace/other/ERT# ./a.out 
This is a son thread
root@ubuntu:~/mySpace/other/ERT#

e.互斥锁 

#include <iostream>
#include <thread>
#include <mutex>std::mutex mtx;
int shared_data = 0;void increment() {mtx.lock();std::thread::id current_id = std::this_thread::get_id();std::cout<<"current id = "<<current_id<<std::endl;++shared_data;mtx.unlock();
}// 更安全的方式：使用RAII锁
void safe_increment() {// 离开作用域时自动解锁std::lock_guard<std::mutex> lock(mtx);++shared_data;
}int main() {std::thread::id main_thread_id = std::this_thread::get_id(); // 当前线程std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();std::cout<<"shared_date ="<<shared_data<<std::endl;return 0;
}输出：
root@ubuntu:~/mySpace/other/ERT# ./a.out 
current id = 140137569199872
current id = 140137560807168
shared_date =2
root@ubuntu:~/mySpace/other/ERT#

f.原子操作

#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>std::atomic<int> counter(0);void increment() {for (int i = 0; i < 1000; ++i) {++counter;  // 原子操作，无需额外同步}
}int main() {std::thread t1(increment);std::thread t2(increment);t1.join();t2.join();std::cout << counter<<std::endl;  // 总是2000return 0;
}输出:
root@ubuntu:~/mySpace/other/ERT# ./a.out 
2000
root@ubuntu:~/mySpace/other/ERT#

g.异步操作

        字段(Future/Promise/Async) std::future、std::promise 和 std::async 来简化异步编程，它们共同构成了 C++ 的 并发编程模型，用于处理多线程任务和异步操作

std::async 简化异步任务的启动

#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <future>int compute() {// 模拟耗时计算std::this_thread::sleep_for(std::chrono::seconds(1));return 42;
}void fun(){std::cout<<"This fun"<<std::endl;
}
int main() {std::future<int> result = std::async(std::launch::async, compute);// 可以做其他工作创建一个线程运行std::thread t(fun);t.join();std::cout << "Result: " << result.get() << "\n";  // 阻塞直到结果就绪return 0;
}输出:
root@ubuntu:~/mySpace/other/ERT# ./a.out 
This fun
Result: 42
root@ubuntu:~/mySpace/other/ERT#

 std::future: 用于获取异步计算的结果（阻塞等待)-未来值

  • 功能：表示一个 异步计算的结果（可能在另一个线程中计算）。

  • 特点：

    • 通过 get() 获取结果（如果结果未就绪，会阻塞当前线程直到计算完成）。

    • 只能获取一次结果（第二次调用 get() 抛出异常）。

    • 通过 wait() 等待结果就绪（不获取值）。

  • 适用场景：获取异步任务（如 std::async 或 std::promise）的返回值 

        案例：

#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <future>int compute() {std::this_thread::sleep_for(std::chrono::seconds(2));std::cout << "during: " << 2 << std::endl;return 42;  // 模拟耗时计算
}int main() {std::future<int> fut = std::async(std::launch::async, compute);// 异步启动一个任务std::cout << "Waiting for result..." << std::endl;int result = fut.get();  // 阻塞直到 compute() 完成std::cout << "Result: " << result << std::endl;return 0;
}输出:
root@ubuntu:~/mySpace/other/ERT# ./a.out 
Waiting for result...
during: 2
Result: 42
root@ubuntu:~/mySpace/other/ERT#

 std::promise: 用于线程间传递数据（生产者-消费者模式）

  • 功能：用于 在线程间传递数据，允许一个线程设置值，另一个线程通过 std::future 获取该值。

  • 特点：

    • promise.set_value() 设置值，并通知 future 可以获取。

    • 如果 promise 被销毁但未设置值，future.get() 会抛出 std::future_error。

  • 适用场景：线程间通信，特别是当一个线程需要等待另一个线程的计算结果时。

案例:

        

#include <iostream>
#include <thread>
#include <mutex>
#include <atomic>
#include <future>void compute(std::promise<int> prom) {prom.set_value(42);  // 设置值
}int main() {// 创建promise对象std::promise<int> prom;// 通过future获取值std::future<int> fut = prom.get_future(); // 通过移动给prom赋值std::thread t(compute, std::move(prom));  // 传递 promise// 阻塞直到 compute() 设置值int result = fut.get();  std::cout << "Result: " << result << std::endl;t.join();return 0;
}输出:
root@ubuntu:~/mySpace/other/ERT# ./a.out 
Result: 42
root@ubuntu:~/mySpace/other/ERT#

8. 线程局部存储 

        a.局部全局变量

        thread_local int tls_var = 0;   每个线程都有自己的 tls_var

#include <iostream>
#include <thread>// 每个线程都有自己的 tls_var,跟linux系统中__thread关键类似，多线程中，每个线程都独有一份全局变量。
thread_local int tls_var = 0;  void increment() {tls_var++;  // 修改的是当前线程的副本std::cout << "Thread " << std::this_thread::get_id() << ": tls_var = " << tls_var << std::endl;
}int main() {std::thread t1(increment);  // t1 的 tls_var 初始为 0，执行后变为 1std::thread t2(increment);  // t2 的 tls_var 初始为 0，执行后变为 1t1.join();t2.join();return 0;
}

        b.类的静态线程局部变量

        

#include <iostream>
#include <thread>class Counter {
public:// 每个线程有自己的 countstatic thread_local int count;  void increment() {count++;std::cout << "Thread " << std::this_thread::get_id() << ": count = " << count << std::endl;}
};// 静态成员类外初始化
thread_local int Counter::count = 0;  int main() {Counter c;// t1 的 count 初始 0 → 1std::thread t1([&c]() {c.increment(); });  // t2 的 count 初始 0 → 1std::thread t2([&c]() { c.increment(); }); t1.join();t2.join();return 0;
}输出:每个线程都独享一份变量count
root@ubuntu:~/mySpace/other/ERT# ./a.out 
Thread 140491193476864: count = 1
Thread 140491185084160: count = 1
root@ubuntu:~/mySpace/other/ERT#

以上就是c++11新特性总结笔记，可能还未完全，后续继续完善！欢迎学习指点！共同进步！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/diannao/80514.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

Spark-Streaming简介 核心编程

Spark-Streaming简介 核心编程

1. Spark-Streaming概述 定义&#xff1a;用于处理流式数据&#xff0c;支持多种数据输入源&#xff0c;可运用Spark原语运算&#xff0c;结果能保存于多处。它以离散化流&#xff08;DStream&#xff09;为抽象表示&#xff0c;是RDD在实时数据处理场景的封装。 特点&#x…
阅读更多...
SpringbootWeb开发（注解和依赖配置）

SpringbootWeb开发（注解和依赖配置）

Lombok 工具 Spring Web web开发相关依赖 MyBatis Framework MyBatis驱动 MySQL Driver MySql驱动包 Restful 风格 Slf4j 记录日志对象 RequestMapping(value “/depts”, method RequestMethod.GET) //指定请求方式为GET method 指定请求方式 GetMapping 限定请求方式为Get…
阅读更多...
杂项知识点

杂项知识点

杂项 1 激活函数1.1 sigmoid1.2 tanh1.3 Relu1.4 leakRelu 1 激活函数 常用的激活函数包括sigmoid tanh Relu leakRelu 1.1 sigmoid import torch import numpy as np import matplotlib.pyplot as plt # sigmoid tanh Relu leakRelu ## 1 sigmoid ### 1.1 代码复现sig…
阅读更多...
计算机组成原理:指令系统

计算机组成原理:指令系统

计算机组成原理：指令集系统 指令集体系结构(ISA)ISA定义ISA包含的内容举个栗子指令的基本组成(操作码+地址码)指令分类：地址码的个数定长操作码变长操作码变长操作码的原则变长操作码的设计指令寻址寻址方式的目的寻址方式分类有效地址直接在指令中给出有效地址间接给出有效地…
阅读更多...
Rust实现高性能目录扫描工具ll的技术解析

Rust实现高性能目录扫描工具ll的技术解析

Rust实现高性能目录扫描工具ll的技术解析 一、项目概述 本项目使用Rust构建了一个类ls命令行工具&#xff0c;具备以下核心特性&#xff1a; 多格式文件信息展示并行目录扫描加速人类可读文件大小运行时性能统计交互式进度提示 二、技术架构 1. 关键技术栈 clap&#xff…
阅读更多...
【深度强化学习 DRL 快速实践】策略梯度算法 (PG)

【深度强化学习 DRL 快速实践】策略梯度算法 (PG)

PG&#xff08;1984&#xff0c;Sutton&#xff09; 核心改进点 策略梯度算法 (PG): 直接对策略函数进行建模&#xff0c;可以适用于连续的动作空间 model-free, on-policy, PG, stochastic 策略 核心改进点说明策略梯度优化通过Actor网络直接优化策略&#xff0c;适应连续动作…
阅读更多...
G1垃圾回收器中YoungGC和MixedGC的区别

G1垃圾回收器中YoungGC和MixedGC的区别

在 G1 垃圾回收器中&#xff0c;Mixed GC 和 Young GC 的区别主要体现在以下几个方面&#xff1a; 作用范围 Young GC&#xff1a;仅针对年轻代中的Region进行回收&#xff0c;包括 Eden 区和 Survivor 区的 Region。Mixed GC&#xff1a;会回收所有年轻代的 Region 以及部分…
阅读更多...
从LLM到AI Agent的技术演进路径：架构解析与实现逻辑

从LLM到AI Agent的技术演进路径：架构解析与实现逻辑

人工智能技术正经历从基础语言模型到智能执行体的关键跃迁。解析LLM→RAG→Agent的技术演进三层架构&#xff0c;拆解大模型与知识库、工具链的融合机理&#xff0c;揭示感知-决策-执行闭环系统的构建逻辑。通过架构范式解析、代码实现示例及多模态实践案例&#xff0c;为开发者…
阅读更多...
commix

commix

Commix 基础用法和高级用法 基础用法 Commix 是一个自动化的命令行注入工具&#xff0c;用于检测和利用 Web 应用程序中的命令注入漏洞。以下是基本使用方法&#xff1a; 基本扫描 python commix.py -u "http://example.com/vuln.php?id1"指定注入点 python commi…
阅读更多...
Git删除指定历史版本

Git删除指定历史版本

问题&#xff1a; 在Git提交版本&#xff0c;有时有些小版本相比较于后续的大版本&#xff0c;都会包含&#xff0c;且后续存在的意义不太大&#xff0c;一般认为是可以删除的。或者&#xff0c;中间一些版本有问题但是也提交了&#xff0c;拉取这些版本根本没用&#xff0c;这…
阅读更多...
使用 Pandas 进行多格式数据整合：从 Excel、JSON 到 HTML 的处理实战

使用 Pandas 进行多格式数据整合：从 Excel、JSON 到 HTML 的处理实战

前言 在数据处理与分析的实际场景中&#xff0c;我们经常需要整合不同格式的数据&#xff0c;例如 Excel 表格、JSON 配置文件、HTML 报表等。本文以一个具体任务&#xff08;蓝桥杯模拟练习题&#xff09;为例&#xff0c;详细讲解如何使用 Python 的 Pandas 库结合其他工具&…
阅读更多...
今日行情明日机会——20250425

今日行情明日机会——20250425

指数依然在震荡&#xff0c;等待方向选择&#xff0c;整体量能不搞但个股红多绿少。 2025年4月25日涨停板行业方向分析如下&#xff1a; 一、核心行业方向及驱动逻辑 一季报增长&#xff08;17家涨停&#xff09; 核心个股&#xff1a;惠而浦、鸿博股份、卫星化学驱动逻辑&am…
阅读更多...
Python 快速获取Excel工作表名称

Python 快速获取Excel工作表名称

文章目录 前言准备工作Python 获取Excel中所有工作表的名称Python 获取Excel中隐藏工作表的名称 前言 在数据分析与办公自动化领域&#xff0c;通过Python处理Excel文件已成为必备技能。通过获取工作表名称&#xff0c;我们可以&#xff1a; 快速了解文件结构自动化处理多工作…
阅读更多...
宁德时代25年时代长安动力电池社招入职测评SHL题库Verify测评语言理解数字推理真题

宁德时代25年时代长安动力电池社招入职测评SHL题库Verify测评语言理解数字推理真题

测试分为语言和数字两部分&#xff0c;测试时间各为17分钟&#xff0c;测试正式开始后不能中断或暂停
阅读更多...
ECMAScript 1（ES1）:JavaScript 的开端

ECMAScript 1（ES1）:JavaScript 的开端

1. 版本背景与发布 ●发布时间&#xff1a;1997 年 6 月&#xff0c;由 ECMA International 正式发布&#xff0c;标准编号为 ECMA-262。 ●历史意义&#xff1a;ES1 是 JavaScript 的首个标准化版本&#xff0c;结束了 Netscape Navigator 与 Internet Explorer 浏览器间脚本语…
阅读更多...
C语言面试高频题——define 和typedef 的区别？

C语言面试高频题——define 和typedef 的区别？

1. 基本概念 (1) #define 定义&#xff1a;#define 是预处理指令&#xff0c;用于定义宏。作用&#xff1a;在编译之前进行文本替换。语法&#xff1a;#define 宏名 替换内容示例&#xff1a;#define PI 3.14159 #define SQUARE(x) ((x) * (x))(2) typedef 定义&#xff1a;…
阅读更多...
【自然语言处理与大模型】模型压缩技术之蒸馏

【自然语言处理与大模型】模型压缩技术之蒸馏

知识蒸馏是一种模型压缩技术&#xff0c;主要用于将大型模型&#xff08;教师模型&#xff09;的知识转移到更小的模型&#xff08;学生模型&#xff09;中。在大语言模型领域&#xff0c;这一技术特别重要。 知识蒸馏的核心思想是利用教师模型的输出作为软标签&#xff08;sof…
阅读更多...
PHP CURL发送POST请求（支持HEADER参数配置）

PHP CURL发送POST请求（支持HEADER参数配置）

/** POST请求（raw数据请求，支持HEADER参数配置） * @param $url * @param $datas 支持数组或字符串 * # $CURLOPT_HTTPHEADER = [ X-AjaxPro-Method:ShowList, Content-Type: application/json; charset=utf-8, Content-Length: . strlen($data_string)]; …
阅读更多...
利用JMeter代理服务器方式实现高效压测

利用JMeter代理服务器方式实现高效压测

前言 在当今快节奏的互联网时代&#xff0c;确保Web应用和服务能够在高负载下稳定运行变得至关重要。无论是电子商务平台、社交媒体网络还是在线教育服务&#xff0c;用户对网站响应速度和稳定性的期望从未如此之高。因此&#xff0c;性能测试不再是一个可选项&#xff0c;而是…
阅读更多...
【JavaWeb后端开发04】java操作数据库(JDBC + Mybatis+ yml格式)详解

【JavaWeb后端开发04】java操作数据库(JDBC + Mybatis+ yml格式)详解

文章目录 1. 前言2. JDBC2.1 介绍2.2 入门程序2.2.1 DataGrip2.2.2 在IDEA执行sql语句 2.3 查询数据案例2.3.1 需求2.3.2 准备工作2.3.3 AI代码实现2.3.4 代码剖析2.3.4.1 ResultSet2.3.4.2 预编译SQL2.3.4.2.1 SQL注入2.3.4.2.2 SQL注入解决2.3.4.2.3 性能更高 2.4 增删改数据…
阅读更多...
最新文章

Copyright @ 2022~2023