深入应用C++11：代码优化与工程级应用--note2

2022-03-30

深入应用C++11的第二篇笔记，包括智能指针，多线程，cast和一些其他工具

智能指针

基础使用

void delete_ptr(int* p) {
    delete p;
}

// 尽可能使用make_ptr来初始化指针
shared_ptr<int> p = make_shared<int>(3);
shared_ptr<int> q(new int(1));  // shared_ptr<int> q = new int(1); 这样写是错的，不能直接赋值
shared_ptr<int> t;
t.reset(new int(2));    // 当智能指针为初始化时，可以用reset来初始化；当智能指针中有值的时候，reset会让计数减1

// 可以通过get来获得原始指针
int* x = t.get();
cout << *x << endl; // 2

// 智能指针初始化的时候可以置顶删除器
shared_ptr<int> y(new int, delete_ptr);
int* a = new int[10]{1,2,10,7};
shared_ptr<int> z(a, [](int* z) -> void {delete[] z;});  // lambda表达式也可以，注意这里直接初始化是可以的，但是make_shared是不行的
cout << z.get()[3] << endl;

封装一个可以支持数组的方法

template<typename T>
shared_ptr<T> make_shared_array(size_t size) {
    return shared_ptr<T>(new int[size], default_delete<T[]>());  // 使用默认的删除器，default_delete是个struct，需要加()
}

// 可以用通过封装一个make_shared_array的方法来让他支持数组
shared_ptr<int> w = make_shared_array<int>(10);

陷阱

接下来介绍一些使用shared_ptr需要注意的陷阱

1.不要用一个原始指针初始化多个shared_ptr

int* ptr = new int;

shared_ptr<int> p1(ptr);

shared_ptr<int> p2(ptr); // logic error

shared_ptr<int> p2 = p1;  // this is good

2.不要在函数实参中创建shared_ptr

function (shared_ptr<int>(new int), g( ) ); // 有缺陷

因为C++的函数参数的计算顺序在不同的编译器不同的调用约定下可能是不一样的，一般是从右到左，但也有可能是从左到右，所以，可能的过程是先new int，然后调g（）。

3.通过shared_from_this（）返回this指针

不要将this指针作为shared_ptr返回出来，因为this指针本质上是一个裸指针，因此，这样可能会导致重复析构。

struct A
{
  shared_ptr<A>GetSelf()
  {
      return shared_ptr<A>(this);       // don't do this!
  }
};

struct A : enable_shared_from_this<A>
{
  shared_ptr<A>GetSelf()
  {
      return shared_from_this();
  }
};

4.避免循环引用

这个其实其实从逻辑层面上就出错了，不多做介绍，如果真的要这样，可以用weak_ptr来避免。

unique_ptr独占的智能指针

unique_ptr是一个独占型的智能指针，它不允许其他的智能指针共享其内部的指针，不允许通过赋值将一个unique_ptr赋值给另外一个unique_ptr。

unique_ptr不允许复制，但可以通过函数返回给其他的unique_ptr，还可以通过std：：move来转移到其他的unique_ptr，这样它本身就不再拥有原来指针的所有权了。

C++11目前还没有提供make_unique方法，在C++14中会提供和make_shared类似的make_unique来创建unique_ptr。

unique_ptr<int> myPtr(new int);                  // Okay
unique_ptr<int> myOtherPtr = std::move(myPtr); // Okay,
// unique_ptr<int> ptr = myPtr;                   // 错误，只能移动，不可复制

// unique_ptr指定删除器和std：：shared_ptr是有差别的，比如下面的写法：
std::shared_ptr<int> ptr(new int(1), [](int*p){delete p;});  // 正确
// std::unique_ptr<int> ptr(new int(1), [](int*p){delete p;});       // 错误
// std::unique_ptr指定删除器的时候需要确定删除器的类型
std::unique_ptr<int, void(*)(int*)> ptr2(new int(1), [](int*p){delete p;});  // 正确
// 需要注意的是lambda表达式在美被捕获的情况下，可以转换为函数指针，但是一旦捕获就不可以了，就不能这么实用了，以防万一，unique_ptr的第二个参数一律都改为function
std::unique_ptr<int, function<void(int*)>> ptr3(new int(1), [](int*p){delete p;});  // 正确

// 使用仿函数自定义删除器
unique_ptr<int, MyDeleter> ptr4(new int(4));

