第五章：C++新特性（2）

目录

一、C++右值引用与转移语义

二、weak_ptr是否可以知道对象计数为0？

三、weak_ptr如何解决shared_ptr的循环引用问题？

四、shared_ptr线程安全性

五、智能指针是否存在内存泄露的情况？

六、C++的四种类型转换

        1、const_cast

        2、static_cast

        3、dynamic_cast

        4、reinterpret_cast

七、C++中auto的用法

        1、基本使用方法

        2.auto和const结合使用

        3、使用auto定义迭代器

        4、用于泛型编程

八、C++11中的可变参数模板特性

---

一、C++右值引用与转移语义

        1、右值引用

        一般来说，不能取地址的表达式，就是右值引用，能取地址的，就是左值。

class A { };
A & r = A(); //error,A()是无名变量，是右值
A && r = A(); //ok,r是右值引用

        2、转移语义

        move本意为“移动”，但该函数并不能移动任何数据，它的功能是将某个左值强制转化为右值。基于move()函数特殊的功能，其常用于实现移动语义。

二、weak_ptr是否可以知道对象计数为0？

        不可以。

        weak_ptr是一种不控制对象生命周期的智能指针，它指向一个shared_ptr管理的对象。进行该对象管理的是那个引用的shared_ptr。weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr设计的目的只是为了配合shared_ptr而引入的一种智能指针。它只可以从一个shared_ptr或者另一个weak_ptr对象构造，它的构造和析构不会引起计数的增加或减少。

三、weak_ptr如何解决shared_ptr的循环引用问题？

        为了解决循环引用导致的内存泄露，引入了弱指针weak_ptr。weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但是不会指向引用计数的共享内存，但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。

四、shared_ptr线程安全性

        多线程环境下，调用不同shared_ptr实例的成员函数是不需要额外的同步手段的，即使这些shared_ptr拥有的是同样的对象。但是如果多线程访问（有写操作）同一个shared_ptr，则需要同步，否则就会有race condition发生。也可以使用shared_ptr overloads of atomic functions 来防止race condition的发生。

        多个线程同时读同一个shared_ptr对象是线程安全的，但是如果多个线程对同一个shared_ptr对象进行读和写，则需要加锁。

        多线程读写shared_ptr所指向的同一个对象，不管是相同的shared_ptr对象，还是不同的shared_ptr对象，也需要加锁保护。示例如下：

//程序实例
shared_ptr<long> global_instance = make_shared<long>(0);
std::mutex g_i_mutex;

void thread_fcn()
{
    //std::lock_guard<std::mutex> lock(g_i_mutex);
    //shared_ptr<long> local = global_instance;
    for(int i = 0; i < 100000000; i++)
    {
        *global_instance = *global_instance + 1;
        //*local = *local + 1;
    }
}


int main(int argc, char** argv)
{
    thread thread1(thread_fcn);
    thread thread2(thread_fcn);
    
    thread1.join();
    thread2.join();
        
    cout << "*global_instance is " << *global_instance << endl;
    
    return 0;
}

        在线程函数thread_fcn的for循环中，2个线程同时对global_instance进行加1的操作。这就是典型的非线程安全的场景，最后的结果是未定的，运行结果如下：

*global_instance is 197240539

        如果使用的是每个线程的局部shared_ptr对象local，因为这些local指向相同的对象，因此结果也是未定的，运行结果如下：

*global_instance is 160285803

        因此，这种情况下必须加锁，将thread_fcn中的第一行代码的注释去掉之后，不管是使用 global_instance，还是使用local，得到的结果都是：

*global_instance is 200000000

五、智能指针是否存在内存泄露的情况？

        智能指针存在内存泄露的情况。

        1、当两个对象同时使用一个shared_ptr成员变量指向对方，会造成循环引用，使得引用计数失效，从而导致内存泄露。

        2、为了解决循环引用导致的内存泄露，引入弱指针weak_ptr，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似于一个普通指针，但是不会指向引用计数的共享内存，但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。

//程序实例
#include <memory>
#include <iostream>
using namespace std;

class Child;
class Parent{
private:
    std::shared_ptr<Child> ChildPtr;
public:
    void setChild(std::shared_ptr<Child> child){
        this->ChildPtr = child;
    }

    void doSomething(){
        if(this->ChildPtr.use_count()){
        }
    }

    ~Parent(){
    }
};

class Child{
private:
    std::shared_ptr<Parent> ParentPtr;
public:
    void setParent(std::shared_ptr<Parent> parent){
        this->ParentPtr = parent;
    }
    
    void doSomething(){
        if(this->ParentPtr.use_count()){
        }
    }
    ~Child(){
    }
};


int main(){
    std::weak_ptr<Parent> wpp;
    std::weak_ptr<Child> wpc;
    {
        std::shared_ptr<Parent> p(new Parent);
        std::shared_ptr<Child> c(new Child);
        p->setChild(c);
        c->setPartent(p);
        wpp = p;
        wpc = c;
        std::cout << p.use_count() << std::endl;
        std::cout << c.use_count() << std::endl;
    }
    std::cout << wpp.use_count() << std::endl;
    std::cout << wpc.use_count() << std::endl;
    return 0;
}

/* 程序运行结果：
    2
    2
    1
    1
*/

        上述代码中，parent有一个shared_ptr类型的成员指向孩子， 而child也有一个shared_ptr类型的成员指向父亲。然后在创建孩子和父亲对象时也使用了智能指针c和p，随后将c和p分别又赋值给child的智能指针成员parent和parent的智能指针成员child，从而形成了一个循环引用。 

