Passando uma classe de objecto a uma função (provavelmente por não ponteiro de referência) C ++

Question

Então, digamos que eu tenho duas funções diferentes. Um deles é uma parte da classe BST, é apenas uma função auxiliar que irá chamar essa função Class. Vou enumerá-los aqui.

sieve(BST<T>* t, int n);

esta função é chamada assim: peneira (T, N), o objecto é chamado de BST t;

Eu vou estar usando a função de classe de remoção dentro da função peneira para retirar objetos específicos. Eu não tenho certeza que o meu protótipo para esta função básica deve ser semelhante? Fazendo isso:

sieve(BST<int> t, int n)

O que acontece aqui é tudo compila bem, mas quando t.remove função é chamada não vejo resultados reais. Estou assumindo porque é apenas a criação de uma cópia ou um outro objeto t todo, em vez de passar a um da minha função main ().

Se eu chamar a função remove (t.remove (valor)) na minha função principal, onde o objeto original foi criado ele remove tudo corretamente. Uma vez que eu começar a fazer isso através da minha função peneira vejo nenhuma mudança quando eu re imprimi-lo de minha função principal. Assim, a minha principal função é algo como isto:

int main ()
{
   int n,
       i,
       len;

   BST<int> t;

   cin >> n;
   vector<int> v(n);

   srand(1);

   for (i = 0; i < n; i++)
      v[i] = rand() % n;

   for (i = 0; i < n; i++)
      t.insert(v[i]);
       print_stat(t);
   t.inOrder(print_data);



   sieve(v,t,n);
   print_stat(t);
   t.inOrder(print_data);
   return 0;
}

Assim, meus resultados acabam sendo o mesmo, apesar de minhas declarações de depuração dentro das funções mostrar que está realmente apagar alguma coisa. Eu estou supondo que onde estou indo errado é como eu estou passando o objeto t para a função.

Answer 1

sieve(BST<int>& t, int n)

Os especifica & passando por referência em vez do valor. : -)

Answer 2

Se bem entendi o seu problema, você deve usar

BST t;    
sieve(BST<T> *t, int n);

e invocá-la como:

sieve(&t,n)

passando o ponteiro para o objeto t

ou

BST t; 
sieve(BST<T> &t, int n);

e invocá-la como:

sieve(t,n)

passar a referência para o objeto t

Answer 3

A assinatura:

/* missing return type */ sieve<BST<int> t, int n);

será, de fato, fazer uma cópia do BST<int> passado para sieve(). Portanto, as alterações feitas a ele vai ser jogado fora (a menos que você retornar uma cópia do mesmo).

Você provavelmente vai querer algo como:

void sieve<BST<int> & t, int n);

que passa em uma referência, de modo que quaisquer modificações que você faz para t dentro do método são feitas para o objeto que você passou no (não uma cópia).

Depois de conseguir isso para baixo e compreendê-lo, você provavelmente vai querer fazer a função sieve() um "modelo de função" para que ele possa tomar um BST<> contendo qualquer tipo.

Answer 4

O que acontece aqui é tudo compila bem, mas quando t.remove função é chamada não vejo resultados reais. Estou assumindo porque é apenas a criação de uma cópia ou um outro objeto t todo, em vez de passar a um da minha função main ().

Correto. Isso é exatamente o que acontece, porque em parâmetros C ++ são passados ??para funcitons por valor. Passando uma referência ou um ponteiro vai resolver o seu problema. Usando uma referência é mais limpo.