The use of auto, a new feature of C++11-C#.Net Tutorial-php.cn

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  #include  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 > map_; map>::const_iterator itr1 = map_.begin(); const auto itr2 = map_.begin(); auto ptr = []() { std::cout << "hello world" << std::endl; }; return 0; }; // 3. 使用模板技术时，如果某个变量的类型依赖于模板参数， // 不使用auto将很难确定变量的类型（使用auto后，将由编译器自动进行确定）。 template  void Multiply(T t, U u) { auto v = t * u; }

Copy after login

2. Return value occupancy

template  auto compose(T1 t1, T2 t2) -> decltype(t1 + t2) { return t1+t2; } auto v = compose(2, 3.14); // v's type is double

Copy after login

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;

Copy after login

2. Variables declared with auto must be initialized

auto m; // m should be intialized

Copy after login

3. Auto cannot be used in combination with other types

auto int p; // 这是旧auto的做法。

Copy after login

4. Function and template parameters cannot be declared as auto

void MyFunction(auto parameter){} // no auto as method argument template // utter nonsense - not allowed void Fun(T t){}

Copy after login

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)

Copy after login

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(value); // same as above

Copy after login

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

Copy after login

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

Copy after login

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<
        
         Copy after login

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!