【C/C++】C++98基础上的C++11新特性

最新推荐文章于 2023-02-27 16:57:03 发布
最新推荐文章于 2023-02-27 16:57:03 发布
阅读量1.2k 收藏 10
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shimadear/article/details/83718870
版权

一、新语法

1.自动类型推导auto

auto的自动推导，用于从初始化表达式中推断出变量的数据类型。

//C++98
int a = 10;
string s = "abc";
float b = 10.0;
vector<int> c;
vector<vector<int> > d;
map<int, string> m;
m[1] = "aaa";
map<int, string>::iterator it = m.begin();


//C++11
auto a1 = 10;  //a1为int
auto s1 = "abc";  //s1为string
auto b1 = b;  
auto c1 = c;
auto d1 = d;
auto e1 = 'a';
int* x = &a1;
auto d1 = x;
auto m1 = m.begin();
auto x=1,y=2; //ok
auto i=1.j=3.14; //compile error

double a2 = 3.144;
const auto a3 = a2;  //const double
auto a4 = a2;  //double
volatile int c2 = 3;
auto c3 = c2; //int

2.萃取类型decltype

decltype可以通过一个变量或表达式得到类型。

#include <iostream>
#include <vector>

using namespace std;

int add(int a)
{
    return ++a;
}

void fun(int a)
{
    cout << "call function: [int]\n" << endl;
}

void fun(int *a)
{
    cout << "call function: [int*]\n" << endl;
}

int main()
{
    //C++11
    int aa = 10;
    decltype(aa) bb = 11;
    string ss = "hello intel";
    decltype(ss) ss1 = "hello";
    const vector<int> vec(1);
    decltype(vec[0]) cc = 1;
    decltype(0) dd = vec[0];  //dd是int类型
    decltype(add(1)) ee;  //int
    int a[5];
    decltype(a) ff; //int[5]
    //decltype(fun) gg;  无法通过编译，是个重载函数
    
    return 0;
}

3.nullptr

空指针标识符nullptr是一个表示空指针的标识，他不是一个整数，这是与我们常用的NULL宏的区别。NULL只是一个定义为常整数0的宏，而nullptr是C++11的一个关键字，一个內建的标识符。

#include <iostream>
#include <vector>

using namespace std;

void fun(int a)
{
    cout << "call function: [int]\n" << endl;
}

void fun(int *a)
{
    cout << "call function: [int*]\n" << endl;
}

int main()
{
    //C++11
    fun(NULL);   //call function: [int]
    fun(nullptr);  //call function: [int*]

    int* p = NULL;
    fun(p);  //call function: [int*]

    return 0;
}

4.区间迭代range for

C++98和C++11在使用语法上的差异如下：

#include <iostream>
#include <vector>

using namespace std;


int main()
{
    //C++98
    vector<int> vec(8, 1);
    cout << "C++98 range for:" << endl;
    for (vector<int>::iterator it = vec.begin(); it != vec.end(); it++)
    {
        cout << *it << endl;
    }

    //C++11
    cout << "C++11 range for:" << endl;
    for (auto d : vec)
    {
        cout << d << endl;
    }

    return 0;
}

值得指出的是，是否能够使用基于范围的for循环，必须依赖一些条件。首先，就是for循环迭代的范围是可确定的。对于类来说，如果该类有begin和end函数，那么for_each之间就是for循环迭代的范围。对于数组而言，就是数组的第一个和最后一个元素间的范围。其次，基于范围的for循环还要求迭代的对象实现+ + 和==等操作符。对于STL中的容器，如string、array、map等使用起来是不会有问题的。下面是C++11操作vector和数组的实践：

#include <vector>

using namespace std;

int main()
{
    vector<int> vec(8, 1);

    //C++11
    cout << "C++11 value range for:" << endl;
    /*d非引用，修改d不会影响vector里的值*/
    for (auto d : vec)   //d中存储的是vec中的值
    {
        d = 2;
    }

    for (auto d : vec)   
    {
        cout << d << endl;
    }

    cout << "C++11 reference range for:" << endl;
    /*当迭代变量d为引用时，vector里的值可以被修改*/
    for (auto &d : vec)  
    {
        d = 2;
    }

    for (auto d : vec)   
    {
        cout << d << endl;
    }

    //数组for_each
    char arr[] = {'a','b','c','d'};
    for (auto &d : arr)
    {
        d -= 32;
    }
    for (auto d : arr)
    {
        cout << d << endl;
    }

    //遍历二维数组，注意迭代变量row必须为引用。如果你想用 range for 的方法，来遍历更高维的数组 （dim > 2），
    //那么你只需要：除了最内层循环之外，其他所有外层循环都加入 '&' 即可。
    int array2[5][5] = {0};
    for (auto &row : array2)
        for (auto col : row)
            cout << col << endl;

    return 0;
}