六、C++的四种类型转换

        C++中的四种类型转换分别为：const_cast、static_cast、dynamic_cast、reinterpret_cast，四种转换的功能如下：

        1、const_cast

        将const变量转为非const。

        2、static_cast

        最常用，可以用于各种隐式转换。比如非const转const，static_cast可以用于类向上转换，但向下转换能成功但是不安全。

        3、dynamic_cast

        只能用于含有虚函数的类转换，用于类向上和向下转换。

        向上转换：指子类向基类转换。

        向下转换：指基类向子类转换。

这两种转换，子类包含父类，当父类转换成子类时可能出现非法内存访问的问题。

        dynamic_cast通过判断变量运行时类型和要转换的类型是否相同来判断是否能够进行向下转换。 dynamic_cast可以做类之间上下转换，转换的时候会进行类型检查，类型相等成功转换，类型不等转换失败。运用RTTI技术，RTTI是”Runtime Type Information”的缩写，意思是运行时类型信息，它提供了运行时确定对象类型的方法。在c++层面主要体现在dynamic_cast和typeid，vs中虚函数表的-1位置存放了指向type_info的指针，对于存在虚函数的类型，dynamic_cast和typeid都会去查询type_info。

        4、reinterpret_cast

        可以做任何类型的转换，不过不对转换结果保证，容易出问题。

注意：为什么不用C的强制转换：C的强制转换表面上看起来功能强大，但是转换不够明确，不能进行错误检查，容易出错。

七、C++中auto的用法

        auto用于定义变量，编译器可以自动判断变量的类型。auto主要有以下几种用法：

        1、基本使用方法

auto name = value; //name 是变量的名字，value是变量的初始值

注意：auto仅仅是一个占位符，在编译期间它会被真正的类型所替代。或者说，C++中的变量必须是有明确类型的，只是这个类型是由编译器自己推导出来的。

auto n = 10;
auto f = 12.8;
auto p = &n;
auto url = "www.123.com";

a. 第 1 行中，10 是一个整数，默认是 int 类型，所以推导出变量 n 的类型是 int。

b. 第 2 行中，12.8 是一个小数，默认是 double 类型，所以推导出变量 f 的类型是 double。

c. 第 3 行中，&n 的结果是一个 int* 类型的指针，所以推导出变量 f 的类型是 int*。

d. 第 4 行中，由双引号 "" 包围起来的字符串是 const char* 类型，所以推导出变量 url 的类型是 const char*，也即一个常量指针。

        2.auto和const结合使用

        ①当类型不为引用时，auto的推导结果将不保留表达式的const属性；

        ②当类型为引用时，auto的推导结果将保留表达式的const属性。

int x = 0;
const auto n = x; //n 为 const int ，auto 被推导为 int
auto f = n; //f 为 const int，auto 被推导为 int（const 属性被抛弃）
const auto &r1 = x; //r1 为 const int& 类型，auto 被推导为 int
auto &r2 = r1; //r1 为 const int& 类型，auto 被推导为 const int 类型

a. 第 2 行代码中，n 为 const int，auto 被推导为 int。

b. 第 3 行代码中，n 为 const int 类型，但是 auto 却被推导为 int 类型，这说明当 = 右边的表达式带有 const 属性时，auto 不会使用 const 属性，而是直接推导出 non-const 类型。

c. 第 4 行代码中，auto 被推导为 int 类型，这个很容易理解，不再赘述。

d. 第 5 行代码中，r1 是 const int & 类型，auto 也被推导为 const int 类型，这说明当 const 和引用结合时，auto 的推导将保留表达式的 const 类型。

        3、使用auto定义迭代器

        在使用STL容器时，需要使用迭代器来遍历容器里面的元素，不同容器的迭代器有不同类型，在定义迭代器时必须指明。迭代器的类型有时候比较复杂，如：

#include <vector>
using namespace std;

int main(){
    vector< vector<int> > v;
    //vector< vector<int> >::iterator i = v.begin();
    auto i = v.begin(); //使用 auto 代替具体的类型,该句比上一句简洁,根据表达式v.begin() 的类型（begin() 函数的返回值类型）来推导出变量i的类型
    return 0;
}

        4、用于泛型编程

        auto的另一个应用是当我们不知道变量是什么类型或者不希望指明具体类型的时候，比如泛型编程中。如：

#include <iostream>
using namespace std;

class A{
public:
    static int get(void){
        return 100;
    }
};

class B{
public:
    static const char* get(void){
        return "www.123.com";
    }
};

template <typename T>
void func(void){
    auto val = T::get();
    cout << val << endl;
}


int main(void){
    func<A>();
    func<B>();
    return 0;
}


/* 运行结果：
    100
    www.123.com
*/

        本例中的模板函数 func() 会调用所有类的静态函数 get()，并对它的返回值做统一处理，但是 get() 的返回值类型并不一样，而且不能自动转换。这种要求在以前的 C++ 版本中实现起来非常的麻烦，需要额外增加一个模板参数，并在调用时手动给该模板参数赋值，用以指明变量 val 的类型。但是有了 auto 类型自动推导，编译器就根据 get() 的返回值自己推导出 val 变量的类型，就不用再增加一个模板参数了。

八、C++11中的可变参数模板特性

        可变参数模板（variadic template）使得编程者能够创建这样的模板函数和模板类，即可接受可变数量的参数。例如要编写一个函数，它可接受任意数量的参数，参数的类型只需要是cout能显示的即可，并将参数显示为用逗号分隔的列表。

int n = 14;
double x = 2.71828

std::string mr = "Mr.String objects!";
show_list(n,x);
show_list(x*x, '!', 7, mr);  //这里的目标是定义show_list()


/* 运行结果：
    14, 2.71828
    7.38905， !, 7, Mr.String objects!
*/

        要创建可变参数模板，需要理解几个要点：

        ①模板参数包（parameter pack）；

        ②函数参数包；

        ③展开（unpack）参数包；

        ④递归。