1.1.用途：1）自動數據類型推斷變量:指定其類型將從其初始化器自動推導而出函數:指定其返回類型是尾隨的返回類型或將從其return語句推導出 非類型模板形參:指定其類型將從參數推導出2）返回值占位3）結構化綁定 auto [v1,v2,...]多值返回4）循環1.2.說明：在塊作用域,命名空間作用域,循環初始化語句等中聲明變量時,auto可用作類型指定符 1.3.注意事項 1）auto是占位符非類型,禁用類型轉換或其他操作,如sizeof和typeid可用valatile,*,&,&&來修飾auto； int value = 1;static_cast<auto>(value); //錯誤auto x = 1; const auto y = 2;auto p1 = new auto(1); assert(*p1 == 1); //int* p;auto* p2 = new auto(x); assert(*p2 == 1);auto** p3 = new auto(&x);assert(**p3 == 1); 2）auto聲明變量,堆上變量必須初始化auto x=1;不能定義類的非靜態成員變量 3）auto不能與其他類型組合連用： auto int x=1;//錯誤聲明中不允許混合變量和函數： auto f() -> int, i = 0;//錯誤定義多變量推導類型必須都相同：auto x= 0, pi = 3.14; //錯誤 4）參數(函數和模板)不能被聲明為auto:func(auto x);template<auto T>實例化模板時不能使用auto作為模板參數 5）auto不能直接聲明數組-會退化為指針除非被聲明為引用int a[9]; auto j = a;typeid(j).name(); //int * __ptr64auto& x = a;typeid(x).name(); // int [9]

?

6）auto不能自動推導成cv-qualifiers（constant & volatile qualifiers）a）auto會忽略引用, 忽略掉頂層const, 保留底層constint i = 1; const int c = 2;const int& r = c; auto x1 = c; x1 = 3; // int x1 頂層const被忽略auto x2 = r; x2 = 4; // int x2 頂層const被忽略b）用于引用聲明的const都是底層constauto p = &c; // const int* pauto cp = &r; // const int* cp //*p = 5; // error// *cp = 6; // error//auto &k0 = 4; //錯誤：非常量引用初始值必為左值const auto &x6 = 4; //正確:常量引用可以綁定到字面值auto& k1 = i;k1 = 10; auto& k2 = c; //k2 = 10;// errorauto& k3 = r; // k3 = 10;// errorc）希望推斷出auto類型是一頂層const需明確指出const auto y1 = i;

2.1.自動數據類型推斷：?

1）變量推導：格式：[const]auto[*|&|&&] name{init_list};說明：變量必須初始化;推導類型必須相同;實例：auto s("hello"); auto x = 1, y = 2; const auto x = 1; const auto& ref_z = 2;int x=3;auto y= x,&ref_y = x,*p = &x; //y,ref_y,p初始化為x副本,引用,指針.map<string, int> m = { {"Tom",10},{"Bob",20},{"Jim",30} };map<string, int>::const_iterator it= m.begin();//類型冗長 2）函數：格式： [cv] auto [ref] parameter //函數參數聲明template < auto Parameter > //模板形參聲明為auto則其類型由對應使用參數推導出實例：auto foo(int x) -> int { return x; } //不進行自動類型檢測auto bar(int x) { return x; } //通過return運算數用模板實參推導規則推導auto func(int x) { auto a = x; return a; }template <typename T, int y> //非類型模板參數-類型auto add(T x) {return x + y;}template <typename T,auto y> //非類型模板參數-auto auto foo(T x){ return x+y;}foo<int,10>(1); //value 被推導為 int 類型decltype(auto) x =4; //auto被替換成其初始化器的表達式decltype(auto) function; //auto被替換成其返回語句的運算數

?2.2.返回值占位

