C++11

在C++11中,auto关键字被作为类型自动类型推导关键字

(1)基本用法

C++98:类型 变量名 = 初值;   int i = 10;

C++11:auto 变量名 = 初值;  auto i = 3.14;

借助于auto关键字,可对变量进行隐式的类型定义,即由编译器在编译期间根据变量的初始化语句,自动推断出该变量的类型.

auto a = 1;//a被推导为int
auto b = new auto(2);//b推导为int*
auto const *c = &a;//

在旧语法中,auto型变量存储于栈区,static型变量存储于静态区,二者不能同时使用,但c++11的auto关键字已经不再作为存储类型指示符

static auto i = 4;
auto int j; //error

auto并不能代表一个世纪的类型声明,只是一个类型声明的占位符,使用auto声明的变量必须马上初始化,以让编译器推断出它的实际类型并在编译剪短将auto替换为真的类型

auto k; //error

 

(2)auto同指针或引用结合使用

即使不把auto声明为指针,其亦可被推导为指针类型

int a = 0;
auto *b = &a; //auto=int  b==>int*
auto c = &a   //auto=int* c==>int*

当表达式带有引用属性时,auto会抛弃其引用属性

auto &d = a;  //auto=int  d==>int&
auto e = a;   //auto=int  e==>int

当表达式带有CV限定,auto会抛弃其CV限定

auto const f = a;  //auto=int  f==>int const
auto g = f;        //auto=int  g==>int

但是如果auto和引用或指针结合使用,表达式的CV限定会被保留下来

auto const &h = a; //auto=int  h==>int const&
auto &i = h;       //auto=int const  i==>cosnt &
auto *j = &h;      //auto=int const  j==>int const*

 

(3)auto使用的限制

auto不能用于函数的参数

void foo(auto i){...}//error 无法推导为int
foo(10);

auto不能用于类的非静态成员变量

auto不能用于模板的类型实参(模板的类型实参都是)

Dummy<int> d1;
Dummy<auto> d2 = d1; //error

auto不能用于数组元素

int a[10];
auto b[10] = a;//error
auto c = a; //ok,但是c推断为int*
auto &d = a; //ok,但是此时a代表的是数组整体不是首地址

 

(4)何时使用auto

通过auto减少模板的类型参数

通过auto可以简化某些复杂类型的书写

#include <iostream>
#include <typeinfo>
#include <map>
#include <string>
using namespace std;

class A{
public:
    A(int arg = 0):m_var(arg){}
    int get(void)const{return m_var;}
    void set(int arg){m_var = arg;}
private:
    int m_var;
};

class B{
public:
    B(char const *arg = ""):m_var(arg){}
    char const *get(void)const{return m_var;}
    void set(char const *arg){m_var = arg;}
private:
    char const *m_var;
};

//C++98版本
template<typename V,typename X>
void foo(X const &x){
    V var = x.get();
    cout << var << endl;
}

//C++11版本
template<typename X>
void bar(X const &x){
    auto var = x.get();
    cout << var << endl;
}

int main(void) {
    A a(1234);
    B b("abcd");
    foo<int>(a);  //X会隐式推断
    foo<char const*>(b);
    multimap<string,int> mm;
    mm.insert(make_pair("zhangfei",70));
    mm.insert(make_pair("zhaoyun",75));
    mm.insert(make_pair("guanyu",90));
    mm.insert(make_pair("zhangfei",50));
    mm.insert(make_pair("zhaoyun",80));
    mm.insert(make_pair("guanyu",80));
    //C++98版本
    pair<multimap<string,int>::iterator,multimap<string,int>::iterator> its1 = mm.equal_range("zhangfei");
    int sum1 = 0;
    for (multimap<string,int>::iterator it=its1.first; it != its1.second; it++)
        sum1 += it->second;
    cout << sum1 << endl;
    //c++11 auto版本
    auto its2 = mm.equal_range("zhangfei");
    int sum2 = 0;
    for(auto it = its2.first; it != its2.second; it++)
        sum2 += it->second;
    cout << sum2 << endl;
    return 0;
}