1_auto类型推导(深入应用C++11:代码优化与工程级应用)

1. auto回顾

在深入学习auto前,本人已经了解了auto的基本用法,对于简单类型推导能够清晰理解.如:

int i = 0;
auto ii = 1;    // auto被推导为int
auto iii = i;   // auto被推导为int

本次学习是为了加深细节理解,如:auto 与指针\引用\cv限定符一起使用时的推导结果.

回顾下简单类型的推导及使用auto时需要注意哪些.

int int_type = 1;               //int       auto被推导为int
float float_type = 1.0;         //float     auto被推导为float
const int const_int_type = 1;   //int const auto被推导为int
auto auto_int = 1;              //int       auto被推导为int
auto auto_double = 1.0;         //double    auto被推导为double

auto x= 5;                      //int       auto被推导为int
auto pi = new auto(1);          //int*      auto被推导为int*
const auto *v = &x, u=6;        //v:int const *    auto 被推导为 int
                                //u:int const      auto 被推导为 int
static auto y = 0.0;            //double           auto被推导为double
auto int r;         // error:two or more data types in declaration of 'r' 
int int r;          // error:two or more data types in declaration of 'r'
auto s;             // error:declaration of 'auto s' has no initializer

需要注意的是:

const auto *v = &x, u=6;
//在推导的时候u必须赋值,且所赋的值不能让auto推导产生二义性,否则无法通过编译
/**u 必须要赋值,否则就等价 const auto u;// error
    * 如:const auto *v = &x, u;
    * error: declaration of variable 'u' with deduced type 'const auto' requires an initializer
    */
/**并且u的初始化不能是编译器推导产生二义性,否则编译失败.
    * 如:const auto *v = &x, u =6.0;
    * error: 'auto' deduced as 'int' in declaration of 'v' and deduced as 'double' in declaration of 'u'
    */

由上面的例子可以看出来,auto并不能代表一个实际的类型声明(如s的编译错误),只是一个类型声明的"占位符".

使用auto声明的变量必须马上初始化,以上编译器推断出它的实际类型,并在编译时将auto占位符替换为真正的类型.

2. auto推导规则

int x = 0;
auto * a = &x;          // int* auto被推导为int
auto   b = &x;          // int* auto被推导为int*
auto & c = x;           // int& auto被推导为int
auto   d = c;           // int  auto被推导为int

const auto e = x;       // int const   auto被推导为int
auto   f = e;           // int         auto被推导为int
const auto & g = x;     // int const & auto被推导为int
auto & h = g;           // int const & auto被推导为int const

const auto * gg = &x;   // int const * auto被推导为int
auto * hh = gg;         // int const * auto被推导为int const

由上面的例子可以看出:

a和c的推导结果是很显然的, auto在编译的时候被替换为int, 因此a和c分别被推导为int*和int&.
b的推导结果说明, 其实auto不声明为指针, 也可以推导出指针类型.
d的推导结果说明, 当表达式是一个引用类型时, auto会把引用类型抛弃, 直接推导成原始类型int.
e的推导结果说明, 当表达式带有const(实际上volatile也会得到同样的结果)属性时, auto会把const属性抛弃掉, 推导成non-const类型int.
g/h的推导说明, 当auto和引用(换成指针在这里也将得到同样的结果, 如:用gg推导hh)结合时, auto的推导将保留表达式的const属性.

通过上面一系列示例, 可以得到下面两条规则:

当不声明为指针或引用时, auto的推导结果和初始化表达式抛弃引用和cv限定符后类型一致.
当声明为指针或引用时, auto的推导结果将保持初始化表达式的cv属性.

3. auto与函数模板

auto的推导和函数模板参数的自动推导有相似之处.下面模板参数的自动推导和auto的类型是一致的:

template<typename T> void func(T x){}
template<typename T> void func(T * x){}
template<typename T> void func(T & x){}

template<typename T> void c_func(const T x){}
template<typename T> void c_func(const T * x){}
template<typename T> void c_func(const T & x){}

func(x);        // func(T x)   参数被推导为int T被推导为int
func(&x);       // func(T * x) 参数被推导为int*  T被推导为int
func(x);        // func(T & x) 参数被推导为in&   T被推导为int

func(e);        // func(T x)   参数被推导为int T被推导为int
func(gg);       // func(T * x) 参数被推导为int const *  T被推导为int const
func(h);        // func(T & x) 参数被推导为int const &  T被推导为int const

c_func(e);      // c_func(const T x)   参数被推导为int const    T被推导为int
c_func(gg);     // c_func(const T * x) 参数被推导为int const *  T被推导为int
c_func(h);      // c_func(const T & x) 参数被推导为int const &  T被推导为int

注意:(T x)版本的模板和(T & x)的模板在验证时只能使其中一个版本生效, 否则会使推导产生二义性导致无法编译. (const T x)与(const T & x)也是如此.

auto不能用作函数的参数. 这点很容易理解, 如果auto可以用作函数的参数, 相当于在编译时就需要对该函数定义所有可能参数的类型.

 void func_auto(auto a){ // error: 'auto' not allowed in function prototype

}

// 相当于需要定义一下函数
void func_auto(char a){}
void func_auto(unsigned char a){}
void func_auto(short a){}
void func_auto(unsigned short a){}
void func_auto(int a){}
void func_auto(unsigned int a){}
void func_auto(float a){}
void func_auto(unsigned float a){}
void func_auto(double a){}
void func_auto(unsigned double a){}
void func_auto(long a){}
void func_auto(unsigned long a){}
void func_auto(long long a){}
void func_auto(unsigned long long a){}
...
...
...

4. auto的限制

上一小节结尾已经梳理了auto不可以作为函数参数的自动推导.那还有哪些情况下无法使用auto自动推导呢?

auto func_ra(){ // error: 'auto' return without trailing return type; deduced return types are a C++14 extension
    return 0;
}

auto func_ra(int a,int b)->decltype (a+b){ // OK
    return a+b;
}

class A {
public:
    auto a =0;              // error: 'auto' not allowed in non-static class member
    static const auto ai2 = 0;
//    static const auto af2 = 0.0;    // error: in-class initializer for static data member of type 'const double' requires 'constexpr' specifier

    static int x;           // static const 的整形或者枚举成员才可以在类内初始化.
                            // 否则就只能在类内声明,在类外通过A::的形式初始化
    static int y = 0;       // error: non-const static data member must be initialized out of line
    static double d = 0.0;  // error: non-const static data member must be initialized out of line
    static float f = 0.0;   // error: non-const static data member must be initialized out of line
    static char c = '0';    // error: non-const static data member must be initialized out of line

    static const int c_i = 0;
    static const double c_d = 0.0;  // error: in-class initializer for static data member of type 'const float' requires 'constexpr' specifier note: add 'constexpr'
    static const float c_f = 0.0;   // error: in-class initializer for static data member of type 'const float' requires 'constexpr' specifier note: add 'constexpr'
    static const char c_c = '0';
};
int A::x = 0;

template <typename T>
class B{};

int array[4] = {0};
auto aarray = a;
auto array2[4] = array; // error: 'array2' declared as array of 'auto'
auto array3[4] = {0};   // error: 'array3' declared as array of 'auto'

B<int> bb;
B<auto> a_bb = bb;  // error: 'auto' not allowed in template argument