Inicialización de estructura C ++

¿Es posible inicializar estructuras en C ++ como se indica a continuación?

struct address {
    int street_no;
    char *street_name;
    char *city;
    char *prov;
    char *postal_code;
};
address temp_address =
    { .city = "Hamilton", .prov = "Ontario" };

Los enlaces aquí y aquí mencionan que es posible usar este estilo solo en C. Si es así, ¿por qué esto no es posible en C ++? ¿Hay alguna razón técnica subyacente por la que no se implementa en C ++, o es una mala práctica usar este estilo? Me gusta usar esta forma de inicialización porque mi estructura es grande y este estilo me da una clara legibilidad de qué valor se asigna a cada miembro.

Comparta conmigo si hay otras formas a través de las cuales podemos lograr la misma legibilidad.

He referido los siguientes enlaces antes de publicar esta pregunta

1. C / C ++ para AIX
2. C Estructura de inicialización con variable
3. Inicialización de estructura estática con etiquetas en C ++
4. Inicialización de estructura adecuada de C ++ 11

Si desea dejar en claro cuál es el valor de cada inicializador, simplemente divídalo en varias líneas, con un comentario en cada una:

address temp_addres = {
  0,  // street_no
  nullptr,  // street_name
  "Hamilton",  // city
  "Ontario",  // prov
  nullptr,  // postal_code
};

Después de que mi pregunta no resultó en un resultado satisfactorio (porque C ++ no implementa init basado en etiquetas para estructuras), tomé el truco que encontré aquí: ¿Los miembros de una estructura C ++ se inicializan a 0 de manera predeterminada?

Para ti equivaldría a hacer eso:

address temp_address = {}; // will zero all fields in C++
temp_address.city = "Hamilton";
temp_address.prov = "Ontario";

Este es sin duda el más cercano a lo que quería originalmente (cero todos los campos excepto los que desea inicializar).

Como otros han mencionado, este se denomina inicializador.

Esta característica es parte de C ++ 20

Los identificadores de campo son de hecho sintaxis de inicializador C. En C ++ solo da los valores en el orden correcto sin los nombres de campo. Desafortunadamente, esto significa que debe darlos a todos (en realidad, puede omitir los campos finales de valor cero y el resultado será el mismo):

address temp_address = { 0, 0, "Hamilton", "Ontario", 0 }; 

Esta característica se llama inicializadores designados . Es una adición al estándar C99. Sin embargo, esta característica quedó fuera de C ++ 11. De acuerdo con el lenguaje de programación C ++, 4a edición, Sección 44.3.3.2 (Características C no adoptadas por C ++):

Algunas adiciones a C99 (en comparación con C89) no se adoptaron deliberadamente en C ++:

[1] Conjuntos de longitud variable (VLA); usar vector o alguna forma de matriz dinámica

[2] Inicializadores designados; usar constructores

La gramática C99 tiene los inicializadores designados [Ver ISO / IEC 9899: 2011, Borrador del Comité N1570 - 12 de abril de 2011]

6.7.9 Inicialización

initializer:
    assignment-expression
    { initializer-list }
    { initializer-list , }
initializer-list:
    designation_opt initializer
    initializer-list , designationopt initializer
designation:
    designator-list =
designator-list:
    designator
    designator-list designator
designator:
    [ constant-expression ]
    . identifier

Por otro lado, el C ++ 11 no tiene los inicializadores designados [Ver ISO / IEC 14882: 2011, Borrador del Comité N3690 - 15 de mayo de 2013]

8.5 Inicializadores

initializer:
    brace-or-equal-initializer
    ( expression-list )
brace-or-equal-initializer:
    = initializer-clause
    braced-init-list
initializer-clause:
    assignment-expression
    braced-init-list
initializer-list:
    initializer-clause ...opt
    initializer-list , initializer-clause ...opt
braced-init-list:
    { initializer-list ,opt }
    { }

Para lograr el mismo efecto, use constructores o listas de inicializadores:

Simplemente puede inicializar a través de ctor:

struct address {
  address() : city("Hamilton"), prov("Ontario") {}
  int street_no;
  char *street_name;
  char *city;
  char *prov;
  char *postal_code;
};

