Pergunta : Operador de atribuição perfeito 1

Olá!, o

How deve mim fazer o operador de atribuição perfeito para esta classe?

class TAAA : TSuperAAA
{
TBBB* b1_;
   TBBB* b2_;
}; o
TBBB é monomorphic e b1_, ponto something.
de b2_ class= do

Resposta : Operador de atribuição perfeito 1

>> especialmente quando Infinity08: escreveu que a garantia não é necessário no sistema real (se eu compreendi).

Não, eu não signifiquei que uma garantia não é necessário. O que eu disse em resposta ao borne da ambiência era que eu prefiro tratar as condições de erro diferentemente do que sua aproximação.

Há duas aproximações aqui (eu adicionei meus próprios pensamentos pessoais demasiado):

(a) Tentar escrever o operador de atribuição para deixar o objeto em um estado válido para cada encenação possível. Isto é basicamente impossível, ou extremamente duramente pelo menos. Há variáveis demais envolvidas, e encenação possível demais do erro. Additionaly, este tipo da aproximação adiciona limitações a o que o código pode fazer, que não é desejável em muitos casos.

(b) Evitar a complexidade adicionada que vem com a aproximação precedente, e adiar preferivelmente a responsabilidade para o código de chamada. O mecanismo das exceções é serido perfeitamente para aquele. Além disso, é geralmente o código de chamada que sabe o melhor como tratar um erro (qualquer um tentando a reparar, ignorar a, falhar graciosa, etc.), de modo que seja uma outra razão preferir esta aproximação.

A segunda aproximação é o que eu recomendo para o caso geral, porque é mais flexível, e mais fácil executar, e quando feito corretamente, você não perde qualquer coisa com considerações codificar a segurança.
A primeira aproximação é útil em determinados casos específicos, mas você começ rapidamente enterrado nas complexidades se você tenta a usar em toda parte heh.



>> Minha inspiração para fazer este borne é

É um artigo agradável, e cobre certamente muitas das armadilhas com os operadores de atribuição.


>> I e queriam saber o que é resposta correta para aquele.

Você anotará que o artigo começa com uma das maneiras corretas de aproximar um operador de atribuição. A única diferença com o código que eu afixei mais cedo, sou que seu operador de atribuição limpa corretamente após se caso que o alocamento de memória falha.

Isso é bom, mas não inteiramente necessário. O destruidor das classes é projetado limpar um objeto, assim que eu prefiro deixar lá essa responsabilidade, em vez de espalhá-la para fora toda sobre os métodos das classes.

Para a extremidade do artigo, as aproximações diferentes são discutidas demasiado.


Indo sobre meu código mais adiantado outra vez, eu manchei um erro embora. A “supressão b1_; a” linha deve ter sido seguida pelo “b1_ = 0; ” linha (similarmente para b2_). Pareço eu datilografava um heh demasiado rápido do bocado. Assim, torna-se:
1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
TAAA& TAAA:: operator= (taaa do const TAAA&) {
    TSuperAAA:: operator= (taaa);                   chamada de // o operador de atribuição para a classe baixa
    se (isto! = &taaa) {                          verificação de // para a atribuição do auto
        supressão b1_;
        b1_ = 0;
        b1_ = TBBB novo (taaa.b1_);
        supressão b2_;
        b2_ = 0;
        b2_ = TBBB novo (taaa.b2_);
    }
    *this do retorno;
}
Outras soluções  
 
programming4us programming4us