关于shared_ptr和unique_ptr的使用场景要根据实际应用需求来选择，如果希望只有一个智能指针管理资源或者管理数组就用unique_ptr，如果希望多个智能指针管理同一个资源就用shared_ptr。

weak_ptr弱引用的智能指针

弱引用指针weak_ptr是用来监视shared_ptr的，不会使引用计数加1，它不管理shared_ptr内部的指针，主要是为了监视shared_ptr的生命周期，更像是shared_ptr的一个助手。weak_ptr没有重载操作符*和->，因为它不共享指针，不能操作资源，主要是为了通过shared_ptr获得资源的监测权，它的构造不会增加引用计数，它的析构也不会减少引用计数，纯粹只是作为一个旁观者来监视shared_ptr中管理的资源是否存在。weak_ptr还可以用来返回this指针和解决循环引用的问题。

基本使用

// 使用use_count获取计数
shared_ptr<int> p(new int(4));
shared_ptr<int> p2 = p;
weak_ptr<int> w(p);
cout << w.use_count() << endl;
// 通过expired方法观察所观测资源是否被释放
// 还能用lock获取观测的指针
if (w.expired()) {
    cout << "pointer is expired." << endl;
} else {
    cout << *(w.lock()) << endl;
}

weak_ptr返回this指针

在上一小节节中提到不能直接将this指针返回为shared_ptr，需要通过派生std::enable_shared_from_this类，并通过其方法shared_from_this来返回智能指针，原因是std::enable_shared_from_this类中有一个weak_ptr，这个weak_ptr用来观测this智能指针，调用shared_from_this（）方法时，会调用内部这个weak_ptr的lock（）方法，将所观测的shared_ptr返回。

需要注意的是，获取自身智能指针的函数仅在shared_ptr的构造函数被调用之后才能使用，因为enable_shared_from_this内部的weak_ptr只有通过shared_ptr才能构造。

解决循环应用问题

这个我不想多做解释，因为我还是觉得逻辑设计成这样已经有些奇怪了，但用weak_ptr确实能解决这个问题。

线程/异步

线程

void f(string message){
    // 这里可以让线程休眠三秒，之后再打印
    std::this_thread::sleep_for(std::chrono::seconds(3));
    cout << "time out" << endl;
    cout << message << endl;
}
// 基础使用
void chap5_1() {
    thread t(f, "hello");    // 创建线程，线程接收任意个参数
    cout << t.get_id() << endl; // 获取当前线程id
    cout << thread::hardware_concurrency() << endl; // 获取当前cpu核数, 16
    t.join();   // join函数将会阻塞线程，直到线程函数执行结束，如果线程函数有返回值，返回值将被忽略。
    
    /**
     如果不希望线程被阻塞执行，可以调用线程的detach（）方法，将线程和线程对象分离。
     通过detach，线程就和线程对象分离了，让线程作为后台线程去执行，当前线程也不会阻塞了。但需要注意的是，detach之后就无法再和线程发生联系了，比如detach之后就不能再通过join来等待线程执行完，线程何时执行完我们也无法控制了。
     这里线程对象就是t，线程就是实际执行的线程
     */
    // t.detach();
    
    /**
     使用这种方式创建线程很方便，但需要注意的是，std：：thread出了作用域之后将会析构，这时如果线程函数还没有执行完则会发生错误，因此，需要保证线程函数的生命周期在线程变量std：：thread的生命周期之内。
     */
    
    // 线程不能复制，但可以移动
    thread t2(move(t)); // 移动之后，原先的线程t就不再代表任何线程对象了
}

互斥量

互斥量是一种同步原语，是一种线程同步的手段，用来保护多线程同时访问的共享数据。

C++11中提供了如下4种语义的互斥量（mutex）：

std::mutex：独占的互斥量，不能递归使用。

std::timed_mutex：带超时的独占互斥量，不能递归使用。

std::recursive_mutex：递归互斥量，不带超时功能。

std::recursive_timed_mutex：带超时的递归互斥量。

// mutex用法，lock()/unlock()就完事了
std::mutex g_lock;
void f2() {
    g_lock.lock();
    std::cout << "entered thread " << std::this_thread::get_id() << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "leaving thread " << std::this_thread::get_id() << std::endl;
    g_lock.unlock();
}

/**
 使用lock_guard可以简化lock/unlock的写法，同时也更安全，因为lock_guard在构造时会自动锁定互斥量，而在退出作用域后进行析构时就会自动解锁，从而保证了互斥量的正确操作，避免忘记unlock操作，因此，应尽量用lock_guard。
 
 lock_guard用到了RAII技术，这种技术在类的构造函数中分配资源，在析构函数中释放资源，保证资源在出了作用域之后就释放。
 */