Incluso puede empaquetar la solución de Gui13 en una sola declaración de inicialización:

struct address {
                 int street_no;
                 char *street_name;
                 char *city;
                 char *prov;
                 char *postal_code;
               };


address ta = (ta = address(), ta.city = "Hamilton", ta.prov = "Ontario", ta);

Descargo de responsabilidad: no recomiendo este estilo

Sé que esta pregunta es bastante antigua, pero encontré otra forma de inicializar, usando constexpr y curry:

struct mp_struct_t {
    public:
        constexpr mp_struct_t(int member1) : mp_struct_t(member1, 0, 0) {}
        constexpr mp_struct_t(int member1, int member2, int member3) : member1(member1), member2(member2), member3(member3) {}
        constexpr mp_struct_t another_member(int member) { return {member1, member,     member2}; }
        constexpr mp_struct_t yet_another_one(int member) { return {member1, member2, member}; }

    int member1, member2, member3;
};

static mp_struct_t a_struct = mp_struct_t{1}
                           .another_member(2)
                           .yet_another_one(3);

Este método también funciona para variables globales estáticas e incluso constexpr. La única desventaja es la mala capacidad de mantenimiento: cada vez que se debe inicializar otro miembro utilizando este método, se deben cambiar todos los métodos de inicialización del miembro.

Podría estar perdiendo algo aquí, por qué no:

#include <cstdio>    
struct Group {
    int x;
    int y;
    const char* s;
};

int main() 
{  
  Group group {
    .x = 1, 
    .y = 2, 
    .s = "Hello it works"
  };
  printf("%d, %d, %s", group.x, group.y, group.s);
}

No está implementado en C ++. (también, char*cadenas? Espero que no).

Por lo general, si tiene tantos parámetros, es un olor a código bastante serio. Pero, en cambio, ¿por qué no simplemente inicializar el valor de la estructura y luego asignar a cada miembro?

Encontré esta forma de hacerlo para las variables globales, que no requiere modificar la definición de estructura original:

struct address {
             int street_no;
             char *street_name;
             char *city;
             char *prov;
             char *postal_code;
           };

luego declare la variable de un nuevo tipo heredado del tipo de estructura original y use el constructor para la inicialización de campos:

struct temp_address : address { temp_address() { 
    city = "Hamilton"; 
    prov = "Ontario"; 
} } temp_address;

Aunque no es tan elegante como el estilo C ...

Para una variable local, requiere un memset adicional (this, 0, sizeof (* this)) al comienzo del constructor, por lo que claramente no es peor y la respuesta de @ gui13 es más apropiada.

(Tenga en cuenta que 'temp_address' es una variable de tipo 'temp_address', sin embargo, este nuevo tipo hereda de 'address' y se puede usar en todos los lugares donde se espera 'address', por lo que está bien).

Hoy me enfrenté a un problema similar, donde tengo una estructura que quiero llenar con datos de prueba que se pasarán como argumentos a una función que estoy probando. Quería tener un vector de estas estructuras y estaba buscando un método de una línea para inicializar cada estructura.

Terminé yendo con una función de constructor en la estructura, que creo que también se sugirió en algunas respuestas a su pregunta.

Probablemente sea una mala práctica hacer que los argumentos para el constructor tengan los mismos nombres que las variables miembro públicas, lo que requiere el uso del thispuntero. Alguien puede sugerir una edición si hay una mejor manera.

typedef struct testdatum_s {
    public:
    std::string argument1;
    std::string argument2;
    std::string argument3;
    std::string argument4;
    int count;

    testdatum_s (
        std::string argument1,
        std::string argument2,
        std::string argument3,
        std::string argument4,
        int count)
    {
        this->rotation = argument1;
        this->tstamp = argument2;
        this->auth = argument3;
        this->answer = argument4;
        this->count = count;
    }

} testdatum;

Lo que usé en mi función de prueba para llamar a la función que se está probando con varios argumentos como este:

std::vector<testdatum> testdata;

