¿Cómo inicializar estructuras anidadas en C++?

Question

He creado un par de estructuras diferentes en un programa. Ahora tengo una estructura con estructuras anidadas; sin embargo, no puedo encontrar la forma de inicializarlas correctamente. Las estructuras se enumeran a continuación.

/***POINT STRUCTURE***/ 
struct Point{ 
    float x;     //x coord of point 
    float y;     //y coord of point 
}; 

/***Bounding Box STRUCTURE***/ 
struct BoundingBox{ 
    Point ymax, ymin, xmax, xmin; 
}; 

/***PLAYER STRUCTURE***/ 
struct Player{ 
    vector<float> x;   //players xcoords 
    vector<float> y;   //players ycoords 
    BoundingBox box; 
    float red,green,blue;  //red, green, blue colour values 
    float r_leg, l_leg;   //velocity of players right and left legs 
    int poly[3];    //number of points per polygon (3 polygons) 
    bool up,down;    
}; 

Intento intializar una estructura de jugador recién creada llamada jugador.

//Creates player, usings vectors copy and iterator constructors 
Player player = { 
vector<float>(xcords,xcords + (sizeof(xcords)/sizeof(float))), //xcords of player 
vector<float>(ycords,ycords + (sizeof(ycords)/sizeof(float))), //ycoords of playe 
box.ymax = 5;    //create bounding box 
box.ymin = 1; 
box.xmax = 5; 
box.xmin = 1; 
1,1,1,      //red, green, blue 
0.0f,0.0f,     //r_leg,l_leg 
{4,4,4},     //number points per polygon 
true,false};    //up, down 

Esto causa varios errores diferentes, relacionados con la caja. La definición de la casilla no tiene un identificador claro y una estructura o sintaxis faltante antes de '.'.

Luego probé sólo para crear una estructura Player y su inicialización de los miembros de la siguiente manera:

Player bob; 
bob.r_leg = 1; 

Pero esto provoca más errores, como el compilador piensa que Bob tiene ningún identificador o falta alguna sintaxis.

Busqué en Google el problema pero no encontré ningún artículo que me mostrara cómo inicializar muchos miembros diferentes de estructuras anidadas dentro de la estructura (principal). Cualquier ayuda sobre este tema sería muy apreciada :-) !!!

Answer 1

inicializar normalmente con { ... }:

Player player = { 
    vector<float>(xcords,xcords + (sizeof(xcords)/sizeof(float))), 
    vector<float>(ycords,ycords + (sizeof(ycords)/sizeof(float))), 
    5, 1, 5, 1, 5, 1, 5, 1, 
    1.0f,1.0f,1.0f,       //red, green, blue 
    0.0f,0.0f,        //r_leg,l_leg 
    {4,4,4},        //number points per polygon 
    true,false 
}; 

Ahora, que es el uso de "elisión corsé". Algunos compiladores advierten de eso, a pesar de que es completamente estándar, porque podría confundir a los lectores. Mejor agrega frenos, por lo que queda claro lo que se ha inicializado donde:

Player player = { 
    vector<float>(xcords,xcords + (sizeof(xcords)/sizeof(float))), 
    vector<float>(ycords,ycords + (sizeof(ycords)/sizeof(float))), 
    { { 5, 1 }, { 5, 1 }, { 5, 1 }, { 5, 1 } }, 
    1.0f, 1.0f, 1.0f,    //red, green, blue 
    0.0f, 0.0f,      //r_leg,l_leg 
    { 4, 4, 4 },     //number points per polygon 
    true, false 
}; 

Si sólo desea volver a la x miembro de los puntos, puede hacerlo mediante la omisión de la otra inicializador. Los elementos restantes en agregados (arrays, structs) se inicializarán en valor a los valores "correctos"; por lo tanto, NULL para punteros, false para bool, cero para ints y así sucesivamente, y usarán el constructor para tipos definidos por el usuario, aproximadamente. La fila que inicializa los puntos se ve así:

{ { 5 }, { 5 }, { 5 }, { 5 } }, 

Ahora podría ver el peligro de usar la elisión de abrazadera. Si agrega algún miembro a su estructura, todos los inicializadores se "desplazarán" de sus elementos reales que deberían inicializar, y podrían golpear otros elementos accidentalmente. Así que será mejor que siempre use aparatos ortopédicos cuando sea apropiado.

Considere usar constructores.Acabo de completar tu código que muestra cómo lo harías utilizando los inicializadores incluidos.

Answer 2

Puede añadir valores por defecto a una estructura así:

struct Point{ 
    Point() : x(0), y(0) 
    { }; 

    float x; 
    float y; 
}; 

o

struct Point{ 
    Point() 
    { 
     x = 0; 
     y = 0; 
    }; 

    float x; 
    float y; 
}; 

Para añadir esos valores durante la construcción, agregar parámetros a los constructores de esta manera:

struct Point{ 
    Point(float x, float y) 
    { 
     this->x = x; 
     this->y = y; 
    }; 

    float x; 
    float y; 
}; 

y ejemplificarlos con estos:

Point Pos(10, 10); 
Point *Pos = new Point(10, 10); 

Esto también funciona para sus otras estructuras de datos.

Answer 3

Parece que el cuadro delimitador solo debe contener flotadores, no puntos?

Dicho esto podría funcionar:

Player player = { 
vector<float>(xcords,xcords + (sizeof(xcords)/sizeof(float))), //xcords of player 
vector<float>(ycords,ycords + (sizeof(ycords)/sizeof(float))), //ycoords of playe 
{{1.0,5.0},{1.0,5.0},{1.0,5.0},{1.0,5.0}}, 
1,1,1,           //red, green, blue 
0.0f,0.0f,        //r_leg,l_leg 
{4,4,4},        //number points per polygon 
true,false}; 

(no probado) ...