void f3() {
   std::lock_guard< std::mutex> locker(g_lock); // 出作用域之后自动解锁
   std::cout << "entered thread " << std::this_thread::get_id() << std::endl;
   std::this_thread::sleep_for(std::chrono::seconds(1));
   std::cout << "leaving thread " << std::this_thread::get_id() << std::endl;
}

// recursive_mutex
// 递归锁允许同一线程多次获得该互斥锁，可以用来解决同一线程需要多次获取互斥量时死锁的问题。展示一个死锁的例子，虽然我觉得设计成这样，已经不是c++的问题了，是人的问题。
struct Complex {
     std::mutex mutex;
     int i;
     Complex() : i(0) {}
     void mul(int x) {
         std::lock_guard<std::mutex> lock(mutex);
         i *= x;
         
     }
     void div(int x) {
         std::lock_guard<std::mutex> lock(mutex);
         i /= x;
     }
     void both(int x, int y) {
         std::lock_guard<std::mutex> lock(mutex);
         mul(x);
         div(y);
     }
 };

// 最后一点，尽量别用递归锁
struct Complex {
    std::recursive_mutex mutex;
    int i;
    Complex() : i(0) {}
    void mul(int x) {
        std::lock_guard<std::recursive_mutex> lock(mutex);
        i *= x;
        
    }
    void div(int x) {
        std::lock_guard<std::recursive_mutex> lock(mutex);
        i /= x;
    }
    void both(int x, int y) {
        std::lock_guard<std::recursive_mutex> lock(mutex);
        mul(x);
        div(y);
    }
};

// 带超时的互斥量std::timed_mutex和std::recursive_timed_mutex
/**
 其实，就是上文的两个锁，设置了一个等待超时的时间，超过了这个时间就不用等了，干别的去，其实内部就是个while一直在等，别的细节还没有去了解。
 std::timed_mutex比std::mutex多了两个超时获取锁的接口：try_lock_for和try_lock_until，这两个接口是用来设置获取互斥量的超时时间，使用时可以用一个while循环去不断地获取互斥量。
 */

条件变量

条件变量是C++11提供的另外一种用于等待的同步机制，它能阻塞一个或多个线程，直到收到另外一个线程发出的通知或者超时，才会唤醒当前阻塞的线程。条件变量需要和互斥量配合起来用。

C++11提供了两种条件变量：

condition_variable，配合std：：unique_lock进行wait操作。
condition_variable_any，和任意带有lock、unlock语义的mutex搭配使用，比较灵活，但效率比condition_variable差一些。

条件变量的使用过程如下：

拥有条件变量的线程获取互斥量。
循环检查某个条件，如果条件不满足，则阻塞直到条件满足；如果条件满足，则向下执行。
某个线程满足条件执行完之后调用notify_one或notify_all唤醒一个或者所有的等待线程。

看个同步队列的例子

template<typename T>
class SyncQueue
{
public:
    SyncQueue(int maxSize) :m_maxSize(maxSize), m_needStop(false)
    {
    }

    void Put(const T&x)
    {
        Add(x);
    }

    void Put(T&&x)
    {
        Add(std::forward<T>(x));
    }

    void Take(std::list<T>& list)
    {
        std::unique_lock<std::mutex> locker(m_mutex);
        m_notEmpty.wait(locker, [this]{return m_needStop || NotEmpty(); });
        
        if (m_needStop)
            return;
        list = std::move(m_queue);
        m_notFull.notify_one();
    }

    void Take(T& t)
    {
        std::unique_lock<std::mutex> locker(m_mutex);
        m_notEmpty.wait(locker, [this]{return m_needStop || NotEmpty(); });
        
        if (m_needStop)
            return;
        t = m_queue.front();
        m_queue.pop_front();
        m_notFull.notify_one();
    }

    void Stop()
    {
        {
            std::lock_guard<std::mutex> locker(m_mutex);
            m_needStop = true;
        }
        m_notFull.notify_all();
        m_notEmpty.notify_all();
    }

    bool Empty()
    {
        std::lock_guard<std::mutex> locker(m_mutex);
        return m_queue.empty();
    }

    bool Full()
    {
        std::lock_guard<std::mutex> locker(m_mutex);
        return m_queue.size() == m_maxSize;
    }

