[C++11] alcance automático de inicialización de lista para nueva palabra clave nuevo contenedor

---

1 lista de inicialización

Lo sabemos por las reglas del lenguaje c: generalmente solo se pueden {}inicializar matrices, pero la nueva sintaxis de C++11 estipula que no solo podemos inicializar varios objetos (tipos integrados y tipos personalizados) con {}, sino también no agregue el =símbolo anterior (generalmente no se recomienda usar de esta manera, la legibilidad no es buena), como el siguiente uso:

struct Point
{
    
    
 int _x;
 int _y;
};
int main()
{
    
    
 int x1 = 1;
 int x2{
    
     2 };
 int array1[]{
    
     1, 2, 3, 4, 5 };
 int array2[5]{
    
     0 };
 Point p{
    
     1, 2 };
 // C++11中列表初始化也可以适用于new表达式中
 int* pa = new int[4]{
    
     0 };
 return 0;
}

Pero, ¿cuál es el principio de tal inicialización? De hecho, se ha agregado una nueva clase en C++ 11: initializer_list
[documento de introducción de initializer_list]

Escenarios de uso de Initializer_list:
std::initializer_list generalmente se usa como un parámetro del constructor C++ 11 agrega std::initializer_list como un constructor de parámetros para muchos contenedores en STL, por lo que es más conveniente inicializar el objeto contenedor. También se puede usar como parámetro de operator=, de modo que podemos usar llaves para asignar valores a contenedores como vector y lista, y podemos usar directamente {} para asignar valores.
Por ejemplo, el siguiente uso:

int main()
{
    
    
 vector<int> v = {
    
     1,2,3,4 };
 list<int> lt = {
    
     1,2 };
 
 // 这里{"sort", "排序"}会先初始化构造一个pair对象
 map<string, string> dict = {
    
     {
    
    "sort", "排序"}, {
    
    "insert", "插入"} };
 
// 使用大括号对容器赋值
v = {
    
    10, 20, 30};
 return 0;

---

2 rango automático && para

Ya hemos explicado esta gramática cuando explicamos la introducción de C++. Si está interesado, puede hacer clic en el siguiente enlace: [Conceptos básicos de Introducción a C++]

---

3 Agregar palabras clave

3.1 tipo de declaración

La palabra clave decltype declara que la variable es del tipo especificado por la expresión.
Algunos escenarios de uso:

template<class T1, class T2>
void F(T1 t1, T2 t2)
{
    
    
decltype(t1 * t2) ret;
cout << typeid(ret).name() << endl;
}
int main()
{
    
    
const int x = 1;
double y = 2.2;
decltype(x * y) ret; // ret的类型是double
decltype(&x) p;      // p的类型是int*
cout << typeid(ret).name() << endl;
cout << typeid(p).name() << endl;
F(1, 'a');
return 0;
}

De hecho, las escenas anteriores se pueden reemplazar por auto, pero las siguientes situaciones no se pueden reemplazar por auto:
vector<decltype(x*y)>porque el vector necesita un tipo específico, por lo que no se puede usar auto.

3.2 por defecto

Suponga que desea utilizar alguna función predeterminada, pero por alguna razón esta función no se genera de forma predeterminada. Por ejemplo: si proporcionamos una estructura por defecto escrita por nosotros mismos, el compilador no generará una estructura por defecto. Pero podemos usar default para forzar al compilador a generar.

class Person
{
    
    
public:
 Person(const char* name = "", int age = 0)
 :_name(name)
 , _age(age)
 {
    
    }
 Person(const Person& p)
 :_name(p._name)
 ,_age(p._age)
 {
    
    }
 Person() = default;
private:
 bit::string _name;
 int _age;
};

Pero el programa anterior parece no tener ningún valor práctico.Después de aprender las referencias de rvalue y la semántica de movimiento, podemos obligar al compilador a generar una construcción de movimiento predeterminada y así sucesivamente.

3.3 eliminar

Si queremos restringir la generación de algunas funciones por defecto, ¿cómo deberíamos hacerlo en C++98?
Haga que la función sea privada y solo declare el parche, de modo que mientras otros intenten llamarlo, se informará un error.
Pero C++11 proporciona una forma más fácil: use la palabra clave delete para especificar la función.

uso:

class Person
{
    
    
public:
 Person(const char* name = "", int age = 0)
 :_name(name)
 , _age(age)
 {
    
    }
 Person(const Person& p) = delete;
private:
 bit::string _name;
 int _age;
};
int main()
{
    
    
 Person s1;
 Person s2(s1);//报错

 return 0;
}

3.4 invalidación final

Estos dos bloggers de palabras clave las han presentado en detalle en el artículo sobre herencia y polimorfismo, los interesados ​​pueden pasar a:
[Herencia y polimorfismo]

---

4 Resumen

En términos generales, la nueva sintaxis introducida esta vez es bastante simple y es todo contenido básico. Todavía hay contenido en la serie C++ 11 que no se ha actualizado. ¡Hasta la próxima! ! ❤️ ❤️❤️