Como ler:
Este artigo é bastante longo. Se você quiser saber sobre agregados e PODs (dados antigos simples), reserve um tempo e leia-o. Se você estiver interessado apenas em agregados, leia apenas a primeira parte. Se você estiver interessado apenas em PODs, deverá primeiro ler a definição, implicações e exemplos de agregados e, em seguida, poderá pular para PODs, mas eu ainda recomendo a leitura da primeira parte na íntegra. A noção de agregados é essencial para a definição de PODs. Se você encontrar algum erro (mesmo menor, incluindo gramática, estilística, formatação, sintaxe etc.), deixe um comentário, eu o edito.
Esta resposta se aplica ao C ++ 03. Para outros padrões C ++, consulte:
O que são agregados e por que são especiais
Definição formal do padrão C ++ ( C ++ 03 8.5.1 §1 ) :
Um agregado é uma matriz ou uma classe (cláusula 9) sem construtores declarados pelo usuário (12.1), sem membros de dados não estáticos privados ou protegidos (cláusula 11), sem classes base (cláusula 10) e sem funções virtuais (10.3 )
Então, tudo bem, vamos analisar essa definição. Primeiro de tudo, qualquer matriz é um agregado. Uma classe também pode ser agregada se ... espere! nada é dito sobre estruturas ou sindicatos, eles não podem ser agregados? Sim eles podem. Em C ++, o termo classrefere-se a todas as classes, estruturas e uniões. Portanto, uma classe (ou estrutura ou união) é agregada se, e somente se, atender aos critérios das definições acima. O que esses critérios implicam?
Isso não significa que uma classe agregada não possa ter construtores, na verdade, pode ter um construtor padrão e / ou um construtor de cópias, desde que declarados implicitamente pelo compilador e não explicitamente pelo usuário.
Nenhum membro de dados não estático privado ou protegido . Você pode ter quantas funções membro privadas e protegidas (mas não construtores), bem como muitos membros de dados estáticos privados ou protegidos e funções membro conforme desejar e não violar as regras para classes agregadas
Uma classe agregada pode ter um operador e / ou destrutor de atribuição de cópia declarado / definido pelo usuário
Uma matriz é agregada, mesmo que seja uma matriz do tipo de classe não agregada.
Agora vamos ver alguns exemplos:
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
};
Você entendeu a ideia. Agora vamos ver como os agregados são especiais. Diferentemente de classes não agregadas, elas podem ser inicializadas com chaves {}. Essa sintaxe de inicialização é comumente conhecida por matrizes, e acabamos de aprender que elas são agregadas. Então, vamos começar com eles.
Type array_name[n] = {a1, a2, …, am};
se (m == n)
o i- ésimo elemento da matriz é inicializado com um i
else se (m <n)
os primeiros m elementos da matriz são inicializados com 1 , 2 ,…, am e os outrosn - melementos são, se possível, inicializados por valor (veja abaixo a explicação do termo);
caso contrário, (m> n)
o compilador emitirá
outro erro (esse é o caso quando n não for especificado de maneira alguma int a[] = {1, 2, 3};)
o tamanho de a matriz (n) é assumida como igual a m, portantoint a[] = {1, 2, 3};é equivalente aint a[3] = {1, 2, 3};
Quando um objecto de tipo escalar ( bool, int, char, double, pontos, etc.) é inicializado-valor , isso significa que é inicializado com 0para que tipo ( falsepara bool, 0.0por double, etc). Quando um objeto do tipo classe com um construtor padrão declarado pelo usuário é inicializado por valor, seu construtor padrão é chamado. Se o construtor padrão for definido implicitamente, todos os membros não estáticos serão recursivamente inicializados por valor. Essa definição é imprecisa e um pouco incorreta, mas deve fornecer a ideia básica. Uma referência não pode ser inicializada por valor. A inicialização de valor para uma classe não agregada pode falhar se, por exemplo, a classe não tiver um construtor padrão apropriado.
Exemplos de inicialização 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
}
Agora vamos ver como as classes agregadas podem ser inicializadas com chaves. Praticamente da mesma maneira. Em vez dos elementos da matriz, inicializaremos os membros de dados não estáticos na ordem em que aparecem na definição de classe (todos eles são públicos por definição). Se houver menos inicializadores do que membros, o restante será inicializado por valor. Se for impossível inicializar com valor um dos membros que não foram explicitamente inicializados, obteremos um erro em tempo de compilação. Se houver mais inicializadores do que o necessário, também obteremos um erro em tempo de compilação.
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}};
No exemplo acima, y.cé inicializado com 'a', y.x.i1com 10, y.x.i2com 20, y.i[0]com 20, y.i[1]com 30e y.fé inicializado por valor, ou seja, inicializado com 0.0. O membro estático protegido dnão é inicializado, porque é static.
As uniões agregadas são diferentes, pois você pode inicializar apenas o primeiro membro com chaves. Eu acho que se você é avançado o suficiente em C ++ para considerar o uso de uniões (o uso deles pode ser muito perigoso e deve ser considerado com cuidado), você mesmo pode procurar as regras para uniões no padrão :).
Agora que sabemos o que há de especial em agregados, vamos tentar entender as restrições nas classes; ou seja, por que eles estão lá. Devemos entender que a inicialização de membros com chaves implica que a classe nada mais é do que a soma de seus membros. Se um construtor definido pelo usuário estiver presente, isso significa que o usuário precisa executar algum trabalho extra para inicializar os membros, portanto, a inicialização entre chaves estaria incorreta. Se houver funções virtuais, significa que os objetos desta classe têm (na maioria das implementações) um ponteiro para a chamada vtable da classe, que é definida no construtor, portanto, a inicialização entre chaves seria insuficiente. Você pode descobrir o restante das restrições de maneira semelhante a um exercício :).
O suficiente sobre os agregados. Agora podemos definir um conjunto mais estrito de tipos, ou seja, PODs
O que são PODs e por que são especiais
Definição formal do padrão C ++ ( C ++ 03 9 §4 ) :
Uma estrutura POD é uma classe agregada que não possui membros de dados não estáticos do tipo estrutura não POD, união não POD (ou matriz de tais tipos) ou referência e não possui operador de atribuição de cópia definido pelo usuário nem destruidor definido pelo usuário. Da mesma forma, uma união POD é uma união agregada que não possui membros de dados não estáticos do tipo estrutura não POD, união POD (ou matriz de tais tipos) ou referência e não possui operador de atribuição de cópia definido pelo usuário e nenhum destruidor definido pelo usuário. Uma classe POD é uma classe que é uma estrutura POD ou uma união POD.
Uau, esse é mais difícil de analisar, não é? :) Vamos deixar os sindicatos de fora (pelo mesmo motivo acima) e reformular de uma maneira um pouco mais clara:
Uma classe agregada é chamada de POD se não tiver um operador e destruidor de atribuição de cópia definido pelo usuário e nenhum de seus membros não estáticos for uma classe não-POD, matriz de não-POD ou uma referência.
O que essa definição implica? (Eu mencionei POD significa Plain Old Data ?)
- Todas as classes POD são agregadas ou, em outras palavras, se uma classe não é agregada, é certo que não é uma POD
- Classes, assim como estruturas, podem ser PODs, mesmo que o termo padrão seja POD-struct para ambos os casos
- Assim como no caso de agregados, não importa que membros estáticos a classe tenha
Exemplos:
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
};
Classes POD, uniões POD, tipos escalares e matrizes desses tipos são chamados coletivamente de tipos POD.
Os PODs são especiais de várias maneiras. Vou fornecer apenas alguns exemplos.
As classes POD são as mais próximas às estruturas C. Diferentemente deles, os PODs podem ter funções membro e membros estáticos arbitrários, mas nenhum desses dois altera o layout da memória do objeto. Portanto, se você deseja escrever uma biblioteca dinâmica mais ou menos portátil que possa ser usada do C e até do .NET, tente fazer com que todas as suas funções exportadas tomem e retornem apenas parâmetros dos tipos POD.
A vida útil dos objetos do tipo não-POD começa quando o construtor termina e termina quando o destruidor termina. Para as classes POD, a vida útil começa quando o armazenamento do objeto é ocupado e termina quando esse armazenamento é liberado ou reutilizado.
Para objetos de tipos POD, é garantido pelo padrão que, quando você memcpycolocar o conteúdo do seu objeto em uma matriz de caracteres ou caracteres não assinados, e depois memcpyo conteúdo voltar ao objeto, o objeto manterá seu valor original. Observe que não existe essa garantia para objetos de tipos não POD. Além disso, você pode copiar objetos POD com segurança memcpy. O exemplo a seguir assume que T é do 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
declaração goto. Como você deve saber, é ilegal (o compilador deve emitir um erro) saltar via goto de um ponto em que alguma variável ainda não estava no escopo para um ponto em que já está no escopo. Esta restrição se aplica apenas se a variável for do tipo não POD. No exemplo a seguir f()está mal formado, enquanto g()está bem formado. Observe que o compilador da Microsoft é muito liberal com essa regra - apenas envia um aviso nos dois 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;
}
É garantido que não haverá preenchimento no início de um objeto POD. Em outras palavras, se um POD de classe de um primeiro membro é do tipo T, você pode com segurança reinterpret_casta partir A*de T*e obter o ponteiro para o primeiro membro e vice-versa.
A lista continua e continua…
Conclusão
É importante entender o que exatamente é um POD, porque muitos recursos de linguagem, como você vê, se comportam de maneira diferente para eles.