CKTIS / C++
Inicialización por valor y llaves vacías `{}` en C++23
Las llaves vacías no siempre indican inicialización por valor. El tipo determina si se inicializa un escalar, se llama a un constructor o se aplican las reglas de los agregados.
Versión: ISO C++23; implementation support may vary
Sintaxis
T object{}; // Direct-list-initialization; the type determines the rule.
T object = {}; // Copy-list-initialization, not assignment.
int count{}; // Value-initialization: 0.
const char* next{}; // Value-initialization: null pointer.
char scratch[32]; // Default-initialization; automatic char elements are not initialized.
char ready[32]{}; // Aggregate initialization: all 32 elements are '\0'.
Result result{}; // Aggregate initialization when Result is the aggregate below.En C++23, T object{}; es inicialización directa por lista con una lista vacía. T object = {}; es inicialización por copia mediante lista, no una asignación. El tipo determina la regla que se aplica: int count{}; y const char* next{}; usan inicialización por valor. En estos casos, la inicialización a cero da 0 y un puntero nulo, respectivamente. No se garantiza que todos los bits de un puntero nulo sean cero.
Result result{}; y char ready[32]{}; usan inicialización de agregados. En un agregado que no sea una unión, un elemento omitido usa su inicializador de miembro predeterminado si lo tiene; de lo contrario, si no es una referencia, se inicializa por copia a partir de {}. Omitir una referencia sin inicializador es un error. Así, result.count vale 0, result.next es un puntero nulo y cada elemento de ready vale \0.
Cuando una clase se inicializa por valor, el objeto se inicializa por defecto. Solo se inicializa antes a cero si el constructor seleccionado no lo ha proporcionado el usuario. Tras struct C { int n; C() {} }; C c{};, el miembro c.n del objeto local sigue sin inicializar.
En const char* input, * declara un puntero; const califica a los caracteres, no al puntero. En la declaración local char scratch[32];, [32] declara un arreglo de 32 caracteres cuyos elementos no se inicializan. Lee solo los elementos en los que ya hayas escrito. Antes de usar el búfer como cadena de C, escribe también un \0 final dentro de los límites del arreglo.
Ejemplos
#include <iostream>
struct Result {
int count;
const char* next;
};
int main() {
const char* input = "A";
char scratch[32];
char ready[32]{};
int count{};
Result result{};
scratch[0] = input[0];
std::cout << "copied: " << scratch[0] << '\n';
std::cout << "ready[31] is null character: " << (ready[31] == '\0') << '\n';
std::cout << "count: " << count << '\n';
std::cout << "result: " << result.count << ", null pointer: "
<< (result.next == nullptr) << '\n';
}Resultado
copied: A ready[31] is null character: 1 count: 0 result: 0, null pointer: 1
El programa escribe en `scratch[0]` antes de leerlo e imprime un solo carácter, no el búfer como cadena. La comparación de `ready[31]` comprueba el último carácter, y `result.next == nullptr` comprueba el valor del puntero sin desreferenciarlo.
Lecciones relacionadas
- C++ · Lección 47 · Avanzado · Versión: 3