Newsgroup: it.comp.lang.c++
Titolo: Un costruttore che non vuol costruire :-)

Un errore nel secondo costruttore; qualcuno sa dirmi perché?
Ecco che mi dice bcc55: The constructor 'Complex::Complex(Complex)' is not
allowed.
<CODE>
class Complex
{
public:
   Complex(); { m_img=0; m_real=0;};
   Complex(Complex z); { m_real=z.real(); m_img=z.img();};
   Complex(double real, double img);{m_real=real; m_img=img;};
   virtual ~Complex(){};
   double  real(){return this->m_real;};
   double  img(){return this->m_img;};
pivate:
   double m_real;
   double m_img;
}
</CODE>
Ciao
Dario

    Complex(double real, double img);{m_real=real; m_img=img;};
Perche' per creare il parametro z di Complex::Complex(Complex z) dovrebbe
richiamare Complex::Complex(Complex z) e per creare il parametro ....
Prova con Complex::Complex(const Complex &z)
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

Ok adesso compila.
grazie
dario
"Andrea Ferro" <And...@UrkaDVD.it> ha scritto nel messaggio
news:96k35h$a6n$1...@serv1.iunet.it...


}
E ricordati il punto e virgola in fondo.
Il Ghenio
-----
James: Adesso so finalmente cosa provano i panni messi in lavatrice!
Jesse: Avremo bisogno di un candeggio!!
(Team Rocket)
-----

>Complex(const Complex &z) { m_real=z.real(); m_img=z.img();}
Questo vale anche per l'overloading degli operatori, vero?
<CODE>
Complex Complex::operator +(const Complex &z)
</CODE>
Ciao
Dario

 warning.
A cosa serve allora il puntatore this?
Ciao
Dario

sicuramente si tratta di cattiva programmazione.
Non e' sempre vero.
Nel caso di riferimento a puntatori a membri, per esempio, e'
obbligatorio specificare "this".
--
Andrea Laforgia (ICQ 87230455)
http://www.geocities.com/AndreaLaforgia
"ci sono tre tipi di persone nel mondo : quelli che
 sono bravi in matematica e quelli che non lo sono."

Questo vale anche per l'overloading degli operatori, vero?
A maggior ragione vale per l'overloading degli operatori, dove passare
oggetti per valore può portare a commettere errori gravi e
difficilmente individuabili.


 obbligatorio specificare "this".