5.返回类型后置语法

先看下面这个例子，编译器在推导decltype(t1+t2)时表达式中t1和t2都未声明，所以编译失败。

#include <iostream>
#include <vector>

using namespace std;

template<class T1, class T2>
decltype(t1 + t2) sum(T1 t1, T2 t2)
{
    return t1 + t2;
}

int main()
{
    auto total = sum(1, 2);
    cout << total << endl;
    return 0;
}

所以C++11引入新语法，即把函数的返回值移至参数声明之后，复合符号->decltype(t1+t2)被称为追踪返回类型。而原本的函数返回值由auto占据。

#include <iostream>
#include <vector>

using namespace std;

template<class T1, class T2>
auto sum(T1 t1, T2 t2) ->decltype(t1+t2)
{
    return t1 + t2;
}

int main()
{
    auto total = sum(1, 2);
    cout << total << endl;
    return 0;
}

6.final和override

struct B
{
    virtual void f1(int) const;
    virtual void f2();
    void f3();
};

struct D1 : public B
{
    void f1(int) const override;  //ok
    void f2(int) override;   //error，B中没有形如f2(int)的函数
    void f3() override;  //error，f3不是虚函数
    void f4() override;  //error，B中无f4函数
};

struct D2 : public B
{
    void f1(int) const final;  //不许后续的其他类覆盖
};

struct D3 :public D2
{
    void f2();
    void f1(int) const; //error，final函数不可覆盖
};

final还可以用于防止继承的发生：

class NoDerived final
{

};

class Bad :NoDerived   //NoDerived不可做基类
{

};

class Base
{

};

class Last final :Base
{

};

class Bad2 :Last   //Last不可做基类
{

};

7.=default和=delete

对于 C++ 的类，如果程序员没有为其定义特殊成员函数，那么在需要用到某个特殊成员函数的时候，编译器会隐式的自动生成一个默认的特殊成员函数，比如拷贝构造函数，或者拷贝赋值操作符。

C++11允许我们使用=default来要求编译器生成一个默认构造函数，也允许我们使用=delete来告诉编译器不要为我们生成某个默认函数。

class B
{
    B() = default; //显示声明使用默认构造函数
    B(const B&) = delete; //禁止使用类对象之间的拷贝
    ~B() = default;  //显示声明使用默认析构函数
    B& operator=(const B&) = delete;  //禁止使用类对象之间的赋值
    B(int a);  
};

8.lambda表达式

简单来说，Lambda函数也就是一个函数（匿名函数），它的语法定义如下：

[capture](parameters) mutable ->return-type{statement}

  1. [=,&a,&b]表示以引用传递的方式捕捉变量a和b，以值传递方式捕捉其它所有变量;
  2. [&,a,this]表示以值传递的方式捕捉变量a和类的this指针，引用传递方式捕捉其它所有变量。
#include <iostream>

using namespace std;

int main()
{
    auto f = []() {cout << "hello world!" << endl; };
    f();  //hello world!

    int a = 123;
    auto f1 = [a] { cout << a << endl; };
    f1();  //123

    auto f2 = [&a] {cout << a << endl; };
    a = 789;
    f2();  //789

    //隐式捕获:让编译器根据函数体中的代码来推断需要捕获哪些变量
    auto f3 = [=] {cout << a << endl; };
    f3();  //789

    auto f4 = [&] {cout << a << endl; };
    a = 990;
    f4();  //990

    auto f5 = [](int a, int b)->int {return a + b; };
    printf("%d\n", f5(1, 2));  //3

    return 0;
}

lambda表达式在C++下的应用，排序

#include <stdio.h>
#include <algorithm>
#include <vector>

using namespace std;

void print(char arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        printf("%d ", arr[i]);
    }
    printf("\n");
}

bool cmp(char a, char b)
{
    if (a > b)
        return true;
    else
        return false;
}

