Cómo leer:
Este artículo es bastante largo. Si desea saber acerca de los agregados y los POD (datos antiguos simples), tómese el tiempo y léalo. Si solo le interesan los agregados, lea solo la primera parte. Si solo le interesan los POD, primero debe leer la definición, las implicaciones y los ejemplos de agregados y luego puede saltar a los POD, pero aún así le recomendaría leer la primera parte en su totalidad. La noción de agregados es esencial para definir los POD. Si encuentra algún error (incluso menor, incluyendo gramática, estilística, formato, sintaxis, etc.), deje un comentario, lo editaré.
Esta respuesta se aplica a C ++ 03. Para otros estándares de C ++ ver:
¿Qué son los agregados y por qué son especiales?
Definición formal del estándar C ++ ( C ++ 03 8.5.1 §1 ) :
Un agregado es una matriz o una clase (cláusula 9) sin constructores declarados por el usuario (12.1), sin miembros de datos no estáticos privados o protegidos (cláusula 11), sin clases base (cláusula 10) y sin funciones virtuales (10.3 )
Entonces, OK, analicemos esta definición. En primer lugar, cualquier matriz es un agregado. Una clase también puede ser un agregado si ... ¡espera! no se dice nada sobre estructuras o sindicatos, ¿no pueden ser agregados? Sí pueden. En C ++, el término se classrefiere a todas las clases, estructuras y uniones. Entonces, una clase (o estructura, o unión) es un agregado si y solo si cumple los criterios de las definiciones anteriores. ¿Qué implican estos criterios?
Esto no significa que una clase agregada no pueda tener constructores, de hecho puede tener un constructor predeterminado y / o un constructor de copia siempre que el compilador los declare implícitamente y no explícitamente el usuario
No hay miembros de datos privados o protegidos no estáticos . Puede tener tantas funciones miembro privadas y protegidas (pero no constructores), así como tantos miembros privados o protegidos de datos estáticos y funciones miembro como desee y no violar las reglas para las clases agregadas
Una clase agregada puede tener un operador y / o destructor de asignación de copia definido / definido por el usuario
Una matriz es un agregado, incluso si es una matriz de tipo de clase no agregada.
Ahora veamos algunos ejemplos:
class NotAggregate1
{
virtual void f() {} //remember? no virtual functions
};
class NotAggregate2
{
int x; //x is private by default and non-static
};
class NotAggregate3
{
public:
NotAggregate3(int) {} //oops, user-defined constructor
};
class Aggregate1
{
public:
NotAggregate1 member1; //ok, public member
Aggregate1& operator=(Aggregate1 const & rhs) {/* */} //ok, copy-assignment
private:
void f() {} // ok, just a private function
};
Tienes la idea. Ahora veamos cómo los agregados son especiales. A diferencia de las clases no agregadas, se pueden inicializar con llaves {}. Esta sintaxis de inicialización se conoce comúnmente para las matrices, y acabamos de enterarnos de que son agregados. Entonces, comencemos con ellos.
Type array_name[n] = {a1, a2, …, am};
if (m == n)
el i- ésimo elemento de la matriz se inicializa con un i
else if (m <n)
los primeros m elementos de la matriz se inicializan con 1 , a 2 , ..., a my los otrosn - melementos son, si es posible, inicializados en valor (vea a continuación la explicación del término) de lo
contrario si (m> n)
el compilador emitirá un error
más (este es el caso cuando n no se especifica del todo int a[] = {1, 2, 3};)
el tamaño de se supone que la matriz (n) es igual a m, por lo queint a[] = {1, 2, 3};es equivalente aint a[3] = {1, 2, 3};
Cuando un objeto de tipo escalar ( bool, int, char, double, punteros, etc.) es de valor inicializado que significa que se inicializa con 0para ese tipo ( falsepara bool, 0.0para double, etc.). Cuando un objeto de tipo de clase con un constructor predeterminado declarado por el usuario tiene un valor inicializado, se llama a su constructor predeterminado. Si el constructor predeterminado se define implícitamente, todos los miembros no estáticos se inicializan de forma recursiva. Esta definición es imprecisa y un poco incorrecta, pero debería darle la idea básica. Una referencia no puede ser inicializada en valor. La inicialización del valor para una clase no agregada puede fallar si, por ejemplo, la clase no tiene un constructor predeterminado apropiado.
Ejemplos de inicialización de matriz:
class A
{
public:
A(int) {} //no default constructor
};
class B
{
public:
B() {} //default constructor available
};
int main()
{
A a1[3] = {A(2), A(1), A(14)}; //OK n == m
A a2[3] = {A(2)}; //ERROR A has no default constructor. Unable to value-initialize a2[1] and a2[2]
B b1[3] = {B()}; //OK b1[1] and b1[2] are value initialized, in this case with the default-ctor
int Array1[1000] = {0}; //All elements are initialized with 0;
int Array2[1000] = {1}; //Attention: only the first element is 1, the rest are 0;
bool Array3[1000] = {}; //the braces can be empty too. All elements initialized with false
int Array4[1000]; //no initializer. This is different from an empty {} initializer in that
//the elements in this case are not value-initialized, but have indeterminate values
//(unless, of course, Array4 is a global array)
int array[2] = {1, 2, 3, 4}; //ERROR, too many initializers
}
Ahora veamos cómo se pueden inicializar las clases agregadas con llaves. Más o menos de la misma manera. En lugar de los elementos de la matriz, inicializaremos los miembros de datos no estáticos en el orden de su aparición en la definición de clase (todos son públicos por definición). Si hay menos inicializadores que miembros, el resto tiene valor inicializado. Si es imposible inicializar con valor uno de los miembros que no se inicializaron explícitamente, obtenemos un error en tiempo de compilación. Si hay más inicializadores de los necesarios, también obtenemos un error en tiempo de compilación.
struct X
{
int i1;
int i2;
};
struct Y
{
char c;
X x;
int i[2];
float f;
protected:
static double d;
private:
void g(){}
};
Y y = {'a', {10, 20}, {20, 30}};
En el ejemplo anterior y.cse inicializa con 'a', y.x.i1con 10, y.x.i2con 20, y.i[0]con 20, y.i[1]con 30y y.fse inicializa el valor, es decir, se inicializa con 0.0. El miembro estático protegido dno se inicializa en absoluto, porque lo es static.
Las uniones agregadas son diferentes en que puede inicializar solo su primer miembro con llaves. Creo que si está lo suficientemente avanzado en C ++ como para considerar el uso de uniones (su uso puede ser muy peligroso y debe pensarse cuidadosamente), puede buscar las reglas para las uniones en el estándar usted mismo :).
Ahora que sabemos qué tienen de especial los agregados, intentemos comprender las restricciones sobre las clases; Por eso están ahí. Debemos entender que la inicialización de los miembros con llaves implica que la clase no es más que la suma de sus miembros. Si está presente un constructor definido por el usuario, significa que el usuario necesita hacer un trabajo adicional para inicializar los miembros, por lo tanto, la inicialización de llaves sería incorrecta. Si las funciones virtuales están presentes, significa que los objetos de esta clase tienen (en la mayoría de las implementaciones) un puntero a la llamada vtable de la clase, que se establece en el constructor, por lo que la inicialización de llaves sería insuficiente. Podrías resolver el resto de las restricciones de manera similar a un ejercicio :).
Tan suficiente sobre los agregados. Ahora podemos definir un conjunto más estricto de tipos, a saber, POD
¿Qué son los POD y por qué son especiales?
Definición formal del estándar C ++ ( C ++ 03 9 §4 ) :
Un POD-struct es una clase agregada que no tiene miembros de datos no estáticos de tipo non-POD-struct, non-POD-union (o array de tales tipos) o referencia, y no tiene operador de asignación de copia definido por el usuario y no destructor definido por el usuario. Del mismo modo, una unión POD es una unión agregada que no tiene miembros de datos no estáticos de tipo non-POD-struct, non-POD-union (o matriz de tales tipos) o referencia, y no tiene operador de asignación de copia definido por el usuario y sin destructor definido por el usuario. Una clase POD es una clase que es una estructura POD o una unión POD.
Wow, este es más difícil de analizar, ¿no? :) Dejemos de lado las uniones (por los mismos motivos que antes) y reformulemos de una manera más clara:
Una clase agregada se denomina POD si no tiene un operador y destructor de asignación de copias definido por el usuario y ninguno de sus miembros no estáticos es una clase no POD, una matriz de no POD o una referencia.
¿Qué implica esta definición? (¿Mencioné POD significa Plain Old Data ?)
- Todas las clases de POD son agregados, o, para decirlo al revés, si una clase no es un agregado, entonces seguramente no es un POD
- Las clases, al igual que las estructuras, pueden ser POD aunque el término estándar sea estructura POD para ambos casos.
- Al igual que en el caso de los agregados, no importa qué miembros estáticos tenga la clase
Ejemplos:
struct POD
{
int x;
char y;
void f() {} //no harm if there's a function
static std::vector<char> v; //static members do not matter
};
struct AggregateButNotPOD1
{
int x;
~AggregateButNotPOD1() {} //user-defined destructor
};
struct AggregateButNotPOD2
{
AggregateButNotPOD1 arrOfNonPod[3]; //array of non-POD class
};
Las clases POD, las uniones POD, los tipos escalares y las matrices de tales tipos se denominan colectivamente tipos POD.
Los POD son especiales en muchos sentidos. Proporcionaré solo algunos ejemplos.
Las clases POD son las más cercanas a las estructuras C. A diferencia de ellos, los POD pueden tener funciones miembro y miembros estáticos arbitrarios, pero ninguno de estos dos cambia la disposición de la memoria del objeto. Por lo tanto, si desea escribir una biblioteca dinámica más o menos portátil que se pueda usar desde C e incluso .NET, debe intentar hacer que todas sus funciones exportadas tomen y devuelvan solo parámetros de tipos POD.
La vida útil de los objetos de tipo de clase que no es POD comienza cuando el constructor ha terminado y termina cuando el destructor ha terminado. Para las clases POD, la vida útil comienza cuando el almacenamiento del objeto está ocupado y termina cuando ese almacenamiento se libera o se reutiliza.
Para los objetos de tipo POD, el estándar garantiza que cuando memcpyel contenido de su objeto se convierta en una matriz de caracteres char o unsigned char, y luego memcpyel contenido vuelva a su objeto, el objeto mantendrá su valor original. Tenga en cuenta que no existe tal garantía para objetos de tipos que no sean POD. Además, puede copiar objetos POD de forma segura con memcpy. El siguiente ejemplo supone que T es un tipo POD:
#define N sizeof(T)
char buf[N];
T obj; // obj initialized to its original value
memcpy(buf, &obj, N); // between these two calls to memcpy,
// obj might be modified
memcpy(&obj, buf, N); // at this point, each subobject of obj of scalar type
// holds its original value
Ir a la declaración. Como sabrán, es ilegal (el compilador debe emitir un error) realizar un salto a través de goto desde un punto donde alguna variable aún no estaba dentro del alcance hasta un punto donde ya está dentro del alcance. Esta restricción se aplica solo si la variable es de tipo no POD. En el siguiente ejemplo f()está mal formado, mientras que g()está bien formado. Tenga en cuenta que el compilador de Microsoft es demasiado liberal con esta regla: solo emite una advertencia en ambos casos.
int f()
{
struct NonPOD {NonPOD() {}};
goto label;
NonPOD x;
label:
return 0;
}
int g()
{
struct POD {int i; char c;};
goto label;
POD x;
label:
return 0;
}
Se garantiza que no habrá relleno al comienzo de un objeto POD. En otras palabras, si el primer miembro de una clase de POD A es de tipo T, que puede de manera segura reinterpret_casta partir A*de T*y obtener el puntero al primer elemento y viceversa.
La lista sigue y sigue…
Conclusión
Es importante entender qué es exactamente un POD porque muchas características del lenguaje, como puede ver, se comportan de manera diferente para ellos.