c++11新特性

server/2024/11/15 7:32:50/

1. auto

        自动推导变量类型，简化代码书写。

#include <iostream>
#include <type_traits>#if defined(__linux__) || defined(__linux)
#include <cxxabi.h>
#define TYPE_NAME(var) abi::__cxa_demangle(typeid(var).name(), 0, 0, 0)
#else
#define TYPE_NAME(var) typeid(var).name()
#endifvoid Test() {char a = 'A';auto aa = a;std::cout << "a,aa type: " << TYPE_NAME(a) << ", " << TYPE_NAME(aa) << std::endl;short b = 1;auto bb = b;std::cout << "b,bb type: " << TYPE_NAME(b) << ", " << TYPE_NAME(bb) << std::endl;int c = 1;auto cc = c;std::cout << "c,cc type: " << TYPE_NAME(c) << ", " << TYPE_NAME(cc) << std::endl;float d = 1.0f;auto dd = d;std::cout << "d,dd type: " << TYPE_NAME(d) << ", " << TYPE_NAME(dd) << std::endl;double e = 1.0;auto ee = e;std::cout << "e,ee type: " << TYPE_NAME(e) << ", " << TYPE_NAME(ee) << std::endl;long f = 1;auto ff = f;std::cout << "f,ff type: " << TYPE_NAME(f) << ", " << TYPE_NAME(ff) << std::endl;const long g = 1;auto gg = g;std::cout << "g,gg type: " << TYPE_NAME(g) << ", " << TYPE_NAME(gg) << std::endl;char h[10] = {0};auto hh = h;std::cout << "h,hh type: " << TYPE_NAME(h) << ", " << TYPE_NAME(hh) << std::endl;int *i = nullptr;auto ii = i;std::cout << "i,ii type: " << TYPE_NAME(i) << ", " << TYPE_NAME(ii) << std::endl;const int *j = nullptr;auto jj = j;std::cout << "j,jj type: " << TYPE_NAME(j) << ", " << TYPE_NAME(jj) << std::endl;const int *const k = nullptr;auto kk = k;std::cout << "k,kk type: " << TYPE_NAME(k) << ", " << TYPE_NAME(kk) << std::endl;int &l = c;auto ll = l;std::cout << "l,ll type: " << TYPE_NAME(l) << ", " << TYPE_NAME(ll) << std::endl;const int &m = c;auto mm = m;std::cout << "m,mm type: " << TYPE_NAME(m) << ", " << TYPE_NAME(mm) << std::endl;int &&n = 1;auto nn = n;std::cout << "n,nn type: " << TYPE_NAME(n) << ", " << TYPE_NAME(nn) << std::endl;const int &&o = 1;auto oo = o;std::cout << "o,oo type: " << TYPE_NAME(o) << ", " << TYPE_NAME(oo) << std::endl;const int *&p = j;auto pp = p;std::cout << "p,pp type: " << TYPE_NAME(p) << ", " << TYPE_NAME(pp) << std::endl;const int *q = j;const auto &qq = j;std::cout << "q,qq type: " << TYPE_NAME(q) << ", " << TYPE_NAME(qq) << std::endl;
}int main(int argc, char *argv[]) {std::cout << "Hello World" << std::endl;Test();return 0;
}

执行结果：

Hello World
a,aa type: char, char
b,bb type: short, short
c,cc type: int, int
d,dd type: float, float
e,ee type: double, double
f,ff type: long, long
g,gg type: long, long
h,hh type: char [10], char*
i,ii type: int*, int*
j,jj type: int const*, int const*
k,kk type: int const*, int const*
l,ll type: int, int
m,mm type: int, int
n,nn type: int, int
o,oo type: int, int
p,pp type: int const*, int const*
q,qq type: int const*, int const*

2. decltype

        推导实体的声明类型，或表达式的类型和值类别。

#include <iostream>
#include <type_traits>#if defined(__linux__) || defined(__linux)
#include <cxxabi.h>
#define TYPE_NAME(var) abi::__cxa_demangle(typeid(var).name(), 0, 0, 0)
#else
#define TYPE_NAME(var) typeid(var).name()
#endifstruct A {double x;
};const int &GetRef(const int *p) { return *p; }
auto Add(int a, int b) -> decltype(a + b) { return a + b; }void Test() {int a = 33;decltype(a) b = a * 2;std::cout << "a,b type: " << TYPE_NAME(a) << ", " << TYPE_NAME(b)<< std::endl;const A *c = nullptr;decltype(c->x) d;decltype((c->x)) e = d;std::cout << "d,e type: " << TYPE_NAME(d) << ", " << TYPE_NAME(e)<< std::endl;const int *const f = &a;decltype(f) g = &b;std::cout << "f,g type: " << TYPE_NAME(f) << ", " << TYPE_NAME(g)<< std::endl;int &aref = a;decltype(aref) h = a;decltype(Add(10, 20)) i;std::cout << "h,i type: " << TYPE_NAME(f) << ", " << TYPE_NAME(g)<< std::endl;
}