    size_t Size()
    {
        std::lock_guard<std::mutex> locker(m_mutex);
        return m_queue.size();
    }

    int Count()
    {
        return m_queue.size();
    }
private:
    bool NotFull() const
    {
        bool full = m_queue.size() >= m_maxSize;
        if (full)
            cout << "full, waiting，thread id: " << this_thread::get_id() << endl;
        return !full;
    }

    bool NotEmpty() const
    {
        bool empty = m_queue.empty();
        if (empty)
            cout << "empty,waiting，thread id: " << this_thread::get_id() << endl;
        return !empty;
    }

    template<typename F>
    void Add(F&&x)
    {
        /** 原始代码如下，是一步一步变下去的
        std::lock_guard< std::mutex> locker(m_mutex);
        while (IsFull()) {
            cout << "缓冲区满了，需要等待..." <<endl;
            m_notFull.wait(m_mutex);    // 满的情况下,m_notFull一直处于等待状态
        }
        m_queue.push_back(x);
        m_notEmpty.notify_one();    // 不空了，激活一个
         */
        
        /**
         wait还有一个重载方法，可以接受一个条件。
         std::lock_guard<std::mutex> locker(m_mutex);
         m_notFull.wait(locker, [this]{return !IsFull();});
         */
        
        /**
         std::unique_lock和std::lock_guard的差别在于前者可以自由地释放mutex，而后者则需要等到std::lock_guard变量生命周期结束时才能释放。
         
         这里需要注意的是，wait函数中会释放mutex，而lock_guard这时还拥有mutex，它只会在出了作用域之后才会释放mutex，所以，这时它并不会释放，但执行wait时会提前释放mutex。
         
         这里应该用unique_lock，因为unique_lock不像lock_guard一样只能在析构时才释放锁，它可以随时释放锁，因此，在wait时让unique_lock释放锁从语义上看更加准确。
         */
        
        std::unique_lock<std::mutex> locker(m_mutex);
        m_notFull.wait(locker, [this]{return m_needStop || NotFull(); });
        if (m_needStop)
            return;

        m_queue.push_back(std::forward<F>(x));
        m_notEmpty.notify_one();
    }

private:
    std::list<T> m_queue; //缓冲区
    std::mutex m_mutex; //互斥量和条件变量结合起来使用
    std::condition_variable m_notEmpty;//不为空的条件变量
    std::condition_variable m_notFull; //没有满的条件变量
    int m_maxSize; //同步队列最大的size

    bool m_needStop; //停止的标志
};

原子变量

使用原子变量就不需要使用互斥量来保护该变量了，用起来更简洁。给个例子就懂了

struct Counter
{
    int value;
    std::mutex mutex;
    void increment()
    {
        std::lock_guard<std::mutex> lock(mutex);
        ++value;
        
    }
    void decrement()
    {
        std::lock_guard<std::mutex> lock(mutex);
        --value;
    }
    int get()
    {
        return value;
    }
};
// 如果食用了原子变量，就可以改成如下所示，会方便一些
struct AtomicCounter {
   std::atomic<int> value;
   void increment(){
      ++value;
   }
   void decrement(){
      --value;
   }
   int get(){
      return value.load();
   }
};

call_once/once_flag

为了保证在多线程环境中某个函数仅被调用一次，使用std::call_once时，需要一个once_flag作为call_once的入参。

std::once_flag flag;
void do_once() {
   std::call_once(flag, [](){ std::cout << "Called once" << std::endl; });
}

void chap5_5() {
    thread t1(do_once);
    thread t2(do_once);
    thread t3(do_once);
    t1.join();
    t2.join();
    t3.join();
    // Called once
}

异步操作

C++11提供了异步操作相关的类，主要有std：：future、std::promise和std::package_task。std::future作为异步结果的传输通道，可以很方便地获取线程函数的返回值；std::promise用来包装一个值，将数据和future绑定起来，方便线程赋值；std::package_task用来包装一个可调用对象，将函数和future绑定起来，以便异步调用。

future

首先介绍future，我想结合书上的原文和别处搜到的英文进行总结。

C++11中增加的线程，使得我们可以非常方便地创建和使用线程，但有时会有些不便，比如希望获取线程函数的返回结果，就不能直接通过thread.join（）得到结果，这时就必须定义一个变量，在线程函数中去给这个变量赋值，然后执行join（），最后得到结果，这个过程是比较烦琐的。thread库提供了future用来访问异步操作的结果，因为一个异步操作的结果不能马上获取，只能在未来某个时候从某个地方获取，这个异步操作的结果是一个未来的期待值，所以被称为future，future提供了获取异步操作结果的通道。我们可以以同步等待的方式来获取结果，可以通过查询future的状态（future_status）来获取异步操作的结果。

