c++新特性与注意事项

最新推荐文章于 2024-07-03 08:34:52 发布

runner668

最新推荐文章于 2024-07-03 08:34:52 发布

阅读量143

点赞数

分类专栏：算法

本文链接：https://blog.csdn.net/runner668/article/details/79854165

版权

算法专栏收录该内容

50 篇文章 2 订阅

订阅专栏

一：委托构造：委托构造，就是构造函数调用其他的构造函数来完成构造过程，其他的构造函数写在成员初始列表中。

#include <iostream>
using namespace std;

class base{
private:
    int a;
public:
    //非委托函数使用相应的实参初始化相应的实参初始化成员
    base(int a):
    a(a){};

    //将构造任务委托给了base(int a)函数
    base():
    base(45){}

    void show_a(){
        cout <<  a << endl;
    }
};

int main(){
    base a;
    a.show_a();  //结果是45
}

二：成员初始化（初始化成员列表）

初始化列表的成员初始化顺序:
C++初始化类成员时，是按照声明的顺序初始化的，而不是按照出现在初始化列表中的顺序。
Example:

class CMyClass {

CMyClass(int x, int y);

int m_x;

int m_y;

};

CMyClass::CMyClass(int x, int y) : m_y(y), m_x(m_y)

{ } //此时初始化的时候m_x是个不确定的值

三：友好的新特性

final：显示禁止类被继承 class A final{ }；

default：显示默认构造析构函数 A （）=default;

auto/decltype :自动类型推断

可变参数模板：可在模板参数里边书写任意数量的类型名。 template<typename T,typename . . . Args>

lambda表达式：匿名函数（闭包），灵活医用

#include<iostream>
using namespace std;
 
int main()
{
    int a = 1;
    int b = 2;
    // =表示传值，&b表示传引用 （int c）是函数的参数列表 { 函数体}
    auto func = [=, &b](int c)->int {return b += a + c;};
    func(3); //jeiguo  6
    return 0;
}

四：for循环语法

int main()
{
    int numbers[] = { 1,2,3,4,5 };
    std::cout << "numbers:" << std::endl;
    for (auto number : numbers)  //有点类似python语言 for i in range(1,5)
    {
        std::cout << number << std::endl;
    }
}

以上用法不仅仅局限于数据，STL容器都同样适用。

五：多线程机制

在C++11以前，C++的多线程编程均需依赖系统或第三方接口实现，一定程度上影响了代码的移植性。C++11中，引入了boost库中的多线程部分内容，形成C++标准，形成标准后的boost多线程编程部分接口基本没有变化，这样方便了以前使用boost接口开发的使用者切换使用C++标准接口，把容易把boost接口升级为C++接口。

　　我们通过如下几部分介绍C++11多线程方面的接口及使用方法。

5.1、std::thread

　　std::thread为C++11的线程类，使用方法和boost接口一样，非常方便，同时，C++11的std::thread解决了boost::thread中构成参数限制的问题，我想着都是得益于C++11的可变参数的设计风格。

　　我们通过如下代码熟悉下std::thread使用风格。

//示例代码1.0 http://www.cnblogs.com/feng-sc/p/5710724.html
#include <thread>
void threadfun1()
{
    std::cout << "threadfun1 - 1\r\n" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "threadfun1 - 2" << std::endl;
}

void threadfun2(int iParam, std::string sParam)
{
    std::cout << "threadfun2 - 1" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(5));
    std::cout << "threadfun2 - 2" << std::endl;
}

int main()
{
    std::thread t1(threadfun1);
    std::thread t2(threadfun2, 10, "abc");
    t1.join();
    std::cout << "join" << std::endl;
    t2.detach();
    std::cout << "detach" << std::endl;
}

　　运行结果：

　　有以上输出结果可以得知，t1.join()会等待t1线程退出后才继续往下执行，t2.detach()并不会并不会把，detach字符输出后，主函数退出，threadfun2还未执行完成，但是在主线程退出后，t2的线程也被已经被强退出。

5.2、std::atomic

　　std::atomic为C++11分装的原子数据类型。

　　什么是原子数据类型？

　　从功能上看，简单地说，原子数据类型不会发生数据竞争，能直接用在多线程中而不必我们用户对其进行添加互斥资源锁的类型。从实现上，大家可以理解为这些原子类型内部自己加了锁。

　　我们下面通过一个测试例子说明原子类型std::atomic_int的特点。

　　下面例子中，我们使用10个线程，把std::atomic_int类型的变量iCount从100减到1。

//示例代码1.0 http://www.cnblogs.com/feng-sc/p/5710724.html
#include <thread>
#include <atomic>
#include <stdio.h>
std::atomic_bool bIsReady = false;
std::atomic_int iCount = 100;
void threadfun1()
{
    if (!bIsReady) {
        std::this_thread::yield();
    }
    while (iCount > 0)
    {
        printf("iCount:%d\r\n", iCount--);
    }
}

int main()
{
    std::atomic_bool b;
    std::list<std::thread> lstThread;
    for (int i = 0; i < 10; ++i)
    {
        lstThread.push_back(std::thread(threadfun1));
    }
    for (auto& th : lstThread)
    {
        th.join();
    }
}