Verissimo, e in altri casi l'uso esplicito di "this" e` comunque
opportuno (anche se non obbligatorio) per chiarire lo scope.
Confrontiamo ad esempio gli stili:
void AClass:setSeveral(int floop, int crasp, int plaik)
{
    this->floop = floop;
    this->crasp = crasp;
    this->plaik = plaik;
}
vs
void AClass:setSeveral(int Afloop, int Acrasp, int Aplaik)
{
    floop = Afloop;
    crasp = Acrasp;
    plaik = Aplaik;
}
Trovo molto piu` chiaro il primo stile; esso, ad esempio,
mi chiarisce *localmente*, senza bisogno di informazioni
contestuali, che la funzione sta settando tre membri di
questo oggetto.  Nel secondo caso, devo studiarmi chissa`
quanto altro codice per sapere se e quali fra floop, crasp
e plaik non siano invece piuttosto variabili globali.  A scopi
simili molti adottano convenzioni sui nomi (tipo quella
di chiamare m_floop, m_crasp, ..., i membri degli oggetti,
e g_floop, g_crasp, ..., le variabili globali), ma l'uso di
'this->' e` secondo me un'alternativa stilistica che risulta
spesso preferibile.
Altri esempi ancora (e qua torniamo sul 'necessario'...)
sono quelli relativi a template.
Alex -- MVP C++ di Brainbench

e g_floop, g_crasp, ..., le variabili globali)
<...>
Ciao Alex, ben tornato.
Volevo chiedere : queste notazioni sono formalizzate da qualche parte
? c'e' un documento che tratta questi stili ?
Ho notato che la convenzione adottata nel passaggio dei parametri (uso
Delphi e C++ Builder e spesso spulcio i sorgenti delle librerie) e'
quella di anteporre una "A" ai parametri delle procedure e funzioni.
Invece, per i membri delle classi, si usa sempre una "F".
Non riesco a capirne il significato.


 A cosa serve allora il puntatore this?
class C {
public:
    void foo();
};
void bar( C *pC );
void C::foo()
{
    // se vuoi chiamare bar non puoi fare a meno di usare this


questo oggetto.
E'vero, ma chi scrive il codice delle classi credo che dovrebbe sapere
i nomi che ha usato per i membri.


 sono quelli relativi a template.
E su questo non ci sono dubbi: per chi ne avesse Alex si riferisce alla
seguente situazione:
int f() { return 5; }
template <typename T> struct A { 
  int f() { return 6; } 
};
template <typename T> struct B : public A<T> {
  int g() {
    return f();
  }
};
In questo caso g() ritorna 5 e non 6, perche' la chiamata ad una
funzione che e' anche membro di una classe base dipendente dal parametro
del template e' risolta a favore della funzione esterna.
Ciao,
Nicola

 del template e' risolta a favore della funzione esterna.
Compilando con il BCC55 il seguente esempio mi stampa 6:
#include <iostream>
int f() { return 5; }
template <typename T> struct A { 
  int f() { return 6; } 
};
template <typename T> struct B : public A<T> {
  int g() {
    return f();
  }
};
int main()
{
    B < int > b;
    std::cout << b.g() << std::endl;
    return 0;
}
Come mai?
EMG

i nomi che ha usato per i membri.
Quando si scrive del codice bisogna dare ampio spazio alla
leggibilita'.  Il codice sorgente viene scritto per essere letto.
E' per questo che bisogna adottare uno stile chiaro e coerente.  Resta
il fatto che usare 'this', non solo in certi casi e' obbligatorio, ma
spesso (come il caso che cita Alex) e' anche consigliato. Quindi non
credo proprio si possa considerare "cattiva programmazione".


Dallo standard:
"If a base class is a dependent type, a member of that class cannot hide
a name declared within a template, or a name from the template’s
enclosing scopes. [Example:
struct A {
  struct B { /* ... */ };
  int a;
  int Y;
};
int a;
template<class T> struct Y : T {
  struct B { /* ... */ };
  B b; // The B defined in Y
  void f(int i) { a = i; } // ::a
  Y* p; // Y<T>
};
Y<A> ya;
The members A::B, A::a, and A::Y of the template argument A do not
affect the binding of names in Y<A>. ]
Nota in particolare come e' risolto il nome "a" all'interno di Y<T>::f()
.
Il fatto che qui la classe base sia il parametro del template, mentre
nel mio caso e' un template dipendente dal parametro non sposta le cose.
Ciao,
Nicola

Con ogni probabilita' e' un baco, che ho segnalato alla Borland.
Ciao,
Nicola

 Con ogni probabilita' e' un baco, che ho segnalato alla Borland.
Piu' che un baco e' una "non compliancy". Che vale, tra l'altro, anche per VC.
Ho verificato che vale anche VC7. Quindi ho postato la cosa a uno degli
sviluppatori di VC in MS.


 .
Sempre con il BCC55 questo esempio
#include <iostream>
struct A {
  struct B { /* ... */ };
  int a;
  int Y;
};
int a;
template<class T> struct Y : T {
  struct B { /* ... */ };
  B b; // The B defined in Y
  void f(int i) { a = i; } // ::a
  Y* p; // Y<T>
};
Y<A> ya;
int main()
{
    ya.f( 123 );
    std::cout << ya.a << std::endl;
    std::cout << a << std::endl;
    return 0;
}
stampa
123
0
E' quindi un bug del BCC55?
EMG

 Piu' che un baco e' una "non compliancy". Che vale, tra l'altro, anche per VC.
Dal momento che sulla scatola c'e' scritto C++, per me e' un baco. E
poi, non avro' mica speso 18 dollari per niente, no? :-)
Ciao,
Nicola