int main()
{
    //c++98
    char arr1[] = { 2,5,2,1,5,89,36,22,89 };
    int len = sizeof(arr1) / sizeof(char);
    sort(arr1, arr1 + len, cmp);
    print(arr1, len);

    //c++11
    char arr2[] = { 2,5,2,1,5,89,36,22,89 };
    int len2 = sizeof(arr2) / sizeof(char);
    sort(arr2, arr2 + len2, [](char a, char b)->bool {return a > b; });
    print(arr2, len2);
    return 0;
}

9.std::move

std::move是为性能而生，通过std::move，可以避免不必要的拷贝操作。std::move是将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存的搬迁或者内存拷贝。

#include <iostream>
#include <utility>
#include <vector>
#include <string>
int main()
{
    std::string str = "Hello";
    std::vector<std::string> v;
    //调用常规的拷贝构造函数，新建字符数组，拷贝数据
    v.push_back(str);
    std::cout << "After copy, str is \"" << str << "\"\n"; //After move, str is "Hello"
    //调用移动构造函数，掏空str，掏空后，最好不要使用str
    v.push_back(std::move(str));
    std::cout << "After move, str is \"" << str << "\"\n";   //After move, str is ""
    std::cout << "The contents of the vector are \"" << v[0]
        << "\", \"" << v[1] << "\"\n";   //The contents of the vector are "Hello", "Hello"
}

二、STL新内容

1.std::array

  1. 使用 std::array保存在栈内存中，相比堆内存中的 std::vector，我们就能够灵活的访问这里面的元素，从而获得更高的性能；同时正式由于其堆内存存储的特性，有些时候我们还需要自己负责释放这些资源。

  2. 使用std::array能够让代码变得更加现代，且封装了一些操作函数，同时还能够友好的使用标准库中的容器算法等等，比如 std::sort。

std::array 会在编译时创建一个固定大小的数组，std::array 不能够被隐式的转换成指针，使用 std::array 很简单，只需指定其类型和大小即可：

#include <stdio.h>
#include <algorithm>
#include <array>

void foo(int* p)
{

}

int main()
{
    std::array<int, 4> arr = {4,3,1,2};

    foo(&arr[0]);  //OK
    foo(arr.data());  //OK
    //foo(arr);  //wrong
    std::sort(arr.begin(), arr.end());  //排序

    return 0;
}

2.std::forward_list

std::forward_list 使用单向链表进行实现，提供了 O(1) 复杂度的元素插入，不支持快速随机访问（这也是链表的特点），也是标准库容器中唯一一个不提供 size() 方法的容器。当不需要双向迭代时，具有比 std::list 更高的空间利用率。

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <forward_list>

int main()
{
    std::forward_list<int> list1 = { 1, 2, 3, 4 };

    //从前面向foo1容器中添加数据，注意不支持push_back
    list1.pop_front();  //删除链表第一个元素
    list1.remove(3);   //删除链表值为3的节点
    list1.push_front(2);
    list1.push_front(1);
    list1.push_front(14);
    list1.push_front(17);

    list1.sort();

    for (auto &n : list1)
    {
        if (n == 17)
            n = 19;
    }

    for (const auto &n : list1)
    {
        std::cout << n << std::endl;  //1 2 2 4 14 19
    }

    return 0;
}

3.std::unordered_map和std::unordered_set

无序容器中的元素是不进行排序的，内部通过 Hash 表实现，插入和搜索元素的平均复杂度为 O(constant)，在不关心容器内部元素顺序时，能够获得显著的性能提升。

C++11 引入了两组无序容器：std::unordered_map/std::unordered_multimap 和 std::unordered_set/std::unordered_multiset。

下面给出unordered_map和unordered_set的使用方法。

#include <stdio.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>

void foo(int* p)
{

}

int main()
{
    //unordered_map usage
    std::unordered_map<std::string, int> um = { {"2",2},{"1",1},{"3",3} };

    //遍历
    for (const auto &n : um)
    {
        std::cout << "key:" << n.first << "  value:" << n.second << std::endl;
    }

    std::cout << "value:" << um["1"] << std::endl;


    //unordered_set usage
    std::unordered_set<int> us = { 2,3,4,1};

    //遍历
    for (const auto &n : us)
    {
        std::cout << "value:" << n << std::endl;
    }

    std::cout << "value:" << us.count(9) << std::endl; //判断一个数是否在集合内，1存在0不存在
    std::cout << "value:" << *us.find(1) << std::endl;  //查找一个特定的数是否在集合内，找到就返回该数的迭代器位置

    return 0;
}

三、智能指针

1. std::shared_ptr

