C++11 auto自动类型推导

清疚 2022-06-15 10:55 216阅读 0赞

## 1. auto类型推导 ##

下面是auto的使用举例：

auto x  =5;			//正确，x是int类型
    auto pi = new auto(1);		//正确，批是int*
    const auto* v = &x, u = 6;	//正确，v是const int*类型，u是const int
    static auto y = 0.0;		//正确，y是double类型
    auto int r;			//错误，auto不再表示存储类型的指示符
    auto s;				//错误，auto无法推导出s的类型（必须马上初始化）

auto并不能代表一个实际的类型声明（上面s编译错误），只是一个类型声明的“占位符”。使用auto声明的变量必须马上初始化，以让编译器推断出它的类型，并且在编译时将auto占位符替换为真正的类型。

## 2. auto类型推导规则 ##

int x = 0;
    auto *a = &x;		//a->int*，auto被推导为int
    auto b = &x;		//b->int*，auto被推导为int*
    auto &c = x;		//c->int&，auto被推导为int
    auto d = c;		//d->int， auto被推导为int
    
    const auto e = x;		//e->const int
    auto f = e;			//f->int
    
    const auto& g = x;		//e->const int&
    auto& h = g;			//g->const int&

auto的推导规则：  
（1）当不声明为指针或是引用时，auto的推导结果和初始化表达式抛弃引用和const属性限定符后的类型一致，图上面的d和f  
（2）当声明为指针或是引用时，auto的推导结果将保持初始化表达式的const属性

## 3. auto类型推导的限制 ##

（1）auto不可以用于函数参数

void func(auto a=1){}	//错误，不可以用作函数参数

（2）auto不可以用于非静态成员变量

struct Foo
    {
        auto var1 = 0;				//错误，不能用于非静态成员变量
        static const auto var2 = 0;	//正确，var2->static const int
    };

注：auto仅能够用于推导static const的整型或者美剧成员（因为其他静态成员无法在类或是结构体中就地完成初始化，都需要在类的外部进行初始化）。C++11中支持非静态成员变量的就地初始化，但却不支持auto类型的非静态成员变量初始化。  
（3）auto类型不能用于定义数组

int a[10] = {...};				
    auto b[10] = a;					//错误，auto类型无法定义数组

（4）auto类型无法导出模板参数

template<typename type> struct Bar
    {
    	...
    };
    Bar<int> a;
    Bar<auto> b = a;				//错误，auto无法推导出模板参数

## 4. auto类型推导的使用场景 ##

（1）需要极大简化书写的时候，例如在定义STL迭代指针的时候

int a[] = {1, 2, 3, 4};
    std::vector<int> vec(a, a+4);
    std::vector<int>::iterator it = vec.begin();
    for(; it != vec.end(); ++it)
    {
    	...
    }

在使用auto类型推导之后

int a[] = {1, 2, 3, 4};
    std::vector<int> vec(a, a+4);
    for(auto it = vec.begin(); it != vec.end(); ++it)
    {
    	...
    }

（2）在无法知道变量该定义成何种类型的时候

class A
    {
    	static int func1(void)
    	{
    		return 1;
    	}
    };
    
    class Bar
    {
    	double func1(void)
    	{
    		return 0.0;
    	}
    };
    
    template<typename type> func3()
    {
    	auto a = type::func1();
    	...
    }