执行结果

a,b type: int, int
d,e type: double, double
f,g type: int const*, int const*
h,i type: int const*, int const*

3. default & delete

        由开发者控制函数由编译器创建(default)或禁止创建(delete)，用于构造、析构系列函数。

class A {A() = delete;A(const A &) = default;A(A &&) = default;A &operator=(const A &) = default;A &operator=(A &&) = delete;~A() = default;
};

4. final & override

        final 用于指定某个虚函数不能在派生类中被重写，或者某个类不能被派生；override指定一个虚函数重写另一个虚函数，用于派生类虚函数重写了基类某个虚函数，如果没有重写编译报错。

#include <iostream>
#include <string>struct A final { virtual void Print(const std::string &str) { std::cout << str << std::endl; }
}
#include <iostream>
#include <string>struct A {A() = default;virtual void Print(const std::string &str) final {std::cout << "A " << str << std::endl;}virtual void Print2(const std::string &str) {std::cout << "A2 " << str << std::endl;}
};struct B : public A {B() : A() {}virtual void Print2(const std::string &str) override {std::cout << "B2 " << str << std::endl;}
};void Test() {A a;a.Print("a invoke");a.Print2("a invoke 2");B b;b.Print("B invoke");b.Print2("b invoke 2");A *c = new B();c->Print("c invoke");c->Print2("c invoke 2");delete c;
}int main(int argc, char *argv[]) {Test();return 0;
}

5. 尾随返回类型

        当返回类型取决于实参名时或当返回类型复杂时，尾随返回类型很有用。

#include <iostream>template <class T, class U> auto Add(T t, U u) -> decltype(t + u) {return t + u;
}void Test() {int a = 10;double b = 20;std::cout << "a + b = " << Add(a, b) << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}

执行结果

a + b = 30

6. 右值引用

  1. 左值：可修改的变量或表达式。
  2. 右值：常量、表达式等不能出现在等式左边。
  3. 左值引用(&)：左值变量的引用别名，传统的引用都是左值。
  4. 右值引用(&&)：右值变量的引用别名，一般只能引用右值，可使用std::move转化为右值，实现移动语义。
  5. 完美转发：不修改传递的变量或表达式语义，进行完整的语义传递，即左值参数传递后还是左值，左右参数传递后还是右值。
#include <iostream>void Test() {int a = 10;   // a 左值， 10右值int &aa = a;  // aa 左值引用int &&aaa = std::move(a); // aaa 右值引用，此时 a 在后边作用域内无意义int b = 0;int &bb = b;int &&bbb = std::move(b);const int c = 20;const int &cc = c;// int &&ccc = std::move(c);const int &d = bbb; // const 修饰的引用可以是左值、也可以是右值
}int main(int argc, char *argv[]) {Test();return 0;
}
void Func(const int&& x) { cout << "const 右值引用" << endl; }template<typename T>
void Test(T&& t)
{// Func(t); //没有使用forward保持其右值的属性，退化为左值Func(std::forward<T>(t));  // 使用 std::forward 实现完美转发
}

7. 移动构造

        移动构造函数是一种构造函数，可以提供一个相同类类型实参调用，并复制该实参的内容，有可能会修改实参。