說明：auto :: 占位符它會被類或枚舉類型遵循制約類型占位符推導規則替換實例：返回值占位template<typename T1,typename T2> auto compose(T1 t1, T2 t2) -> decltype(t1 + t2){return t1+t2;}auto v = compose(2, 3.14); // v's type is double

??2.3.結構化綁定聲明

1）格式：[cv] auto [*|&|&&][identifier - list] initializer; 2）說明：用括號包含多個變量表示結構化綁定，用auto即綁定時聲明變量結構化綁定允許通過對象的元素或成員初始化多個實體結構化綁定對于返回結構或數組的函數尤其有用使代碼更具可讀性如果用于初始化結構化綁定引用的值是一個臨時對象，則通常將臨時對象的生存期擴展到結構化綁定的生存期auto[name,age]=struct_Type s;//name,age的類型不會衰減3）使用：用于具有public數據成員、原始C語言風格數組和像tuple元組對象結構:a. 結構體和類中所有非靜態公共數據成員b. 原始數組可以將名稱綁定到每個元素.c. 對于任何類型都可用像tuple元組API將名稱綁定到API定義為“元素”任何內容參考如何提供tuple一樣的API接口。該API大致由以下元素組成的類型:- std::tuple_size<type>::value必須返回元素數量- std::tuple_element<idx,type>::type必須返回idx元素類型-全局或成員get<idx>()必須生成idx元素的值d.標準庫std::pair<>， std::tuple<>， std::array<>已經提供了這個API如果結構或類提供了像tuple元組API，則使用該APIe.在所有情況下，元素或數據成員數量都必須符合結構化綁定聲明中的名稱數量你不能跳過名字，也不能重復使用名字。但是可用“_”但在相同范圍內只能用一次:auto [_,val1] = getStruct(); // OKauto [_,val2] = getStruct(); // ERROR: name _ already used

?3.實例：

實例1:數據類型推導#include <iostream>#include <utility>#include<cassert>template<class T, class U>auto add(T t, U u) { return t + u; } // 返回類型operator+(T, U)類型// 函數返回引用必須用 decltype(auto)template<class F, class... Args>decltype(auto) func(F fun, Args&&... args){return fun(std::forward<Args>(args)...);}template<auto lst> // C++17 auto形參聲明auto f() -> std::pair<decltype(lst), decltype(lst)> // auto不能從花括號初始化器列表推導{ return { lst, lst };} using namespace std;int main() {//變量類型自動推導auto x1 = 1 + 2;assert(x1 == 3); // int x1 auto x2 = add(1, 1.2); assert(x2 == 2.2); // double x2static_assert(std::is_same_v<decltype(x1), int>);static_assert(std::is_same_v<decltype(x2), double>);decltype(auto) x3 = x1; // int x3 保有x1的副本decltype(auto) x1_alias = (x1); // int& x1_alias為x1別名++x1_alias; assert(x1 == 4);//通過x1_alias修改x1auto lst = { 1, 2 }; assert(*lst.begin() == 1); // lst 類型std::initializer_list<int>auto lst1 = { 3 }; assert(*lst1.begin() == 3); // lst1類型std::initializer_list<int>//auto e{1, 2}; // C++17起錯誤,之前為 std::initializer_list<int>auto e{ 3 }; assert(e == 3); // C++17起m類型為int ,之前initializer_list<int>//auto int x; // 于 C++98 合法, C++11 起錯誤//auto x; // 于 C 合法,于 C++ 錯誤//decltype(auto) z = { 1, 2 } // 錯誤： {1, 2} 不是表達式decltype(auto) z = 1 + 2; assert(z == 3);// 結構化綁定聲明auto[rst1, rst2] = f<2>(); assert(rst1 == 2 && rst2 == 2);//auto 常用于無名類型,例如 lambda 表達式的類型auto lambda = [](int x) { return x + 3; }; assert(lambda(2) == 5);auto add = [](int x, int y) {return x + y; };auto rst = func(add,1,2);cout << rst << endl;}

?實例2：auto迭代

