条款6：auto推导若非己愿，使用显式类型初始化惯用法

一、代理类

所谓的代理类就是以模仿和增强一些类型的行为为目的存在的类

class MyArray
{
public:class MyArraySize{public:MyArraySize(int size) : theSize(size) {}int size() const { return theSize; }operator int() const { return theSize; }private:int theSize;};MyArray(MyArraySize size) : size_(size), data_(new int[size.size()]) {}int operator[](int index){return data_[index];}bool operator==(const MyArray &temp){return data_ == temp.data_;}MyArraySize size() { return size_; }private:int *data_;MyArraySize size_;
};class MyArray_
{
public:// C++ 11之前没有explicitMyArray_(int size) : size_(size), data_(new int[size]) {}private:int *data_;int size_;
};void func1(MyArray arr)
{
}void func2(MyArray_ arr)
{
}int main()
{func2(10);func1(10);  // 错误，不能进行两次类型转换func1(MyArray(10)); // 通过代理类，可以避免上面隐式转换的情况return 0;myArray arr(10);auto size = arr.size();  // auto 推导为MyArray::MyArraySizeint size_ = arr.size();  // 因为存在operator int()隐式类型转换
}

二、临时变量的引用不要用引用来接

#include <vector>
#include <iostream>class A
{
public:A() { std::cout << "A::A()" << std::endl; }A(int data) : _data(data) { std::cout << "A::A(int data)" << std::endl; }A(const A &a) : _data(a._data){std::cout << "A::A(const A &a)" << std::endl;}A(A &&a) : _data(a._data){std::cout << "A::A(A &&a)" << std::endl;}~A() { std::cout << "A::~A()" << std::endl; }int _data{100};
};std::vector<A> func()
{return {A(1), A(2), A(3), A(4), A(5)};
}int main()
{A aaa = func()[2];    // 发生拷贝A &bbb = func()[3];   // 错误，引用了一个临时变量return 0;
}

#include <vector>
#include <iostream>std::vector<bool> features()
{return {true, true, true, false, false};
}int main()
{bool highPriority = features()[4];auto highPriority = features()[4]; // 错误写法，推导为引用类型的代理类// auto推到为std::vector<bool>::reference// reference在vector中其实是一个代理类auto highPriority_ = static_cast<bool>(features()[4]);return 0;
}

三、expressin template

#include <cassert>
#include <iostream>
#include <vector>template <typename Derived>
void func(Base<Derived> derived)
{derived.name();
}// https://blog.csdn.net/HaoBBNuanMM/article/details/109740504
// CRTP中的基类模板
template <typename E>
class VecExpression
{
public:// 通过将自己static_cast成为子类，调用子类的对应函数实现实现静态多态double operator[](size_t i) const { return static_cast<E const &>(*this)[i]; }size_t size() const { return static_cast<E const &>(*this).size(); }
};// 将自己作为基类模板参数的子类 - 对应表达式编译树中的叶节点
class Vec : public VecExpression<Vec>
{std::vector<double> elems;public:double operator[](size_t i) const { return elems[i]; }double &operator[](size_t i) { return elems[i]; }size_t size() const { return elems.size(); }Vec(size_t n) : elems(n) {}Vec(std::initializer_list<double> init){for (auto i : init)elems.push_back(i);}// 赋值构造函数可以接受任意父类VecExpression的实例，并且进行表达式的展开// （对应表达式编译树中的赋值运算符节点）template <typename E>Vec(VecExpression<E> const &vec) : elems(vec.size()){for (size_t i = 0; i != vec.size(); ++i){elems[i] = vec[i];}}
};// 将自己作为基类模板参数的子类 - 对应表达式编译树中的二元运算符输出的内部节点
// 该结构的巧妙之处在于模板参数E1 E2可以是VecSum，从而形成VecSum<VecSum<VecSum ... > > >的嵌套结构，体现了表达式模板的精髓：将表达式计算改造成为了构造嵌套结构
template <typename E1, typename E2>
class VecSum : public VecExpression<VecSum<E1, E2>>
{E1 const &_u;E2 const &_v;public:VecSum(E1 const &u, E2 const &v) : _u(u), _v(v){assert(u.size() == v.size());}double operator[](size_t i) const { return _u[i] + _v[i]; }size_t size() const { return _v.size(); }
};// 对应编译树上的二元运算符，将加法表达式构造为VecSum<VecSum... > >的嵌套结构
template <typename E1, typename E2>
VecSum<E1, E2> const operator+(E1 const &u, E2 const &v)
{return VecSum<E1, E2>(u, v);
}// 主函数入口
int main()
{// 创建3个叶子节点Vec v0 = {1.0, 1.0, 1.0}; Vec v1 = {2.0, 2.0, 2.0}; Vec v2 = {3.0, 3.0, 3.0}; auto v4 = v0 + v1;  //auto 推导为VecSum<Vec, Vec> v4，这也是一个代理类// 如果想要的不是这种类型// 解决方案1Vec v4 = v0 + v1;// 解决方案2auto v4 =static_cast<Vec>( v0 + v1);return 0;
}