L'usage de l'auto, une nouveauté du C 11

Préface

Le C est un langage fortement typé, et le type d'une variable doit être clairement indiqué lors de sa déclaration. Cependant, en pratique, il est difficile de déduire le type de valeur d'une expression. Surtout avec l'émergence des types de modèles, il devient plus difficile de déterminer le type de retour de certaines expressions complexes. Pour résoudre ce problème, auto introduit dans C 11 a deux utilisations principales : l'inférence de type automatique et l'occupation de la valeur de retour. La sémantique de auto en C98 pour identifier les variables temporaires, rarement utilisées et redondantes, a été supprimée en C++11. Les deux automobiles standards avant et après sont des concepts complètement différents.

1. Inférence de type automatique

L'inférence de type automatique est utilisée pour déduire le type de données de la variable à partir de l'expression d'initialisation. Grâce à l'inférence de type automatique d'auto, notre travail de programmation peut être considérablement simplifié. Voici quelques exemples d’utilisation de 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 = &#39;A&#39;; 
 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. Valeur de retour d'occupation

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

3. Précautions d'utilisation

1. On peut utiliser volatile, pointeur (*), référence. (&), référence rvalue (&&) pour modifier auto

auto k = 5;
auto* pK = new auto(k);
auto** ppK = new auto(&k);
const auto n = 6;

2 Les variables déclarées avec auto doivent être initialisées

auto m; // m should be intialized

< 🎜. >

3. auto ne peut pas être utilisé en combinaison avec d'autres types

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

4. paramètres Ne peuvent pas être déclarés comme auto

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

5 Variables définies sur le tas, les expressions utilisant auto doivent être initialisées

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. Je pense que auto est un espace réservé, pas son propre type, il ne peut donc pas être utilisé pour la conversion de type ou d'autres opérations, telles que sizeof et typeid

int value = 123;
auto x2 = (auto)value; // no casting using auto
  
auto x3 = static_cast<auto>(value); // same as above

7. Les variables définies dans une séquence automatique doivent toujours être déduites du même type

auto x1 = 5, x2 = 5.0, x3='r'; // This is too much....we cannot combine like this

8. auto ne peut pas être automatiquement déduit en qualificatifs CV (qualificatifs constants et volatils) à moins qu'il ne soit déclaré comme type de référence

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 dégénérera en un pointeur vers un tableau à moins qu'il ne soit déclaré comme référence

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]

Résumé

Ce qui précède est tout le contenu de cet article, j'espère que cela. article Le contenu peut être utile à tout le monde dans l'apprentissage ou l'utilisation du C. Si vous avez des questions, vous pouvez laisser un message pour communiquer.

Pour plus d'articles liés à l'utilisation d'auto, la nouvelle fonctionnalité de C 11, faites attention au site PHP chinois !