future_status有如下3种状态：

Deferred，异步操作还没开始。
Ready，异步操作已经完成。
Timeout，异步操作超时。

获取future结果有3种方式：get、wait、wait_for，其中get等待异步操作结束并返回结果，wait只是等待异步操作完成，没有返回值，wait_for是超时等待返回结果。

这段介绍是书上的原文，但是并没有很好的例子，从别的博客哪里找来了进一步的介绍和补充(英文的材料确实讲的更好…)

In this post, we are going to talk about futures, more precisely std::future. What is a future ? It’s a very nice and simple mechanism to work with asynchronous tasks. It also has the advantage of decoupling you from the threads themselves, you can do multithreading without using std::thread. The future itself is a structure pointing to a result that will be computed in the future. How to create a future ? The simplest way is to use std::async that will create an asynchronous task and return a std::future.

auto future = std::async(std::launch::async, [](){
   std::cout << "I'm a thread" << std::endl;
});

future.get();
// 这里的async函数返回值是一个future，第一个参数是执行的策略，第二个参数执行的函数。

Nothing really special here. std::async will execute the task that we give it (here a lambda) and return a std::future. Once you use the get() function on a future, it will wait until the result is available and return this result to you once it is. The get() function is then blocking. Since the lambda, is a void lambda, the returned future is of type std::future and get() returns void as well. It is very important to know that you cannot call get several times on the same future. Once the result is consumed, you cannot consume it again! If you want to use the result several times, you need to store it yourself after you called get().

这里提到了一点，同一个future，通过get的返回值，只能拿一次，之后就拿不到了，要重复使用返回结果，需要自己存储。

auto future = std::async(std::launch::async, [](){
   std::this_thread::sleep_for(std::chrono::seconds(5));
   return 42;
});

// Do something else ?

std::cout << future.get() << std::endl;

This time, the future will be of the time std::future and thus get() will also return an int. std::async will again launch a task in an asynchronous way and future.get() will wait for the answer. What is interesting, is that you can do something else before the call to future.