　　运行结果：

　　注：屏幕太短的原因，上面结果没有截完屏

　　从上面的结果可以看到，iCount的最小结果都是1，单可能不是最后一次打印，没有小于等于0的情况，大家可以代码复制下来多运行几遍对比看看。

5.3、std::condition_variable

　　C++11中的std::condition_variable就像Linux下使用pthread_cond_wait和pthread_cond_signal一样，可以让线程休眠，直到别唤醒，现在在从新执行。线程等待在多线程编程中使用非常频繁，经常需要等待一些异步执行的条件的返回结果。

　　OK，在此不多解释，下面我们通过C++11官网的例子看看。

 1 // webset address: http://www.cplusplus.com/reference/condition_variable/condition_variable/%20condition_variable
 2 // condition_variable example
 3 #include <iostream>           // std::cout
 4 #include <thread>             // std::thread
 5 #include <mutex>              // std::mutex, std::unique_lock
 6 #include <condition_variable> // std::condition_variable
 7 
 8 std::mutex mtx;
 9 std::condition_variable cv;
10 bool ready = false;
11 
12 void print_id(int id) {
13     std::unique_lock<std::mutex> lck(mtx);
14     while (!ready) cv.wait(lck);
15     // ...
16     std::cout << "thread " << id << '\n';
17 }
18 
19 void go() {
20     std::unique_lock<std::mutex> lck(mtx);
21     ready = true;
22     cv.notify_all();
23 }
24 
25 int main()
26 {
27     std::thread threads[10];
28     // spawn 10 threads:
29     for (int i = 0; i<10; ++i)
30         threads[i] = std::thread(print_id, i);
31 
32     std::cout << "10 threads ready to race...\n";
33     go();                       // go!
34 
35     for (auto& th : threads) th.join();
36 
37     return 0;
38 }

上面的代码，在14行中调用cv.wait(lck)的时候，线程将进入休眠，在调用33行的go函数之前，10个线程都处于休眠状态，当22行的cv.notify_all()运行后，14行的休眠将结束，继续往下运行，最终输出如上结果。

六：最重要的：智能指针

在内存管理方面，C++11的std::auto_ptr基础上，移植了boost库中的智能指针的部分实现，如std::shared_ptr、std::weak_ptr等，当然，像boost::thread一样，C++11也修复了boost::make_shared中构造参数的限制问题。把智能指针添加为标准，个人觉得真的非常方便，毕竟在C++中，智能指针在编程设计中使用的还是非常广泛。

　　什么是智能指针？网上已经有很多解释，个人觉得“智能指针”这个名词似乎起得过于“霸气”，很多初学者看到这个名词就觉得似乎很难。

　　简单地说，智能指针只是用对象去管理一个资源指针，同时用一个计数器计算当前指针引用对象的个数，当管理指针的对象增加或减少时，计数器也相应加1或减1，当最后一个指针管理对象销毁时，计数器为1，此时在销毁指针管理对象的同时，也把指针管理对象所管理的指针进行delete操作。

　　如下图所示，简单话了一下指针、智能指针对象和计数器之间的关系：

　　下面的小章节中，我们分别介绍常用的两个智能指针std::shared_ptr、std::weak_ptr的用法。

4.1、std::shared_ptr

　　std::shared_ptr包装了new操作符动态分别的内存，可以自由拷贝复制，基本上是使用最多的一个智能指针类型。

　　我们通过下面例子来了解下std::shared_ptr的用法:

//示例代码1.0 http://www.cnblogs.com/feng-sc/p/5710724.html
#include <memory>
class Test
{
public:
    Test()
    {
        std::cout << "Test()" << std::endl;
    }
    ~Test()
    {
        std::cout << "~Test()" << std::endl;
    }
};
int main()
{
    std::shared_ptr<Test> p1 = std::make_shared<Test>();
    std::cout << "1 ref:" << p1.use_count() << std::endl;
    {
        std::shared_ptr<Test> p2 = p1;
        std::cout << "2 ref:" << p1.use_count() << std::endl;
    }
    std::cout << "3 ref:" << p1.use_count() << std::endl;
    return 0;
}

　　运行结果：

　　从上面代码的运行结果，需要读者了解的是：

　　1、std::make_shared封装了new方法，boost::make_shared之前的原则是既然释放资源delete由智能指针负责，那么应该把new封装起来，否则会让人觉得自己调用了new，但没有调用delete，似乎与谁申请，谁释放的原则不符。C++也沿用了这一做法。

　　2、随着引用对象的增加std::shared_ptr<Test> p2 = p1，指针的引用计数有1变为2，当p2退出作用域后，p1的引用计数变回1，当main函数退出后，p1离开main函数的作用域，此时p1被销毁，当p1销毁时，检测到引用计数已经为1，就会在p1的析构函数中调用delete之前std::make_shared创建的指针。

4.2、std::weak_ptr

