Palabra clave automática de C ++

C ++ 98 automático

Ya en el estándar C ++ 98, existía la palabra clave auto. En ese momento, se usaba auto para declarar variables como variables automáticas. Variables automáticas destinadas a tener tiempos de vida automáticos. Esto era redundante, porque incluso si no se usaban declaraciones automáticas , las variables todavía tienen una vida útil automática:

int a =10 ;  //拥有自动生命期
auto int b = 20 ;//拥有自动生命期
static int c = 30 ;//延长了生命期

El auto en C ++ 98 es redundante y rara vez se usa. C ++ 11 ha eliminado este uso y lo reemplazó con un nuevo auto: inferencia de tipo automático de variables.

volver a la cima

C ++ 11 coches

Auto puede seleccionar automáticamente el tipo de coincidencia para esta variable de acuerdo con el tipo de valor inicial de la variable al declarar la variable. Palabras clave similares incluyen decltype. por ejemplo:

    int a = 10;
    auto au_a = a;//自动类型推断，au_a为int类型
    cout << typeid(au_a).name() << endl;

El operador typeid puede generar el tipo de variable. Los resultados del programa se emiten

En t

Este uso es similar a la palabra clave var en C #. La inferencia de tipo automática de Auto se produce en tiempo de compilación, por lo que el uso de auto no reducirá la eficiencia del programa en tiempo de ejecución. Y si causará consumo de tiempo durante la compilación, creo que no. Cuando no se usa auto, el compilador también necesita saber el tipo del operando derecho, y luego compararlo con el tipo del operando izquierdo para verificar si el correspondiente puede ocurrir La conversión, si se requiere conversión de tipo implícita.

volver a la cima

El uso de auto

El ejemplo anterior es muy simple, no se recomienda usar auto de esta manera al programar, es más claro y comprensible escribir el tipo de variable directamente. El uso correcto de la palabra clave auto se enumera a continuación.

Se utiliza para reemplazar declaraciones de variables largas y complejas con un ámbito de uso específico.

Imagínese que cuando no hay auto, a menudo necesitamos operar la biblioteca estándar de esta manera:

#include<string>
#include<vector>
int main()
{
    std::vector<std::string> vs;
    for (std::vector<std::string>::iterator i = vs.begin(); i != vs.end(); i++)
    {
        //...
    }
}

Es realmente molesto mirar el código y escribir código de esta manera. Alguien podría decir por qué no usar el espacio de nombres std directamente, por lo que el código puede ser más corto. De hecho, este no es el método recomendado (C ++ Primer tiene una descripción relacionada de esto). El uso de auto puede simplificar el código:

#include<string>
#include<vector>
int main()
{
    std::vector<std::string> vs;
    for (auto i = vs.begin(); i != vs.end(); i++)
    {
        //..
    }
}

La i en el bucle for deducirá automáticamente su tipo en tiempo de compilación, sin que tengamos que definir explícitamente la cadena larga.

Al definir una función de plantilla, se utiliza para declarar tipos de variables que dependen de los parámetros de la plantilla.

template <typename _Tx,typename _Ty>
void Multiply(_Tx x, _Ty y)
{
    auto v = x*y;
    std::cout << v;
}

Si no usa la variable auto para declarar v, entonces esta función será difícil de definir, cuando no está compilada, ¿quién sabe el tipo real de x * y?

La función de plantilla depende del valor de retorno del parámetro de plantilla

template <typename _Tx, typename _Ty>
auto multiply(_Tx x, _Ty y)->decltype(x*y)
{
    return x*y;
}

Cuando el valor de retorno de una función de plantilla depende de los parámetros de la plantilla, todavía no podemos determinar el tipo de parámetro de plantilla antes de compilar el código, por lo que no hay forma de saber el tipo de valor de retorno. En este caso, puede usar auto. El formato se muestra arriba.
El operador decltype se usa para consultar el tipo de datos de las expresiones. También es un nuevo operador introducido por el estándar C ++ 11. Su propósito es resolver el problema de que algunos tipos en la programación genérica están determinados por parámetros de plantilla y son difíciles de Rápido.
El rol de auto aquí también se llama ocupación de valor de retorno , solo ocupa un lugar para el valor de retorno de la función, el valor de retorno real es el siguiente tipo de declinación (_Tx * _Ty). ¿Por qué desea publicar el valor devuelto? Si no hay sufijo, la declaración de función es:

decltype(x*y)multiply(_Tx x, _Ty y)

En este momento, xey aún no se han declarado y la compilación falla.

volver a la cima

Precauciones

• La variable auto debe inicializarse cuando se define, que es similar a la palabra clave const.

• Las variables definidas en una secuencia automática siempre deben deducirse del mismo tipo. P.ej:

  auto a4 = 10, a5 = 20, a6 = 30;//正确
  auto b4 = 10, b5 = 20.0, b6 = 'a';//错误,没有推导为同一类型

  Cuando se usa la palabra clave auto para la derivación automática de tipos, se aplican las siguientes reglas a su vez:

• Si la expresión de inicialización es una referencia, se elimina la semántica de referencia.

  int a = 10;
  int &b = a;
  
  auto c = b;//c的类型为int而非int&（去除引用）
  auto &d = b;//此时c的类型才为int&
  
  c = 100;//a =10;
  d = 100;//a =100;

• Si la expresión de inicialización es constante o volátil (o ambas), elimine la semántica constante / volátil.

  const int a1 = 10;
  auto  b1= a1; //b1的类型为int而非const int（去除const）
  const auto c1 = a1;//此时c1的类型为const int
  b1 = 100;//合法
  c1 = 100;//非法

• Si la palabra clave auto va acompañada de un ampersand, la semántica const no se elimina.

  const int a2 = 10;
  auto &b2 = a2;//因为auto带上&，故不去除const，b2类型为const int
  b2 = 10; //非法

  Esto se debe a que cómo eliminar la constante, entonces b2 es una referencia no constante a a2, y el valor de a2 se puede cambiar mediante b2, lo que obviamente no es razonable.

• Cuando la expresión de inicialización es una matriz, la palabra clave auto deduce que el tipo es un puntero.

  int a3[3] = { 1, 2, 3 };
  auto b3 = a3;
  cout << typeid(b3).name() << endl;

  El programa saldrá

  En t *

• Si la expresión es una matriz y auto va acompañada de &, el tipo deducido es un tipo de matriz.

  int a7[3] = { 1, 2, 3 };
  auto & b7 = a7;
  cout << typeid(b7).name() << endl;

  Salida del programa

  int [3]

• Los parámetros de función o plantilla no se pueden declarar como automáticos

  void func(auto a)  //错误
  {
  //... 
  }

• Siempre tenga en cuenta que el automóvil no es un tipo real.
  Auto es solo un marcador de posición. No es un tipo real. No puede usar algunos operadores de operando de tipo, como sizeof o typeid.

  cout << sizeof(auto) << endl;//错误
  cout << typeid(auto).name() << endl;//错误