struct A {A() = default;~A() = default;A(const A &) { std::cout << "A(const A&)" << std::endl; }A(A &&) { std::cout << "A(A&&)" << std::endl; }A(const A &&) { std::cout << "const A(A&&)" << std::endl; }A(const volatile A &&) { std::cout << "const volatile A(A&&)" << std::endl; }A(A &&, int num) { std::cout << "A(A&&), num = " << num << std::endl; }int x = 10;
};void Test() {A a;A b = a;A bb = std::move(a);const A c; // 只读变量A d = std::move(c);const volatile A e; // 只读变量A f = std::move(e);a.x = 20;std::cout << "a.x = " << a.x << std::endl;b.x = 30;std::cout << "b.x = " << b.x << std::endl;bb.x = 40;std::cout << "bb.x = " << bb.x << std::endl;d.x = 60;std::cout << "d.x = " << d.x << std::endl;f.x = 80;std::cout << "f.x = " << f.x << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}

执行结果

A(const A&)
A(A&&)
const A(A&&)
const volatile A(A&&)
a.x = 20
b.x = 30
bb.x = 40
d.x = 60
f.x = 80

8. 移动赋值运算符

        移动赋值运算符是名字是 operator= 的非模板非静态成员函数，可以提供一个相同类类型实参调用，并复制该实参的内容，有可能会修改实参。

#include <iostream>struct A {A() = default;~A() = default;A &operator=(const A &) {std::cout << "A &operator=(const A &)" << std::endl;}A &operator=(A &&) { std::cout << "A &operator=(A &&)" << std::endl; }A &operator=(const A &&) {std::cout << "A &operator=(const A &&)" << std::endl;}int x = 10;
};void Test() {A a;a.x = 20;A b;b = a;// const A c = a;  // 复制构造函数A d;d = std::move(a);// const A e = std::move(a);  // 复制构造函数a.x = 20;std::cout << "a.x = " << a.x << std::endl;b.x = 30;std::cout << "b.x = " << b.x << std::endl;d.x = 60;std::cout << "d.x = " << d.x << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}

执行结果

A &operator=(const A &)
A &operator=(A &&)
a.x = 20
b.x = 30
d.x = 60

9. 作用域枚举

        枚举 是一种独立的类型，它的值被限制在一个取值范围内（细节见下文），它可以包含数个明确命名的常量（“枚举项”）。各常量的值是某个整数类型（称为该枚举的底层类型）的值。枚举的大小、值表示和对齐要求与它的底层类型相同。而且枚举的每个值都与该枚举的底层类型的对应值有着相同的表示。

#include <iostream>enum EnumColor { kRed = 0, kGreen, kBlue };
enum class EnumClassColor { kRed = 3, kGreen, kBlue };
enum class EnumClassColorType : int { kRed = 6, kGreen, kBlue };void Test() {std::cout << "EnumColor: " << EnumColor::kRed << ", " << kGreen << ", "<< kBlue << std::endl;std::cout << "EnumClassColor: " << int(EnumClassColor::kRed) << ", "<< int(EnumClassColor::kGreen) << ", " << int(EnumClassColor::kBlue)<< std::endl;std::cout << "EnumClassColorType: " << int(EnumClassColorType::kRed) << ", "<< int(EnumClassColorType::kGreen) << ", "<< int(EnumClassColorType::kBlue) << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}

执行结果

EnumColor: 0, 1, 2
EnumClassColor: 3, 4, 5
EnumClassColorType: 6, 7, 8

10. constexpr

        指定变量或函数的值可以在常量表达式中出现，必须初始化。字面类型是constexpr类型拥有的类型，且能通过constexpr函数构造、操作及返回它们。

#include <iostream>constexpr int Ret() { return 0; }
constexpr bool b2 = noexcept(Ret()); // true，f() 是常量表达式constexpr int Add() { return 10 + 20; }static constexpr char *COLOR[3]{"kRed", "kGreen", "kBlue"};void Test() {constexpr int NUM = 10;static constexpr int NUM2 = 20;static constexpr int const NUM3 = 30;static constexpr int const &NUM4 = 40;constexpr int ARR[2] = {0, 1};std::cout << "Add: " << Add() << std::endl; // 30
}int main(int argc, char *argv[]) {Test();return 0;
}

11. 列表初始化

         从花括号包围的初始化器列表列表初始化对象，默认std::initializer_list类为构造参数。C++98中，标准允许使用花括号{}对数组元素进行统一的列表初始值设定。C++98对于自定义类型，无法使用列表初始化。

#include <iostream>
#include <map>
#include <vector>struct A {A(int a, int b) {}private:int m_a;int m_b;
};void Test() {int arr1[5]{1, 2, 3, 4, 5};int arr2[]{1, 2, 3, 4, 5};int *arr3 = new int[5]{1, 2, 3, 4, 5}; // 动态数组，在C++98中不支持std::vector<int> v{1, 2, 3, 4, 5};std::map<int, int> m{{1, 1}, {2, 2}, {3, 3}, {4, 4}};delete[] arr3;int a = 1 + 3;int b = {1 + 3};int c{1 + 3};A d = {4, 5};A e{6, 7};
}int main(int argc, char *argv[]) {Test();return 0;
}