　　std::weak_ptr网上很多人说其实是为了解决std::shared_ptr在相互引用的情况下出现的问题而存在的，C++官网对这个只能指针的解释也不多，那就先甭管那么多了，让我们暂时完全接受这个观点。

　　std::weak_ptr有什么特点呢？与std::shared_ptr最大的差别是在赋值是，不会引起智能指针计数增加。

　　我们下面将继续如下两点：

　　1、std::shared_ptr相互引用会有什么后果；

　　2、std::weak_ptr如何解决第一点的问题。

　　A、std::shared_ptr相互引用的问题示例：

//示例代码1.0 http://www.cnblogs.com/feng-sc/p/5710724.html
#include <memory>
class TestB;
class TestA
{
public:
    TestA()
    {
        std::cout << "TestA()" << std::endl;
    }
    void ReferTestB(std::shared_ptr<TestB> test_ptr)
    {
        m_TestB_Ptr = test_ptr;
    }
    ~TestA()
    {
        std::cout << "~TestA()" << std::endl;
    }
private:
    std::shared_ptr<TestB> m_TestB_Ptr; //TestB的智能指针
}; 

class TestB
{
public:
    TestB()
    {
        std::cout << "TestB()" << std::endl;
    }

    void ReferTestB(std::shared_ptr<TestA> test_ptr)
    {
        m_TestA_Ptr = test_ptr;
    }
    ~TestB()
    {
        std::cout << "~TestB()" << std::endl;
    }
    std::shared_ptr<TestA> m_TestA_Ptr; //TestA的智能指针
};


int main()
{
    std::shared_ptr<TestA> ptr_a = std::make_shared<TestA>();
    std::shared_ptr<TestB> ptr_b = std::make_shared<TestB>();
    ptr_a->ReferTestB(ptr_b);
    ptr_b->ReferTestB(ptr_a);
    return 0;
}

　　运行结果：

　　大家可以看到，上面代码中，我们创建了一个TestA和一个TestB的对象，但在整个main函数都运行完后，都没看到两个对象被析构，这是什么问题呢？

　　原来，智能指针ptr_a中引用了ptr_b，同样ptr_b中也引用了ptr_a，在main函数退出前，ptr_a和ptr_b的引用计数均为2，退出main函数后，引用计数均变为1，也就是相互引用。

　　这等效于说：

　　　　ptr_a对ptr_b说，哎，我说ptr_b，我现在的条件是，你先释放我，我才能释放你，这是天生的，造物者决定的，改不了。

　　　　ptr_b也对ptr_a说，我的条件也是一样，你先释放我，我才能释放你，怎么办？

　　是吧，大家都没错，相互引用导致的问题就是释放条件的冲突，最终也可能导致内存泄漏。

　　B、std::weak_ptr如何解决相互引用的问题

　　我们在上面的代码基础上使用std::weak_ptr进行修改：

//示例代码1.0 http://www.cnblogs.com/feng-sc/p/5710724.html
#include <memory>
class TestB;
class TestA
{
public:
    TestA()
    {
        std::cout << "TestA()" << std::endl;
    }
    void ReferTestB(std::shared_ptr<TestB> test_ptr)
    {
        m_TestB_Ptr = test_ptr;
    }
    void TestWork()
    {
        std::cout << "~TestA::TestWork()" << std::endl;
    }
    ~TestA()
    {
        std::cout << "~TestA()" << std::endl;
    }
private:
    std::weak_ptr<TestB> m_TestB_Ptr;
};

class TestB
{
public:
    TestB()
    {
        std::cout << "TestB()" << std::endl;
    }

    void ReferTestB(std::shared_ptr<TestA> test_ptr)
    {
        m_TestA_Ptr = test_ptr;
    }
    void TestWork()
    {
        std::cout << "~TestB::TestWork()" << std::endl;
    }
    ~TestB()
    {
        std::shared_ptr<TestA> tmp = m_TestA_Ptr.lock();
        tmp->TestWork();
        std::cout << "2 ref a:" << tmp.use_count() << std::endl;
        std::cout << "~TestB()" << std::endl;
    }
    std::weak_ptr<TestA> m_TestA_Ptr;
};


int main()
{
    std::shared_ptr<TestA> ptr_a = std::make_shared<TestA>();
    std::shared_ptr<TestB> ptr_b = std::make_shared<TestB>();
    ptr_a->ReferTestB(ptr_b);
    ptr_b->ReferTestB(ptr_a);
    std::cout << "1 ref a:" << ptr_a.use_count() << std::endl;
    std::cout << "1 ref b:" << ptr_a.use_count() << std::endl;
    return 0;
}

　　运行结果：

　　由以上代码运行结果我们可以看到：

　　1、所有的对象最后都能正常释放，不会存在上一个例子中的内存没有释放的问题。

　　2、ptr_a 和ptr_b在main函数中退出前，引用计数均为1，也就是说，在TestA和TestB中对std::weak_ptr的相互引用，不会导致计数的增加。在TestB析构函数中，调用std::shared_ptr<TestA> tmp = m_TestA_Ptr.lock()，把std::weak_ptr类型转换成std::shared_ptr类型，然后对TestA对象进行调用。