Ponteiro para uma pergunta ponteiro

Question

Eu tenho uma classe com um ponteiro (não inteligente) para um objeto de interface (permite chamá-lo pInterface) e eu estou construindo uma classe aninhada que também precisa de acesso a essa interface. Estou indo para contornar esta situação, passando o ponteiro para a interface para o construtor da classe aninhada assim:

CNestedClass someClass( pInterface, ... );

No entanto tenho a certeza da melhor maneira de armazenar esse ponteiro na classe aninhada. Eu poderia usar:

1) A scoped (or other smart) pointer (to the original object)
2) A pointer to a pointer 

O que vocês sugerem e por quê?

EDIT:. Devo esclarecer - a classe aninhada precisará chamar métodos no objeto interface, no entanto, não criá-lo (ou modificar o objeto 'apontado' to), a classe pai é responsável por isso

Answer 1

O uso de um ponteiro de um ponteiro é, se uma ou outra classe pode alterar o valor do apontador - e.g. apagando o objeto existente e substituí-lo por um novo. Isso permite que ambas as classes ainda usar o mesmo objeto dereferenciando o ponteiro-para-ponteiro.

Se não a sua preocupação é garantir o objeto permanece válida para toda a vida de ambas as classes.

• Se a classe aninhada vidas mais curtas você realmente não precisa se preocupar.
• Se for a mesma, desde que você clean-up na ordem correta (classe por exemplo, aninhada em primeiro lugar, objeto mais tarde), em seguida, novamente, você não precisa se preocupar
• Se a classe aninhada pode persistir após o proprietário é destruído em seguida, você deve implementar uma maneira de garantir que o objeto também persiste.

Se você precisa para garantir a vida útil do objeto que poderia ser feito por meio de referência contagem-semântica, manualmente ou através de uma interface ponteiro inteligente.

Para um ponteiro inteligente, em seguida, boost :: shared_ptr seria uma boa escolha. shared_ptr permite que a propriedade de um objeto a ser compartilhada montante vários ponteiros. Quando o último shared_ptr sai do escopo, o objeto é excluído.

(note que este não é o caso com auto_ptr, onde um objeto são propriedade exclusiva).

As coisas para estar ciente de;

1. Ao usar boost :: shared_ptr ter certeza que a classe aninhada tem um cópia do shared_ptr e não uma referência / ponteiro.
2. std :: auto_ptr se comporta de forma bastante diferente, os objetos são de propriedade exclusiva e não compartilhada
3. boost :: shared_ptr só pode trabalhar com objetos de pilha, v.g. ponteiros retornado de uma chamada para 'novo'

Exemplo:

typedef boost::shared_ptr<Interface> shared_interface;

class NestedClass
{
  shared_interface mInterface; // empty pointer
}

void NestedClass::setInterface(shared_interface& foo)
{
  mInterface= foo; // take a copy of foo.
}

void ParentClass::init( void )
{
  // mInterface is also declared as shared_interface
  mInterface = new Interface();
  mNestedClass->setInterface(mInterface);
}

Answer 2

A outra razão que você pode querer usar um ponteiro para um ponteiro seria se o externo código pode alterar o valor do ponteiro de origem (por exemplo, fazê-lo apontar para um novo objeto, ou configurá-lo para NULL depois libertar o objecto que aponta para). No entanto, IMO, é bastante má prática para mudar um ponteiro depois de dá-lo a outra pessoa.

Então, se nem o código externo, nem a classe aninhada altera o ponteiro, apenas armazená-lo na classe aninhada como uma cópia do ponteiro original como uma variável de membro (campo).

Answer 3

Passe o endereço de um ponteiro para a interface (IMyInterface ** ppInterface), e preencher o ponteiro se for implementada pela classe.

A classe pode lançar seu este ponteiro para essa interface e preencha o ponteiro * ppInterface. Se a classe não implementa esta interface pode definir ppInterface * para NULL.

Answer 4

Basicamente, você está compartilhando um ponteiro para o mesmo objeto entre dois objetos diferentes. Se você não estiver usando os ponteiros inteligentes, simplesmente armazenar o ponteiro para o objeto compartilhado. Você deve ter cuidado com a propriedade do objeto compartilhado, ou seja, qual objeto é responsável para desalocar o objeto compartilhado e notificar os outros que ele foi embora.

Answer 5

class Outer
{
    class Inner
    {
    };
};

Como um objeto de Outer apenas detém um ponteiro RAW para um objeto pInterface isso implica que o objeto externo não possui nem tem qualquer controle sobre o tempo de vida do objeto pInterface. Esperamos, portanto, há alguma garantia de que o objeto pInterface vai viver tanto tempo quanto o objeto exterior; Neste caso não há nenhuma razão para sequer usar um ponteiro que você poderia usar apenas uma referência (assumindo que não há nenhuma situação que pInterface seria NULL).

Como Inner mantém a sua 'referência' (C referência não ++) depende e realmente precisamos de mais informações sobre a relação entre os objetos envolvidos!

• O que é o realationship entre objetos internos e externos.
• O que é o tempo de vida de um objeto interno em relação ao objeto exterior que herdou o ponteiro pInterface de?
• O que é a garantia de que um objeto externo tem uma vida útil mais curta do que um objeto pInterface.

etc.