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;
}