12. 委托构造 & 继承构造

        如果类自身的名字在初始化器列表中作为类或标识符 出现，那么该列表只能由这一个成员初始化器组成；这种构造函数被称为委托构造函数，而构造函数列表的仅有成员所选择的构造函数是目标构造函数。此时首先由重载决议选择目标构造函数并予以执行，然后控制返回到委托构造函数并执行其函数体。委托构造函数不能递归。

        c++语言当中的继承关系，只有虚函数可以被继承，而构造函数不可以是虚函数，所以构造函数不能被继承，但是我们可以通过某种手段，达到继承效果

class A
{
public: A(char x, int y) {}A(int y) : A('a', y) {} // A(int) 委托到 A(char, int)
};
#include <iostream>struct A {A(int a, int b, int c) {}
};struct B : A {using A::A;int m_a;
};void Test() {A a(1, 2, 3);B b(1, 2, 3); // 调用 A 构造函数， 未初始化 m_a// B c;
}int main(int argc, char *argv[]) {Test();return 0;
}

13. nullptr

        关键词 nullptr 代表指针字面量。它是std::nullptr_t类型的纯右值。存在从 nullptr 到任何指针类型及任何成员指针类型的隐式转换。同样的转换对于任何空指针常量也存在，空指针常量包括std::nullptr_t的值，以及宏 NULL。

#include <type_traits>
#include <iostream>#if defined(__linux__) || defined(__linux)
#include <cxxabi.h>
#define TYPE_NAME(var) abi::__cxa_demangle(typeid(var).name(), 0, 0, 0)
#else
#define TYPE_NAME(var) typeid(var).name()
#endifvoid Test() {std::nullptr_t ptr = nullptr;std::cout << "ptr type: " << TYPE_NAME(ptr) << std::endl;int *ptr2 = nullptr;std::cout << "ptr2 type: " << TYPE_NAME(ptr2) << std::endl;
}int main(int argc, char *argv[]) {Test();return 0;
}

执行输出

ptr type: decltype(nullptr)
ptr2 type: int*

14. long long类型

        long long - 目标类型将有至少 64 位的宽度。具体与平台架构实现相关，long类型规定大于等于32位宽度。

15. char16_t & char32_t

        char16_t - UTF-16 字符表示的类型，要求大到足以表示任何 UTF-16 编码单元（16 位）。它与std::uint_least16_t具有相同的大小、符号性和对齐，但它是独立的类型。

        char32_t - UTF-32 字符表示的类型，要求大到足以表示任何 UTF-32 编码单元（32 位）。它与std::uint_least32_t具有相同的大小、符号性和对齐，但它是独立的类型。

16. 类型别名

        类型别名是指代先前定义的类型的名字(类似 typedef)。别名模版是指代一族类型的名字。

#include <iostream>
#include <string>
#include <type_traits>
#include <typeinfo>// 类型别名，等同于 typedef std::ios_base::fmtflags flags;
using flags = std::ios_base::fmtflags;
flags fl = std::ios_base::dec;// 类型别名，等同于 typedef void (*func)(int, int);
using func = void (*)(int, int);
void example(int, int) {}
func f = example;// 别名模板
template <class T> using ptr = T *;
ptr<int> x;// 用于隐藏模板形参的别名模版
template <class CharT>
using mystring = std::basic_string<CharT, std::char_traits<CharT>>;
mystring<char> str;// 别名模板可引入成员 typedef 名
template <typename T> struct Container { using value_type = T; };// 可用于泛型编程
template <typename ContainerType> void info(const ContainerType &c) {typename ContainerType::value_type T;std::cout << "ContainerType 是 `" << TYPE_NAME(typeid(decltype(c)).name())<< "`\n""value_type 是 `"<< typeid(T).name() << "`\n";
}// 用于简化 std::enable_if 语法的类型别名
template <typename T> using Invoke = typename T::type;template <typename Condition>
using EnableIf = Invoke<std::enable_if<Condition::value>>;template <typename T, typename = EnableIf<std::is_polymorphic<T>>>
int fpoly_only(T) {return 1;
}struct S {virtual ~S() {}
};int main() {Container<int> c;info(c); // Container::value_type 将在此函数中是 int//  fpoly_only(c); // 错误：被 enable_if 禁止S s;fpoly_only(s); // OK：被 enable_if 允许
}

执行结果