shared_ptr使用引用计数，每一个shared_ptr的拷贝都指向相同的内存。每使用他一次，内部的引用计数加1，每析构一次，内部的引用计数减1，减为0时，删除所指向的堆内存。shared_ptr内部的引用计数是安全的，但是对象的读取需要加锁。

#include <stdio.h>
#include <memory>
#include <iostream>

int main()
{
    //auto ptr = std::make_shared<int>(10);
    std::shared_ptr<int> ptr(new int(10));
    std::shared_ptr<int> ptrC(ptr);

    auto ptr2 = ptr;

    {
        auto ptr3 = ptr2;
        std::cout << "pointer1.use_count() = " << ptr.use_count() << std::endl;  //4
        std::cout << "pointer2.use_count() = " << ptr2.use_count() << std::endl;  //4
    }

    std::cout << "pointer1.use_count() = " << ptr.use_count() << std::endl;  //3
    std::cout << "pointer2.use_count() = " << ptr2.use_count() << std::endl;  //3

    int *p = ptr.get(); //获取原始指针

    std::cout << "pointer1.use_count() = " << ptr.use_count() << std::endl;  //3
    std::cout << "pointer2.use_count() = " << ptr2.use_count() << std::endl;  //3

    return 0;
}

2. std::unique_ptr

std::unique_ptr 是一种独占的智能指针，它禁止其他智能指针与其共享同一个对象，从而保证代码的安全：

#include <stdio.h>
#include <memory>
#include <iostream>

int main()
{
    std::unique_ptr<int> ptr(new int(10));
    //auto ptr2 = ptr; //非法

    //虽说unique_ptr是不可复制的，但我们可以使用std::move将其独占权转移到其他的unique_ptr
    auto ptr2(std::move(ptr));
    std::cout << *ptr2 << std::endl;

    return 0;
}

3. std::weak_ptr

先观察下面的代码，如果我们在类father中使用的是shared_ptr，就是shared_ptr的环形引用问题。

#include <iostream>
#include <memory>
using namespace std;

class father;
class son;

class father {
public:
    father() {
        cout << "father !" << endl;
    }
    ~father() {
        cout << "~~~~~father !" << endl;
    }
    void setSon(shared_ptr<son> s) {
        son = s;
    }
private:
    //shared_ptr<son> son;
    weak_ptr<son> son; // 用weak_ptr来替换
};


class son {
public:
    son() {
        cout << "son !" << endl;
    }
    ~son() {
        cout << "~~~~~~son !" << endl;
    }
    void setFather(shared_ptr<father> f) {
        father = f;
    }
private:
    shared_ptr<father> father;
};

void test() {
    shared_ptr<father> f(new father());
    shared_ptr<son> s(new son());
    f->setSon(s);
    s->setFather(f);
}

int main()
{
    test();
    return 0;
}

为了避免shared_ptr的环形引用问题，需要引入一个弱引用weak_ptr， weak_ptr是为了配合shared_ptr而引入的一种智能指针，弱引用不会引起引用计数增加,它更像是shared_ptr的一个助手而不是智能指针，因为它不具有普通指针的行为，没有重载operator*和->,它的最大作用在于协助shared_ptr工作，像旁观者那样观测资源的使用情况。

输出：

father !
son !
~~~~~~son !
~~~~~father !

 

转自：在C++98基础上学习C++11新特性

这个博主写的很多东西都是精品，可以多看看。

