C++auto关键字

auto关键字：
1.C++98标准auto关键字的作用和C语言的相同，表示自动变量，是关于变量存储位置的类型饰词，通常不写，因为局部变量的默认存储就是auto

void foo(void)
{
    int a;            //变量存储在栈区
    auto int b;       //自动变量，存储在栈区
    static int c;     //静态变量，存储在数据区
    register int d;   //寄存器变量，存储在寄存器中
}    

2.C++11标准中auto关键字不再表示变量的存储类型，而是用于类型推导
(2.1)auto的基本用法

void foo（void）
{
    auto a = 1;    　　　　  　　 //a是int类型
    auto b = new auto(2);   　　 //b是int *类型
    auto const *c = &a;         //c是const int *类型
    static auto d = 4.0;    　　 //d是double类型,在旧语法中，auto类型变量存储在栈区，static类型变量存储在静态区，二者不能同时使用,但在新语法中,auto已经不再作为存储类型指示符,和static关键字没有冲突，可以合用
    auto e;                     //error,C++11标准中auto变量必须被初始化
    auto const *f = &a,g = 4.0; //error,类型推导不能带有二义性
    auto const *h = &a,i;       //error，虽然可以根据&a得出auto表示int类型，但是i依然需要显示初始化
    auto int j = 3;    　　　　　 //error,auto不能与其他任何类型说明符组合使用
}                

(2.2)auto和指针或者引用结合使用

void foo(void)
{
　　int a = 0;
　　auto *b = &a;      　　　　　　　　　　//b是int *类型
　　auto c = &a;       　　　　　　　　　　//c是int *类型
　　auto &d = a;       　　　　　　　　　　//d是int&类型
　　cout << &d << ' ' << &a << endl; 　 //地址相同
　　auto e = d;    　   　　　　　　　　　 //e是int类型，当表达式带有引用属性时，auto会抛弃其引用属性，直接推导为原始类型
　　cout << &e << ' ' << &a << endl; 　 //地址不同
　　auto const f = a;                   //f是int const 类型
　　cout<<++f<<endl;                    //error,f带有常属性
　　auto g = f;
　　cout<<++g<<endl;                    //g的值为1，当表达式带有CV限定时，auto会抛弃其CV限定
　　auto const &h = a;
　　auto &i = h;    　　                 //i是int const &类型
　　cout<<++i<<endl;                    //error，如果auto和引用或者指针结合使用，表达式的CV限定会被保留下来
　　auto *j = &h;                       //j是int const *类型
　　cout<<++*j<<endl;                   //error,如果auto和引用或者指针结合使用，表达式的CV限定会被保留下来
}

(2.3)auto使用的限制
(2.3.1)auto不能用于函数的参数

void foo (auto a )    //error
{
    cout << typeid (a).name () << endl;
} 
//使用函数模板代替auto，如下：
template<typename T>
void foo (T a = T ())
{
    cout << typeid (a).name () << endl;
} 

(2.3.2)类的非静态数据成员不能包含auto类型

class A
{
public:
    int m_x = 0;
    //类的非静态数据成员不能包含auto类型
    auto m_y = 1;//error
    static auto const m_z = 2;
};

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

template<typename T>
class B 
{
public:
　　B (T const& arg) : m_var (arg) {}
　　T m_var;
};    
void main()
{
　　B<int> b1(0);    //true
　　B<auto> b2 = b1; //error,auto不能用于模板的类型实参
}

(2.3.4)auto不能用于数组元素

void func()
{
    int arr1[10];
    auto arr2[10] = arr1;    //error,auto不能用于数组元素
    auto arr3 = arr1;    //true,arr3是int *类型，arr1代表数组首地址
    auto &arr4 = arr1;    //true,arr4是int(&)[10]类型，arr1代表数组整体
    cout << typeid (arr4).name () << endl;//int[10]
}

(2.4)何时使用auto
(2.4.1)通过auto减少模板的类型参数

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(const char *arg):m_var(arg){}
　　const char *get(void)const
　　{
　　　　return m_var;
　　}
　　void set(const char *arg)
　　{
　　　　m_var = arg;
　　}
private:
　　const char *m_var;
};

//template <typename V,typename X>
template <typename X>
void foo(X const &x)
{
　　//V var = x.get();
　　auto var = x.get();
　　cout << typeid(var).name() << endl;
}

void main(void)
{
　　A a(1234);
　　//foo<int> (a);
　　foo(a);// 通过auto减少模板的类型参数

　　B b("abcd");
　　foo(b);
}

(2.4.2)通过auto简化复杂类型的书写

void foo(void)
{
  　　multimap<string, int> msi;
  　　msi.insert(make_pair("张飞", 100));
  　　msi.insert(make_pair("赵云", 90));
  　　msi.insert(make_pair("关羽", 80));
  　　msi.insert(make_pair("张飞", 95));
  　　msi.insert(make_pair("赵云", 85));
  　　msi.insert(make_pair("关羽", 75));
 　　 pair<multimap<string, int>::iterator, multimap<string, int>::iterator> range1 = msi.equal_range("张飞");//equal_range()函数查找multimap中键值等于key的所有元素，返回指示范围的两个迭代器。
 　　 int sum1 = 0;
 　　 for (multimap<string, int>::iterator it = range1.first; it != range1.second;++it)
 　 　{
 　　　　 sum1 += it->second;
 　 　}
 　 　cout << sum1 << endl;
 
 　　 auto range2 = msi.equal_range("张飞");
 　　 int sum2 = 0;
 　　 for (auto it = range2.first; it != range2.second; ++it)
 　　 {
 　　　 　sum2 += it->second;
 　 　}
 　　 cout << sum2 << endl;
}