ContainerType 是 `char const*`
value_type 是 `i`

17. 可变参模板

        模板形参包是接受零个或更多个模板实参（非类型、类型或模板）的模板形参。函数形参包是接受零个或更多个函数实参的函数形参。至少有一个形参包的模板被称作变参模板。

#include <iostream>void tprintf(const char* format) // 基础函数
{std::cout << format;
}template<typename T, typename... Targs>
void tprintf(const char* format, T value, Targs... Fargs) // 递归变参函数
{for (; *format != '\0'; format++){if ( *format == '%' ){std::cout << value;tprintf(format + 1, Fargs...); // 递归调用return;}std::cout << *format;}
}int main()
{tprintf("% world% %\n", "Hello", '!', 123);
}

执行结果

Hello world! 123


http://www.ppmy.cn/server/129502.html

相关文章

Java实现图书管理系统

Java实现图书管理系统

示例 代码框架 其中User包括管理员和普通用户的基本信息&#xff1b;book包括书籍和书架的基本信息&#xff1b;ioperate包括查找图书&#xff0c;借阅图书等基础业务 代码下载 https://github.com/King-xxz/Library-Management-System
阅读更多...
、js 相关

、js 相关

隐式类型转换 let num1 10 let num2 10 console.log(num1 num2) // 1010 console.log(num1 - num2) // 0 // 尝试类型转换 console.log(1.23 1.23) // true 字符串和数字可以互相转换 console.log(0 false) // true 非零数值被视为真&#xff08;true&#xff09; consol…
阅读更多...
STM32（五）GPIO输入硬件电路及C语言知识复习

STM32（五）GPIO输入硬件电路及C语言知识复习

本小节主要是GPIO输入模式下的硬件电路和C语言知识的回顾 C语言中的数据&#xff1a;定义和引用 一、GPIO输入模式下的硬件和电路 1.按键介绍 可以用延时函数消除按键抖动 2.传感器模块介绍 &#xff08;1&#xff09;传感器元件的电阻会随模拟量的变化而变化&#xff0c;通…
阅读更多...
【2024】前端学习笔记12-JavaScript初体验-Js操作window

【2024】前端学习笔记12-JavaScript初体验-Js操作window

学习笔记 1.什么是JavaScript2.JavaScript初体验3.案例：弹出一个带确认、取消的对话框4.JS之window对象4.1.window.open：打开新窗口4.2.window.innerWidth/innerHeight：获取浏览器窗口宽度和高度4.3.window.location.reload：重新加载当前页面4.4.window.document：操作文档…
阅读更多...
K8s简介及环境搭建

K8s简介及环境搭建

一、Kubernetes简介 kubernetes 的本质是一组服务器集群&#xff0c;它可以在集群的每个节点上运行特定的程序&#xff0c;来对节点中的容器进行管理。目的是实现资源管理的自动化&#xff0c;主要提供了如下的主要功能&#xff1a; 自我修复&#xff1a;一旦某一个容器崩溃&a…
阅读更多...
【C++】AVL树（AVLTree）

【C++】AVL树（AVLTree）

目录 一、AVL树概念&#xff1a; 二、定义&#xff1a; 三、AVL树的插入&#xff1a; 四、AVL树的旋转&#xff1a; 1、左单旋&#xff1a; 2、右单旋&#xff1a; 3、右左双旋&#xff1a; 4、左右双旋&#xff1a; 五、AVL树的检验&#xff1a; 一、AVL树概念&#x…
阅读更多...
思迅食通天提示：存在未买单餐桌不能日结

思迅食通天提示：存在未买单餐桌不能日结

可用语句1查询相关单据&#xff0c;语句2删除&#xff0c;语句1时间改为实际日结开始结束时间&#xff0c;语句2单号改为1查询出的单号&#xff0c;注意备份数据库 use issfoodv6 ----1、可查询出对应的单据 select * from cybr_u_tmp_orderdish_qu where isnull ( ch_payflag …
阅读更多...
ajax的原理，使用场景以及如何实现

ajax的原理，使用场景以及如何实现

AJAX 原理 AJAX&#xff08;Asynchronous JavaScript and XML&#xff09;是一种在网页中实现异步通信的技术&#xff0c;允许网页在不重新加载整个页面的情况下与服务器交换数据。这使得网页应用可以更加响应式和动态&#xff0c;提升用户体验。 AJAX 的核心原理是在后台通过…
阅读更多...
最新文章

Copyright @ 2022~2023