Preface
C++ is a strongly typed language, and its type must be clearly stated when declaring a variable. However, in practice, it is difficult to infer the type of the value of an expression. Especially with the emergence of template types, it becomes more difficult to figure out the return type of some complex expressions. In order to solve this problem, auto introduced in C++11 has two main uses: automatic type inference and return value occupancy. The semantics of auto in C++98 to identify temporary variables have been removed in C++11 due to their minimal and redundant use. The two standard autos before and after are completely different concepts.
1. Automatic type inference
auto automatic type inference is used to infer the data type of the variable from the initialization expression. Through auto's automatic type inference, our programming work can be greatly simplified. Here are some examples of using auto.
#include <vector> #include <map> using namespace std; int main(int argc, char *argv[], char *env[]) { // auto a; // 错误,没有初始化表达式,无法推断出a的类型 // auto int a = 10; // 错误,auto临时变量的语义在C++11中已不存在, 这是旧标准的用法。 // 1. 自动帮助推导类型 auto a = 10; auto c = 'A'; auto s("hello"); // 2. 类型冗长 map<int, map<int,int> > map_; map<int, map<int,int>>::const_iterator itr1 = map_.begin(); const auto itr2 = map_.begin(); auto ptr = []() { std::cout << "hello world" << std::endl; }; return 0; }; // 3. 使用模板技术时,如果某个变量的类型依赖于模板参数, // 不使用auto将很难确定变量的类型(使用auto后,将由编译器自动进行确定)。 template <class T, class U> void Multiply(T t, U u) { auto v = t * u; }
2. Return value occupancy
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
3. Precautions for use
1. We can use valatile, pointer (*), reference (&) , rvalue reference (&&) to modify auto
auto k = 5; auto* pK = new auto(k); auto** ppK = new auto(&k); const auto n = 6;
2. Variables declared with auto must be initialized
auto m; // m should be intialized
3. Auto cannot be used in combination with other types
auto int p; // 这是旧auto的做法。
4. Function and template parameters cannot be declared as auto
void MyFunction(auto parameter){} // no auto as method argument template<auto T> // utter nonsense - not allowed void Fun(T t){}
5. Variables defined on the heap and expressions using auto must be initialized
int* p = new auto(0); //fine int* pp = new auto(); // should be initialized auto x = new auto(); // Hmmm ... no intializer auto* y = new auto(9); // Fine. Here y is a int* auto z = new auto(9); //Fine. Here z is a int* (It is not just an int)
6. Think that auto is a placeholder, not a type of its own, so it cannot be used for type conversion or other operations, such as sizeof and typeid
int value = 123; auto x2 = (auto)value; // no casting using auto auto x3 = static_cast<auto>(value); // same as above
7. Variables defined in an auto sequence must always be deduced to the same type
auto x1 = 5, x2 = 5.0, x3='r'; // This is too much....we cannot combine like this
8. Auto cannot be automatically deduced into CV-qualifiers (constant & volatile qualifiers), unless it is declared as a reference type
const int i = 99; auto j = i; // j is int, rather than const int j = 100 // Fine. As j is not constant // Now let us try to have reference auto& k = i; // Now k is const int& k = 100; // Error. k is constant // Similarly with volatile qualifer
9. auto will degenerate into a pointer to an array, unless it is declared as a reference type
int a[9]; auto j = a; cout<<typeid(j).name()<<endl; // This will print int* auto& k = a; cout<<typeid(k).name()<<endl; // This will print int [9]
Summary
The above is the entire content of this article. I hope the content of this article can be helpful to everyone in learning or using C++. If you have any questions, you can leave a message to communicate.
For more articles related to the use of auto, the new feature of C++11, please pay attention to the PHP Chinese website!