#include<iostream>#include<string>#include<list>#include<map>#include<cassert>using namespace std;template<typename K, typename V>struct S_Type { K key; V value; }; int main() {//C++11引入基于范圍的for循環。for循環后括號由冒號“ ：”分為兩部分：//第一部分是范圍內用于迭代的變量,第二部分則表示被迭代的范圍//數組：int arr[] = { 1,2,3 };for (auto v : arr) { cout << v << endl; } //按值傳遞-只讀for (auto &v : arr) { v *= 100; } //修改值map<string, int> m = { {"Tom",10},{"Bob",20},{"Jim",30} };for (auto &v : m) { cout<< v.first<<","<<v.second<<";"; }cout << endl;//Bob, 20; Jim, 30; Tom, 10; //結構體：S_Type<string, int> s1{ "Tom",20 }, s2 = { "Aob",30 };auto[key, value] = s1;assert(key == string("Tom")&&value == 20);//list:std::list<S_Type<string, int>> lsts{ s1,s2 };for (auto[key, value] : lsts){std::cout<< key<<","<< value << ";";}cout << endl;//Tom, 20; Aob, 30; //map:std::map<string, S_Type<string, int>> maps;maps = { {"NO1",s1},{"NO2",s2} };for (auto[No, lsts] : maps){auto[ley, value] = lsts;cout << No << "," << key << "," << value << ";";}cout << endl;//NO1, Tom, 20; NO2, Tom, 30;auto[a, b, c] = std::make_tuple("Bob", "shanghai",3.14);cout << a << "," << b<<"," << c << endl;//"Bob", "shanghai",3.14} 實例3：注意：只有有限的繼承用法是可能的所有非靜態數據成員必須是相同類定義的成員因此，它們必須是類型的直接成員或相同的明確的公共基類的直接成員#include<iostream>using namespace std;struct A { int x = 1; int y = 2; };struct B1 : A {};struct B2 : A { int z = 3; };int mxin() {auto[x, y] = B1{}; // OK//auto [x1,x2,x3] = B2{}; // Compile-Time ERRORstd::cout << "x=" << x << ", y=" << y << std::endl;}

?實例4：結構化綁定