testdata.push_back(testdatum("val11", "val12", "val13", "val14", 5));
testdata.push_back(testdatum("val21", "val22", "val23", "val24", 1));
testdata.push_back(testdatum("val31", "val32", "val33", "val34", 7));

for (std::vector<testdatum>::iterator i = testdata.begin(); i != testdata.end(); ++i) {
    function_in_test(i->argument1, i->argument2, i->argument3, i->argument4m i->count);
}

Es posible, pero solo si la estructura que está inicializando es una estructura POD (datos antiguos simples). No puede contener ningún método, constructor o incluso valores predeterminados.

En C ++, los inicializadores de estilo C fueron reemplazados por constructores que, en tiempo de compilación, pueden garantizar que solo se realicen inicializaciones válidas (es decir, después de la inicialización, los miembros del objeto son consistentes).

Es una buena práctica, pero a veces es útil una preinicialización, como en su ejemplo. OOP resuelve esto mediante clases abstractas o patrones de diseño de creación .

En mi opinión, usar esta forma segura mata la simplicidad y, a veces, la compensación de seguridad puede ser demasiado costosa, ya que el código simple no necesita un diseño sofisticado para mantenerse mantenible.

Como solución alternativa, sugiero definir macros usando lambdas para simplificar la inicialización para que se vea casi como el estilo C:

struct address {
  int street_no;
  const char *street_name;
  const char *city;
  const char *prov;
  const char *postal_code;
};
#define ADDRESS_OPEN [] { address _={};
#define ADDRESS_CLOSE ; return _; }()
#define ADDRESS(x) ADDRESS_OPEN x ADDRESS_CLOSE

La macro DIRECCIÓN se expande a

[] { address _={}; /* definition... */ ; return _; }()

que crea y llama a la lambda. Los parámetros de macro también están separados por comas, por lo que debe poner entre paréntesis el inicializador y llamar como

address temp_address = ADDRESS(( _.city = "Hamilton", _.prov = "Ontario" ));

También podría escribir macro inicializador generalizado

#define INIT_OPEN(type) [] { type _={};
#define INIT_CLOSE ; return _; }()
#define INIT(type,x) INIT_OPEN(type) x INIT_CLOSE

pero entonces la llamada es un poco menos hermosa

address temp_address = INIT(address,( _.city = "Hamilton", _.prov = "Ontario" ));

sin embargo, puede definir la macro DIRECCIÓN usando la macro INIT general fácilmente

#define ADDRESS(x) INIT(address,x)

En GNUC ++ (parece estar obsoleto desde 2.5, hace mucho tiempo :) Vea las respuestas aquí: Inicialización de estructura mediante etiquetas. Funciona, pero ¿cómo? ), es posible inicializar una estructura como esta:

struct inventory_item {
    int bananas;
    int apples;
    int pineapples;
};

inventory_item first_item = {
    bananas: 2,
    apples: 49,
    pineapples: 4
};

Inspirado por esta respuesta realmente ordenada: ( https://stackoverflow.com/a/49572324/4808079 )

Puedes hacer cierres de lamba:

// Nobody wants to remember the order of these things
struct SomeBigStruct {
  int min = 1;
  int mean = 3 ;
  int mode = 5;
  int max = 10;
  string name;
  string nickname;
  ... // the list goes on
}

.

class SomeClass {
  static const inline SomeBigStruct voiceAmps = []{
    ModulationTarget $ {};
    $.min = 0;  
    $.nickname = "Bobby";
    $.bloodtype = "O-";
    return $;
  }();
}

O, si quieres ser muy elegante

#define DesignatedInit(T, ...)\
  []{ T ${}; __VA_ARGS__; return $; }()

class SomeClass {
  static const inline SomeBigStruct voiceAmps = DesignatedInit(
    ModulationTarget,
    $.min = 0,
    $.nickname = "Bobby",
    $.bloodtype = "O-",
  );
}

Hay algunos inconvenientes relacionados con esto, principalmente relacionados con miembros no iniciados. Por lo que dicen los comentarios de las respuestas vinculadas, se compila de manera eficiente, aunque no lo he probado.

En general, creo que es un enfoque ordenado.