¿Cómo se llama la asignación mediante llaves? y puede ser controlado?

Question

¿Cómo se llama esto?

Vec3 foo = {1,2,3}; 

¿Se puede controlar a través de un operador o algo similar? Como en ¿puedo especificar cómo debería actuar?

Por ejemplo, si tuviera alguna clase complicada, ¿podría usar esto para asignar variables? (Solo un ejercicio de curiosidad).

Answer 1

Eso no es una tarea. Eso es inicialización.

Dicha inicialización está permitida solo para agregado, que incluye la clase POD. POD significa tipo de datos antiguos sin formato.

ejemplo,

//this struct is an aggregate (POD class) 
struct point3D 
{ 
    int x; 
    int y; 
    int z; 
}; 

//since point3D is an aggregate, so we can initialize it as 
point3D p = {1,2,3}; 

Ver la anterior compila bien: http://ideone.com/IXcSA

Pero otra vez considere esto:

//this struct is NOT an aggregate (non-POD class) 
struct vector3D 
{ 
    int x; 
    int y; 
    int z; 
    vector3D(int, int, int){} //user-defined constructor! 
}; 

//since vector3D is NOT an aggregate, so we CANNOT initialize it as 
vector3D p = {1,2,3}; //error 

Lo anterior no compila. Se da este error:

prog.cpp:15: error: braces around initializer for non-aggregate type ‘vector3D’

Véase a sí mismo: http://ideone.com/zO58c

¿Cuál es la diferencia entre point3D y vector3D? Solo el vector3D tiene un constructor definido por el usuario, y eso lo convierte en no POD. ¡Por lo tanto, no se puede inicializar con llaves!

---

¿Qué es un agregado?

La norma dice en la sección §8.5.1/1,

An aggregate is an array or a class (clause 9) with no user-declared constructors (12.1), no private or protected non-static data members (clause 11), no base classes (clause 10), and no virtual functions (10.3).

Y entonces se dice en §8.5.1/2 que,

When an aggregate is initialized the initializer can contain an initializer-clause consisting of a brace-enclosed, comma-separated list of initializer-clauses for the members of the aggregate, written in increasing subscript or member order. If the aggregate contains subaggregates, this rule applies recursively to the members of the subaggregate.

[Example: 

struct A 
{ 
    int x; 
    struct B 
    { 
     int i; 
     int j; 
    } b; 
} a = { 1, { 2, 3 } }; 

initializes a.x with 1, a.b.i with 2, a.b.j with 3. ]