#include <vector>#include <iostream>#include<string>#include<map>#include<tuple>#include<cassert>using namespace std;//原始數組int arr[] = { 1, 2 };auto getArrayRef() -> int(&)[2]{ return arr; }decltype(arr)& getArray_Ref() { return arr; }//等效上面void test_arr() {auto[x1, y1] = arr;//auto [x1] = arr; // 數量不合適assert(x1 == 1 && y1 == 2);//數組作為參數或返回數組退化為指針,引用數組不退化auto& r1 = getArrayRef(); //00007FF7F1A3F000auto r2 = getArrayRef(); //00007FF7F1A3F000auto& r3 = getArray_Ref();//00007FF7F1A3F000auto r4 = getArray_Ref(); //00007FF7F1A3F000assert(r1 == r2 && r3 == r4 && r2 == r3);auto[x2, y2] = getArray_Ref(); assert(x2 == 1 && y2 == 2);} //結構體：struct S_Type { string name{ "Tom" }; int age = 1; };// 函數返回結構體:結構化綁定綁定到從返回值初始化的新實體，非綁定到返回值S_Type foo(string name, int age){return { name,age };};S_Type bar(string name, int age){return S_Type{ name,age };}//等效上面void test_struct() {S_Type s{ "Tom",10 };auto[name, age] = s;//匿名拷貝-修改s不影響name,age//const auto&可用到左值或右值const auto&[u, v] = s; //聲明const引用結構化綁定-修改s影響u,vassert(u == string("Tom")&&v==10);auto[x, y] = foo("Bob", 20);assert(&((S_Type*)&x)->age == &y); //指向匿名實體的指針}void view(string name, int age) { std::cout << "(" << name << "," << age << ")," ; } //移動語義void test_move() {auto print = [](auto name, auto age,auto n,auto a) {std::cout << "("<<name << "," << age <<"),("<<n<<","<<a<<")"<< endl; };//實例1：//新匿名實體從s1移動了值s1.name已丟失它的值//修改新匿名實體值或修改s1相互不影響;s1仍然存在，但s1.name值未知S_Type s1 = { "Tom",10 };auto[n1, v1] = std::move(s1); print(n1, v1,s1.name, s1.age); //(Tom,10),(,10)//n1 = string("Bob"); v1 = 11;//print(n1, v1, s1.name, s1.age); //(Bob, 11), (, 10)s1.name = string("Bob"); s1.age = 12;print(n1, v1, s1.name, s1.age); //(Tom,10),(Bob,12)//實例2：//新匿名實體值不能修改,修改s2不影響n2,v2S_Type s2 = { "Tom",10 };const auto[n2, v2] = std::move(s2);//n2,v2不能修改print(n2, v2, s2.name, s2.age); //(Tom,10),(,10)s2.name = string("Bob"); s2.age = 12;print(n2, v2, s2.name, s2.age); //(Tom,10),(Bob,12)//實例3：//修改新匿名實體值或修改s1相互影響S_Type s3 = { "Tom",10 };//auto&[it, b] = std::move(s3);錯誤auto&[it, b] = s3;print(it, b, s3.name, s3.age); //(Tom, 10), (Tom, 10)//it = string("Bob"); b = 11;//print(it, b, s3.name, s3.age); //(Bob, 11), (Bob, 11)s3.name = string("Bob"); s3.age = 12;print(it, b, s3.name, s3.age); //(Bob,12),(Bob,12)//實例4：//修改新匿名實體值或修改s4相互影響;//結構化綁定n4和v4表示一匿名實體作為s4的右值引用，s4仍然保持其值并沒有真正移動s4S_Type s4 = { "Tom",10 };auto&&[n4, v4] = std::move(s4);print(n4, v4, s4.name, s4.age);//(Tom, 10), (Tom, 10)//n4 = string("Bob"); v4 = 11;//print(n4, v4, s4.name, s4.age); //(Bob, 11), (Bob, 11)s4.name = string("Bob"); s4.age = 12;print(n4, v4, s4.name, s4.age); //(Bob, 12), (Bob, 12)//可移動賦值n也就是s.name:與移動規則一樣，從對象中移出的對象處于有效狀態，值未指定string name = move(n4);int age = move(v4);view(name, age);print(n4, v4, s4.name, s4.age);//(Bob,12),(,12),(,12)name = string("Jim"); age = 13;view(name, age); print(n4, v4, s4.name, s4.age);//(Jim,13),(,12),(,12)n4 = string("Smith"); v4 = 13;view(name, age); print(n4, v4, s4.name, s4.age);//(Jim,13),(Smith,13),(Smith,13)s4.name = string("Amila"); s4.age = 14;view(name, age); print(n4, v4, s4.name, s4.age);//(Jim,13),(Amila,14),(Amila,14) } void test_atl() {tuple<string, int,double> t("Tom", 10,3.14);auto[n1,v1,z1] = t;cout << n1 <<","<< v1 << "," <<z1<< endl;//Tom, 10, 3.14pair<string, int> p{ "Tom",10 };auto[n2, v2] = p;cout << n2 << "," << v2 << endl;//Tom, 10map<string, int> m;auto[it, b] = m.emplace("Tom",10 );auto[first, second] = *it;cout << first << "," << second << "," <<std::boolalpha<< b << endl;//Tom, 10, truevector<int>vec{ 10,20 };auto it2 = vec.emplace(end(vec), 30);cout << *it2 << endl;}int main() {test_arr();test_struct();test_move();test_atl(); }

?

總結

以上是生活随笔為你收集整理的C++ 关键字auto tcy的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。