escopo variáveis ??de membro privadas - C ++

Question

Eu estou apenas começando com C ++ e tem alguns problemas em compreender como o escopo para variáveis ??de membro privadas em uma fábrica de classe. Consulte o código abaixo

class Foo{
    private:
        std::vector<int> container;
    public:
        // other methods
};

int main(int argc, char* argv[])
{
    Foo* foo = new Foo;
    // other method calls to which foo is passed
    delete foo;
    return 0;
}

No código acima, variável "recipiente" é uma variável membro privado. Eu estou chamando instância "Foo" e passá-lo para vários outros métodos e classes. A seguir estão as minhas dúvidas

1. Qual será o âmbito da variável "recipiente"? Será que existem variável até que eu apagar o foo exemplo?
2. que eu preciso para fazer o "recipiente" como um ponteiro para vetor?

Obrigado pela ajuda

Answer 1

1. Sim, a tempo de vida do membro recipiente irá durar tanto quanto o objeto que contém ela existe, que é até que você chamar delete no ponteiro apontando para ele (foo no seu caso).
2. Não, não há nenhuma razão para fazer isso. Tornando-se um ponteiro requer a criação de um objeto dinâmico de vector<int> que você precisa para gerenciar o tempo de vida (incluindo chamando de exclusão no ponteiro container). Isso é desnecessário aqui. Supondo que você deseja que o recipiente última contanto que o objeto Foo, você está bem com tê-lo diretamente contido, sem fazê-lo com um ponteiro.

Passando o ponteiro foo vai apenas passar o ponteiro. O objeto que ele aponta para a vontade não ser copiado, apenas o ponteiro apontando para ele se necassary. Se você sabe Java, então ele ajuda você Se eu te disser que passa o ponteiro é o mesmo que apenas passando uma referência a um objeto em Java, dizer:

Foo f = new Foo();
// just passes the reference (pointer in C++) to doIt. 
// the actual object is not copied
doIt(f);

Answer 2

Eu estou chamando "Foo" instância

Na verdade, você está criando uma instância de class Foo .

Especificamente, você está alocando um bloco de memória fora do heap via new () . Este bloco de memória é grande o suficiente para conter Foo :: recipiente e qualquer outra classe sobrecarga Foo requer.

(Neste exemplo, não há nenhuma. Com outras classes, pode haver atributos adicionais ou talvez uma mesa-pointer virtual.)

Naturalmente, new () invoca o (talvez padrão?) Foo :: Foo () construtor, que, por sua vez inicializa Foo :: recipiente através do std :: vector construtor.

Qual será o âmbito da variável "recipiente"?

recipiente é um atributo [componente] do exemplo foo . Ela existe desde que a instância foo existe.

Scope-wise, podemos falar de Foo :: recipiente . Mas você não pode acessar Foo :: constainer , sem uma instância da classe Foo . (Por exemplo, o objeto foo .) Foo :: constainer não existe sem uma instância da classe Foo .

(Há de classe-variáveis ??que o trabalho um pouco diferente, onde um valor é compartilhado entre todas as instâncias. Mas isso não é o caso aqui.)

Este escopo é IRRELEVANTE para o seu membro-de controle de acesso público / protegidos / / private amigo.

por exemplo., Em alguns Foo :: myPublicMethod () , você pode se referir a Foo :: recipiente . Embora você também pode renunciar ao escopo explícita nesta situação e apenas se referem a ele como recipiente .

Mind você, sendo privada, não é possível o acesso Foo :: recipiente fora da classe do Foo métodos.

Will que existem variável até que eu apagar o foo exemplo?

Sim.

Eu preciso fazer o "recipiente" como um ponteiro para vetor?

No. Você pode, mas você certamente não precisa.

De um modo geral, eu recomendo contra membros de instância de classe sendo ponteiros juntamente com nova no construtor e excluir no processo de destruição. É ineficiente e problemático. (O construtor de cópia padrão pode copiar o valor do ponteiro, o destruidor pode então excluir o mesmo valor ponteiro duas vezes.)

---

Dependendo de suas necessidades, você pode considerar:

int main(int argc, char* argv[])
{
  Foo foo;
  // other method calls to which foo is passed
  return 0;
}

foo iria sair do âmbito após return 0; , e ser excluído automaticamente. Além disso, foo seria alocado na pilha em vez da pilha.

---

Você pode encontrar uma cópia usada do The Annotated C ++ referência manual útil . É velho, mas tem uma alta relação sinal-ruído.