朱又炖粉条
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言/C++基础之爱心源码
12-20
C语言/C++基础之爱心源码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C++98和C++11的特性和改进
最新发布
m0_60352504的博客
01-22 635
需要注意的是，相较于 C++11、C++14 和 C++17，C++98 的新特性相对较少，C++11 引入的新特性更加丰富和强大。类型推断：C++11 引入了 decltype 关键字和更加灵活的模板类型推导规则，提高了 C++ 中类型推断的能力。新的标准库组件：C++11 引入了新的标准库组件，如正则表达式库、元组库、随机数库等，增强了 C++ 标准库的功能。总的来说，C++11 相较于 C++98 引入了许多重要的新特性和改进，使得 C++ 编程更加方便、灵活和高效，提高了代码的质量和效率。
C++11:从C++98到C++11惯用法的变化
weixin_43718250的博客
02-01 830
C++11惯用法
C++入门(C++关键字(C++98))(命名空间)(C++输入&输出)(缺省参数)(函数重载)(引用)(内联函数)(auto关键字(C++11))(基于范围的for循环(C++11))(指针空值)
zhanghgh的博客
10-24 1162
1. C++关键字(C++98) 2. 命名空间 3. C++输入&输出 4. 缺省参数 5. 函数重载 6. 引用 7. 内联函数 8. auto关键字(C++11) 9. 基于范围的for循环(C++11) 10. 指针空值---nullptr(C++11)
【C++】初识C++
weixin_63249832的博客
09-16 930
嘿少年，开始你的C++之旅吧 C++命名空间，缺省参数，重载
C++98以及C++11产生随机数的方法
面条有点辣
01-31 960
C++生成随机数方法。
C语言/C++基础之爱心程序源码
12-20
C语言/C++基础之爱心程序源码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
基于C语言/C++基础的跨年烟花代码
12-19
C语言/C++基础之跨年烟花代码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C语言/C++基础之冰墩墩源码
12-20
C语言/C++基础之冰墩墩源码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C语言/C++基础之跨年烟花代码
12-20
C语言/C++基础之跨年烟花代码，适合初学C语言/C++的小伙伴学习研究，博客中有对应的讲解和演示，避免走弯路，费时费力。也真心希望能够帮助正在苦学C语言/C++ 程序设计的小伙伴们，你们的成长是我最大的幸福
C++基础
SeanWong
04-01 571
​​C++起源于C语言，new C --> C with class --> C++. C++演化有如下版本： C++98（1.0） C++11（2.0） C++14 C++17 C++20 C++：写高性能应用，有力控制操作系统的资源和内存。 开始写C++需要两个工具，一个文本编辑器和一个编译器。gcc and g++分别是GNU的c & c++编译器。Clang是一个由Apple主导编写，基于LLVM的C/C++/Objective-C编译器。 变量类型： int,float,dou
C++98&C++11的区别
wolfGuiDao的博客
03-29 5857
C++98&C++11的区别 文章目录C++98&C++11的区别1. C++11简介2. 自动类型推导auto3. 列表初始化4. 变量类型推导5. 范围for循环6. 返回类型后置语法7. final和override8. =default和=delete9. lambda表达式10. std::move11. std::array12. std::forward_list13...
【C/C++】C语言&C++标准版本+不同版本的新特性（C89/90、C95、C99、C11、C17；C++98、C++03、C++11、C++14、C++17、C++20)（截止到2023年）
热门推荐
crr411422的博客
07-04 1万+
C语言：C89/90、C95、C99、C11、C17；C++:C++98、C++03、C++11、C++14、C++17、C++20；列出每个版本的一些主要特性。
C++——关键字|命名空间|输入&输出|缺省参数|函数重载|引用
weixin_49449676的博客
08-23 857
C语言中定义一个变量可能会跟一些函数名发生冲突，C++中为了解决这个问题 提出了namespace这个概念用namesapce来定义一个域， 若要使用这个域内的变量，我们使用域名::变量名，说明变量出处即可使用如若不 说明变量出处则是一个随机值::叫作用域限定符,这样可访问全局变量a命名的空间内可定义变量，函数，结构体，使用的时候需要声明命名空间{{}{int val;};}命名空间可以嵌套{int a;int b;{}{int c;int d;{
C++11与C++98的区别(更)
潘然PR的博客
08-31 3183
&nbsp;C++11与C++98的区别 本文参考了许多邓凡平老师的blogC++11学习之路 这俩天学QT的时候发现遇到了 很多C++11的特性 于是决定点C++11与C++98的区别，不定时更新 空指针（nullptr）取代了之前的NULL 字符串中加入了Raw字符串，定义形式为:R”附加定界符(字符串)附加定界符”在定界符之间的字符串都不会转义。 C++推出“移动”的概念，此...
【C++】C++基础语法
ChaoFreeandeasy_的博客
09-28 4085
C++基础语法呢，有非常多的细节，需要大家慢慢来摸索，仔细的回顾，反复的复习
【C++98智能指针】C++98实现Unique_Ptr/Shared_Ptr
qq_36745595的博客
02-27 418
【代码】【C++98智能指针】C++98实现Unique_Ptr/Shared_Ptr。
vscode配置c/c++环境最新
09-16
9. 创建一个新的C/C++文件，将代码保存为以".c"或".cpp"为后缀的文件。 10. 在文件中编写C/C++代码，在代码的顶部添加必要的头文件。 11. 点击编辑器上方的运行按钮（或者使用快捷键Ctrl+Shift+B）编译和运行代码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值