Newsgroup: it.comp.lang.c++
Titolo: [REQ] Passare oggetto come parametro ad una funzione membro...

Ho una classe Primo e una classe Secondo.
Vorrei passare ad una funzione membro di Secondo
come parametro un oggetto di classe Primo.
Devo passargli un puntatore?
Devo dichiarare all'interno di Secondo
un oggetto di tipo Primo?
Come si può fare??
Sui vari tutorial e libri non riesco a trovare
niente che faccia al caso mio..
grazie,
Blob

 un oggetto di tipo Primo?
No.
E.

come parametro un oggetto di classe Primo.
void Secondo::tuaFunzione(const Primo& primo);
void Secondo::tuaFunzione(Primo& primo);
La natura const o non-const del parametro dipende da ciò che vuoi fare
dell'istanza di Primo.
Altri tipi di passaggi sono per copia:
void Secondo::tuaFunzione(const Primo primo);
void Secondo::tuaFunzione(Primo primo);
In questo caso è bene che Primo abbia un costruttore di copia e questo
tipo di chiamata non va bene se l'oggetto è troppo grande.
Il terzo tipo è il passaggio per puntatore:
void Secondo::tuaFunzione(const Primo *primo);
void Secondo::tuaFunzione(Primo *primo);
Ma è bene evitare l'uso dei puntatori, laddove è possibile usare i
reference.
Il seguente programma:
<CODE>
#include <iostream>
class Primo {
private:
  int m_x;
public:
  int getX() const { return m_x; }
  Primo(int x=0) { 
    m_x = x;
    std::cout << "Primo costruito: x = " << m_x << std::endl; 
  }
  Primo(const Primo& primo) { 
    m_x = primo.getX();
    std::cout << "Primo costruito per copia: x = " << m_x <<
std::endl; 
  }
};
class Secondo {
public:
  Secondo() { std::cout << "Secondo costruito" << std::endl; }  
  void funzione1(const Primo& primo) {
    std::cout << "Secondo::funzione1(): Primo passato per reference: x
= " << primo.getX() << std::endl;  
  }
  void funzione2(const Primo primo) {
    std::cout << "funzione2(): Primo passato per copia: x = " <<
primo.getX() << std::endl;  
  }
  void funzione3(const Primo *primo) {
    std::cout << "Secondo::funzione3(): Primo passato come puntatore:
x = " << primo->getX() << std::endl;  
  }  
};
int main()
{
    Primo p(5);
    Secondo s;    
 
    std::cout << "------" << std::endl;
    s.funzione1(p);
    std::cout << "------" << std::endl;
    s.funzione2(p);
    std::cout << "------" << std::endl;
    s.funzione3(&p);
 
    return EXIT_SUCCESS;
}
</CODE>
ha il seguente output:
Primo costruito: x = 5
Secondo costruito
------
Secondo::funzione1(): Primo passato per reference: x = 5
------
Primo costruito per copia: x = 5
funzione2(): Primo passato per copia: x = 5
------
Secondo::funzione3(): Primo passato come puntatore: x = 5


Grazie mille per l'esaustività.
Ho gia padronanza delle varie modalità di passaggio
di parametri a funzione "sulla carta", ma non avevo
idea di cosa fosse possibile fare in C++ e cosa no.
Ora è tutto piu chiaro,
ciao.
Blob



 void Secondo::tuaFunzione(Primo primo);
A rischio di confondere l'OP: queste due dichiarazioni sono
equivalenti. Trattandosi di passaggio per copia la qualifica const non
ha significato.
Ciao,
Nicola


Beh, significa che il corpo della funzione non modifica mai la copia del 
parametro. Può avere una certa rilevanza. Ad esempio la dichiarazione
void funzione(const T x)
   può essere convertita in
void funzione (const T &x)
   con la sicurezza che effettivamente x non viene modificato nel corpo 
della funzione.
E.


Dici? Prova a compilare questo esempio:
int f(int const i);
int f(int i) { return i; }
int main() { return f(0); }
Ciao,
Nicola

 ha significato.
In che senso? Il const non dovrebbe dichiarare la volontà di non fare
modifiche sulla copia locale?
D'altronde non mi sembra siano *equivalenti*.
Se scrivo:
<CODE>
class A {
  int m_value;
public:
  int getValue() const { return m_value; }
  void setValue(int value) { m_value = value; }
};
void funz1(const A a) {
     a.setValue(3);  // <-------- errore in compilazione:
     // passing `const A' as `this' argument of `void
A::setValue(int)' discards qualifiers
}
void funz2(A a) {
     a.setValue(3);
}
int main()
{
    A a;
    funz1(a);
    funz2(a);
}
</CODE>
Che ho sbagliato? :-)

 Che ho sbagliato? :-)
Ti e' piu' chiaro? ;-)
Ciao,
Nicola

 int f(int i) { return i; }
Certo, all'esterno le due funzioni sono identiche e quindi hanno lo 
stesso prototipo. Ma prova a compilare questa:
int f(const int i) {
   return --i;
}
e ti accorgi che mettere il const cambia qualcosa.
E.

 riferisce ad un implicito parametro che e' un puntatore.
Forse c'è un fraintendimento di fondo.  Non stavo parlando di questo
(il this non c'entra nulla e la presenza del metodo getX()
nell'esempio, è solo incidentale).

 > > void Secondo::tuaFunzione(Primo primo);
In questo caso non c'e' differenza di qualifica a livello di
dichiarazione della funzione membro, mentre c'e' una differenza
*apparente* nella dichiarazione del parametro. Trattandosi della
qualifica di livello piu' alto (top level const qualification) il
compilatore la ignora.
Le due dichiarazioni dichiarano la stessa funzione membro. L'effetto
e' che potrai scrivere solo una delle due definizioni,
indifferentemente, anche se effettivamente a livello di definizione il
significato cambia eccome.
Ciao,
Nicola

 > > > void Secondo::tuaFunzione(Primo primo);
Ok, allora mi sono sbagliato io.  Il punto e virgola non ci voleva,
quello che volevo scrivere è:
void Secondo::tuaFunzione(const Primo primo) {
   // ...... tuo codice
}
void Secondo::tuaFunzione(Primo primo) {
   // ...... tuo codice
}