Newsgroup: it.comp.lang.c++
Titolo: 2 domande 2

Porgendovi 2 domande....
1)Qual'e' la signatura per overloadare l'operatore di pre e post
incremento?
2) L'atto di  modificare un operatore di una classe (mettiamo lo
operator= ) viene definito OVERLOADING  o  OVERRIDING?
Qual'e' la differenza?
Pace, gente.
~Guybrush~

 Qual'e' la differenza?
Per overload si intende la definizione di una funzione con lo stesso
nome di una gia' esistente, ma con segnatura differente; tra i valori di
ritorno puo' non esserci alcuna relazione. Per override si intende la
ridefinizione di una funzione membro virtuale in una sottoclasse, ovvero
la definizione di una funzione membro con la *stessa* segnatura della
corrispondente funzione nella superclasse e valore di ritorno uguale o
covariante (puntatore o reference a sottoclasse del valore ritornato
allo stesso modo dalla funzione originale).
Se la funzione della sottoclasse ha segnatura diversa da quella della
superclasse, quella della superclasse e' nascosta. Ad esempio:
struct X {};
struct Y : public X {};
struct A {
  virtual void f(int);		// 1
  virtual X * f(double);	// 2: overload di 1
};
struct B : public A {
  virtual void f(int);		// 3: override di 1
  virtual Y * f(double);	// 4: override di 2
};
struct C : public B {
  void f();			// 5: nasconde 1,2,3,4
};
Ciao,
Nicola

=:-|
Scusami ma credo di non aver capito...
Facciamo cosi. Io ti faccio 4 esempi.
Riusciresti a spiegarmi cosa sto facendo  (overriding o overloading)?
1)------------------------------------------
class A
{
  public:
       void F( );
};
class B:public A
{
 public:
      void F( );   //   Sto facendo overriding?
    [ se ci fosse  >  void F(int) < ? Cosa avrei fatto?]
};
2)-------------------------------------------
class pippo
{
  public:
        pippo operator+(pippo);   // Overriding o overloading? 
};
3)-----------------------------------------
class pluto:public pippo
{
 public:
      pluto operator+(pippo);   //  Over < cosa>?
};
4)-----------------------------------------
class figura
{
    public:
          virtual  figura F( )=0;
};
class triangolo:public figura
{
   public:
	double area() {return base*altezza/2};
   private:
                  double base,altezza;
};
Grazie
~Guybrush~

e aggiungo......
5)----------------------
class pippo
{
      pippo();   //sto facendo overriding?
      ~pippo();  //anche qui overriding?
};
Grazie
~Guybrush~

 };
No. Stai solo dichiarando costruttore e distruttore.
L'overriding avviene quando una classe ridefinisce un metodo virtuale di una
classe base. Non esiste overriding in una classe che non deriva da un'altra. Non
esiste overriding se non ci sono metodi virtuali.
L'overloading avviene quando ci sono, nello stesso scope, ovvero nella stessa
classe, piu' metodi con lo stesso nome.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 };
Anche triangolo e' astratta perche' non avendo fatto l'override di figura::F()
questa resta virtuale pura.
Non puoi instanziare neppure triangolo: sei obbligato a derivarla.


classe, piu' metodi con lo stesso nome.
OK...adesso la coltre di nebbia si sta diradando.
Manca soltanto l'ultimo tassello alla mia "griglia" mentale.
Cosa significa dichiarare un metodo "VIRTUAL"?
Per ora un mega GRAZIE ...!!!
Sai, al mio corso di fondamenti di informatica 2,  il professore mi ha
veramente impicciato le idee.
~Guybrush~

Dichiarare una funzione membro "virtual" e' il modo di attivare il
meccanismo denominato overriding. Se tu hai una gerarchia come la
seguente:
class A {
  public:
    virtual int f() { return 5; }
    int g() { return 4; }
};
class B : public A {
  public:
    virtual int f() { return 7; }
    int g() { return 8; }
};
Puoi associare ad un puntatore o un reference ad A anche oggetti di tipo
B, ad esempio:
B b;
A & ra = b;
A * pa = new B;
Quando chiami una funzione membro virtuale attraverso un puntatore o un
reference, viene chiamata la funzione dell'oggetto effettivamente
puntato, quindi
sia ra.f() che pa->f() restituiscono 7 . Questo non e' vero per funzioni
membro non dichiarate virtuali, ovvero ra.g() e pa->g() restituiscono
entrambe 4, anche se b.g() restituisce 8 .
E' piu' chiaro?
Ciao,
Nicola

>E' piu' chiaro?
Grazie Nicola,
  adesso la situazione e' piu' chiara.
Grazie
~Guybrush~

 Nicola
Oops, evidentemente nella fretta ti e' sfuggito qualcosa...
l'operatore post fisso deve tornare una copia dell'oggetto su cui si
applica, prima dell incremento.
Quindi C dovrebbe essere una cosa del genere :
 struct C {
     C & operator++()  { ++i; return *this; }
     C operator++(int) { C temp(*this); ++i; return temp; }
   private:
     int i;
 };
in generale, per evitare codice duplicato, gli operatori postfissi si
possono
implementare in termine di quelli prefissi in questo modo:
C operator++(int) { C temp(*this); operator++() ; return temp; }
saluti
Fabio
----------------------------------------------------------------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 4.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2442289

OVERLOADING!!!
si dice che hai esguio l'overriding quando hai riscritto una funziona, cosa
che capita quando si utilizza l'ereditarietą delle classi..