But get() is not the only interesting function in std::future. You also have wait() which is almost the same as get() but does not consume the result. For instance, you can wait for several futures and then consume their result together. But, more interesting are the wait_for(duration) and wait_until(timepoint) functions. The first one wait for the result at most the given time and then returns and the second one wait for the result at most until the given time point. I think that wait_for is more useful in practices, so let’s discuss it further. Finally, an interesting function is bool valid(). When you use get() on the future, it will consume the result, making valid() returns :code:`false. So, if you intend to check multiple times for a future, you should use valid() first.

这里介绍了wait,wait_for,wait_until,valid等函数以及它们的作用。


auto f1 = std::async(std::launch::async, [](){
    std::this_thread::sleep_for(std::chrono::seconds(9));
    return 42;
});

auto f2 = std::async(std::launch::async, [](){
    std::this_thread::sleep_for(std::chrono::seconds(3));
    return 13;
});

auto f3 = std::async(std::launch::async, [](){
    std::this_thread::sleep_for(std::chrono::seconds(6));
    return 666;
});

auto timeout = std::chrono::milliseconds(10);

while(f1.valid() || f2.valid() || f3.valid()){
    if(f1.valid() && f1.wait_for(timeout) == std::future_status::ready){
        std::cout << "Task1 is done! " << f1.get() << std::endl;
    }

    if(f2.valid() && f2.wait_for(timeout) == std::future_status::ready){
        std::cout << "Task2 is done! " << f2.get() << std::endl;
    }

    if(f3.valid() && f3.wait_for(timeout) == std::future_status::ready){
        std::cout << "Task3 is done! " << f3.get() << std::endl;
    }

    std::cout << "I'm doing my own work!" << std::endl;
    std::this_thread::sleep_for(std::chrono::seconds(1));
    std::cout << "I'm done with my own work!" << std::endl;
}

std::cout << "Everything is done, let's go back to the tutorial" << std::endl;

// 这是一个极其全面的例子，需要好好理解。

std::promise、std::packaged_task和std::future三者之间的关系

对于future已经介绍了很多了，但是promise，packaged_task，书上的解释有点抽象，直接从给的代码里分析他们的作用。

std::future提供了一个访问异步操作结果的机制，它和线程是一个级别的，属于低层次的对象。在std::future之上的高一层是std::packaged_task和std::promise，它们内部都有future以便访问异步操作结果，std::packaged_task包装的是一个异步操作，而std::promise包装的是一个值，都是为了方便异步操作，因为有时需要获取线程中的某个值，这时就用std::promise，而有时需要获一个异步操作的返回值，这时就用std::packaged_task。

但其实我们在介绍future中，已经介绍了async。std::async比std::promise、std::packaged_task和std::thread更高一层，它可以用来直接创建异步的task，异步任务返回的结果也保存在future中，当需要获取异步任务的结果时，只需要调用future.get（）方法即可，如果不关注异步任务的结果，只是简单地等待任务完成的话，则调用future.wait（）方法。这应该作为我们的首选。

// a simple task:
void chap5_6() {
    std::packaged_task<int(int)> tsk ([](int x) -> int {return x+2;});
    std::future<int> fut = tsk.get_future();        // 获取future
    std::thread(std::move(tsk),2).detach();       // task作为线程函数
    int value = fut.get();                                // 等待“task完成并获取结果
    std::cout <<"The result is "<< value <<".\n";
    // std::future是不能复制的，不能放到容器中，需要用shared_future
    vector<std::future<int>> v;
    v.emplace_back(std::async(std::launch::async,[](int a,int b){return a + b;},2,3));
    std::cout << "The shared_futureresult is " << v[0].get() << '\n';
    
    vector<std::shared_future<int>> v2;
    v2.push_back(std::async(std::launch::async,[](int a,int b){return a + b;},3,3));
    std::cout << "The shared_futureresult is " << v2[0].get() << '\n';
}

C++四种类型转换运算符

学习链接：http://c.biancheng.net/cpp/biancheng/view/3297.html

从上面扒下来的，做个简单的笔记，以后尽可能使用cast，养成好的习惯。

static_cast

static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说，不能将 const/volatile 类型转换为非 const/volatile 类型。

static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

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

class Complex{
public:
    Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
public:
    operator double() const { return m_real; }  //类型转换函数
private:
    double m_real;
    double m_imag;
};

int main(){
    //下面是正确的用法
    int m = 100;
    Complex c(12.5, 23.8);
    long n = static_cast<long>(m);  //宽转换，没有信息丢失
    char ch = static_cast<char>(m);  //窄转换，可能会丢失信息
    int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) );  //将void指针转换为具体类型指针
    void *p2 = static_cast<void*>(p1);  //将具体类型指针，转换为void指针
    double real= static_cast<double>(c);  //调用类型转换函数
   
    //下面的用法是错误的
    float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换
    p3 = static_cast<float*>(0X2DF9);  //不能将整数转换为指针类型

    return 0;
}

dynamic_cast

当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。

#include <iostream>
using namespace std;

class A{
public:
    virtual void func() const { cout<<"Class A"<<endl; }
private:
    int m_a;
};

class B: public A{
public:
    virtual void func() const { cout<<"Class B"<<endl; }
private:
    int m_b;
};

class C: public B{
public:
    virtual void func() const { cout<<"Class C"<<endl; }
private:
    int m_c;
};

class D: public C{
public:
    virtual void func() const { cout<<"Class D"<<endl; }
private:
    int m_d;
};

int main(){
    A *pa = new A();
    B *pb;
    C *pc;
   
    //情况①
    pb = dynamic_cast<B*>(pa);  //向下转型失败
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型失败
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    cout<<"-------------------------"<<endl;
   
    //情况②
    pa = new D();  //向上转型都是允许的
    pb = dynamic_cast<B*>(pa);  //向下转型成功
    if(pb == NULL){
        cout<<"Downcasting failed: A* to B*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to B*"<<endl;
        pb -> func();
    }
    pc = dynamic_cast<C*>(pa);  //向下转型成功
    if(pc == NULL){
        cout<<"Downcasting failed: A* to C*"<<endl;
    }else{
        cout<<"Downcasting successfully: A* to C*"<<endl;
        pc -> func();
    }
   
    return 0;
}

这个例子配合着上面的图，还是很好理解的。

const_cast

const_cast 比较好理解，它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。

#include <iostream>
using namespace std;

int main(){
    const int n = 100;
    int *p = const_cast<int*>(&n);
    *p = 234;
    cout<<"n = "<<n<<endl;
    cout<<"*p = "<<*p<<endl;

    return 0;
}

reinterpret_cast

可以用 reinterpret_cast 来完成，两个具体类型指针之间的转换、int 和指针之间的转换（有些编译器只允许 int 转指针，不允许反过来）。

#include <iostream>
using namespace std;

class A{
public:
    A(int a = 0, int b = 0): m_a(a), m_b(b){}
private:
    int m_a;
    int m_b;
};

int main(){
    //将 char* 转换为 float*
    char str[]="http://c.biancheng.net";
    float *p1 = reinterpret_cast<float*>(str);
    cout<<*p1<<endl;
    //将 int 转换为 int*
    int *p = reinterpret_cast<int*>(100);
    //将 A* 转换为 int*
    p = reinterpret_cast<int*>(new A(25, 96));
    cout<<*p<<endl;
   
    return 0;
}

C++11中的工具

时间库chrono

这个等要看了，看看就好了。

数值类型和字符串的相互转换

给个例子就好，不过很多我在mac上是失败了，做一个简单了解就可以了。

#include <iostream>
#include <string>
#include <codecvt>
#include <locale>

using namespace std;

int main() {
    // 转换成string
    int x = 12345;
    cout << to_string(x) << endl;
    // 字符串利用atoi,atoll,atol,atof可以穿换成int,long long,long float
    // 注意是字符串，不能是string
    char* s = "3.14";
    string s2 = "123.123";
    cout << atof(s) << endl;
    cout << stof(s2) << endl;   // sto就可以转换string了

    // C++11还增加了宽字符的转换，就先当unicode好了，支持中文了
    // 宽窄sting转换
    // wstring_convert<codecvt<wchar_t, char, mbstate_t>> converter(new codecvt<wchar_t, char, mbstate_t>("CHS")); error
    wstring str = L"我是xiaoyuyu";
    // wcout.imbue(std::locale("chs")); error
    wcout << str << endl;
    // string narrow = converter.to_bytes(str);
    // cout << narrow << endl;
    // cout << converter.to_bytes(narrow) << endl;
    return 0;
}

C++11的一些其余特性

委托构造函数

委托构造函数允许在同一个类中一个构造函数可以调用另外一个构造函数，从而可以在初始化时简化变量的初始化。

class class_c {
public:
    int max;
    int min;
    int middle;
    class_c(int my_max) {
        max = my_max > 0 ? my_max : 10;
   }
    class_c(int my_max, int my_min) : class_c(my_max) {
        min = my_min > 0 && my_min < max ? my_min : 1;
   }
   class_c(int my_max, int my_min, int my_middle) : class_c(my_max, my_min){
       middle = my_middle < max && my_middle > min ? my_middle :5;
    }
};

这里只要注意委托构造函数，不要循环调用就可以了，这点一般性不会发生。但是另一点需要注意，使用了代理构造函数就不能用类成员初始化了。

class class_a {
public:
    class_a() {}
    // member initialization here, no delegate
    class_a(string str) : m_string{ str } {}
    
    // 调用了委托构造函数，不能用类成员初始化了
    // error C3511: a call to a delegating constructor shall be the only member-initializer
    // class_a(string str, double dbl) : class_a(str) ,m_double{ dbl } {}
    
    // 只能通过成员赋值来初始化
    class_a(string str, double dbl) : class_a(str) { m_double = dbl; }
    double m_double{ 1.0 };
    string m_string;
};

继承构造函数

struct Base {
    int x;
    double y;
    string s;
    Base(int i) :x(i), y(0){}
    Base(int i, double j) :x(i), y(j){}
    Base(int i, double j, const string& str) :x(i), y(j),s(str){}
};

struct Derived : Base {};
int main()
{
    Derived d(1,2.5,"ok"); // 编译错误，没有合适的构造函数
}

这个报错的原因是：通过基类的构造函数去构造派生类对象是不合法的，因为派生类的默认构造函数隐藏了基类，比较常见的争取用法如下。

struct Derived : Base {
    Derived(int i) : Base(i){};
    Derived(int i, double j) : Base(i, j){};
    Derived(int i, double j, const string& str) : Base(i, j, str){};
};

在派生类中重新定义和基类一致的构造函数的方法虽然可行，但是很烦琐且重复，C++11的继承构造函数特性正是用于解决派生类隐藏基类同名函数的问题的，可以通过using Base：：SomeFunction来表示使用基类的同名函数，通过using Base：：Base来声明使用基类构造函数。

1
2
3

struct Derived2 : Base {
    using Base::Base;   // 声明使用基类构造函数
};

原始字面量

这个其实就和markdown里的输入的字符串原样输出的功能类似，只要使用R”xxx(raw string)xxx”的格式即可，其中raw string会原样输出，跑个例子就可以了。

void chap7_2() {
    string s =
    R"(<HTML>
    <HEAD>
    <TITLE>This is a test</TITLE>
    </HEAD>
    <BODY>
    <P>Hello, C++ HTML World!</P>
    </BODY>
</HTML>
)";
    cout << s << endl;
}

final和override

final

看到final还是很亲切的，毕竟我是java转过来的，在c++11中，final的作用和java的类似，但又有些不同。

C++11中增加了final关键字来限制某个类不能被继承，或者某个虚函数不能被重写。如果修饰函数，final只能修饰虚函数，并且要放到类或者函数的后面。

struct A {
     // A::foo is final，限定该虚函数不能被重写
     virtual void foo() final;
     
     // Error: non-virtual function cannot be final，只能修饰虚函数
     void bar() final;
 };

 struct B final : A {
     // struct B is final
     // Error: foo cannot be overridden as it's final in A
     void foo();
 };

 struct C : B {
     // Error: B is final
 };

override

override关键字确保在派生类中声明的重写函数与基类的虚函数有相同的签名，同时也明确表明将会重写基类的虚函数，还可以防止因疏忽把本来想重写基类的虚函数声明成重载。这样，既可以保证重写虚函数的正确性，又可以提高代码的可读性。它的用法和Java、C#中的用法类似，区别是override关键字和final关键字一样，需要放到方法后面。

struct A {
    virtual void func(){}
};
struct D: A {
    // 显式重写
    void func() override {}
};

内存对齐

这个知识点，之前其实已经了解过了，再进一步学习一下，记一下笔记。

struct MyStruct {
    char a;             // 1 byte
    int b;              // 4 bytes
    short c;            // 2 bytes
    long long d;        // 8 bytes
    char e;             // 1 byte
};

void chap7_4() {
    cout << sizeof(MyStruct) << endl;   // 32字节，并不是16，因为实际结构如下
}

struct MyStruct
 {
     char a;             // 1 byte
     char pad_0[3];      // Padding 3
     int b;              // 4 bytes
     short c;            // 2 bytes
     char pad_1[6];      // Padding 6
     long long d;        // 8 bytes
     char e;             // 1 byte
     char pad_2[7];      // Padding 7
 };
/**  
 这里字节数最大的类型是8，所以整个类必须是8的倍数，同时每个成员之间还需要进行对齐。
 我们可以在gcc+32位Linux中尝试计算sizeof（MyStruct），得到的结果是24。这是因为gcc中的对齐规则和MSVC不一样，不同的平台下会使用不同的默认对齐值。在gcc+32位Linux中，大小超过4字节的基本类型仍然按4字节对齐。
 1.基本类型的对齐值就是其sizeof值;
 2.结构体的对齐值是其成员的最大对齐值;
 3.编译器可以设置一个最大对齐值，怎么类型的实际对齐值是该类型的对齐值与默认对齐值取最小值得来。
 */

利用alignas指定内存对齐大小

alignas(32) long long a = 0;
#define XX 1
struct alignas(XX) MyStruct_1 {};       // OK
template <size_t YY = 1>
struct alignas(YY) MyStruct_2 {};       // OK
static const unsigned ZZ = 1;
struct alignas(ZZ) MyStruct_3 {};       // OK

需要注意的是alignas只能改大不能改小 [2] 。如果需要改小，比如设置对齐数为1，仍然需要使用#pragma pack。但微软不支持改小，那就算了。

利用alignof和std：：alignment_of获取内存对齐大小，这个我在第一篇笔记的option中有介绍过，就不做赘述了。

c++11一些新增加的算法直接看书上的介绍就好，也不展开了。

本文作者： xiaoyuyu
本文链接： http://woaixiaoyuyu.github.io/2022/03/30/%E6%B7%B1%E5%85%A5%E5%BA%94%E7%94%A8C++11%EF%BC%9A%E4%BB%A3%E7%A0%81%E4%BC%98%E5%8C%96%E4%B8%8E%E5%B7%A5%E7%A8%8B%E7%BA%A7%E5%BA%94%E7%94%A8--note2/
版权声明： 本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。转载请注明出处！