Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur
comme
une fonction quelconque pour surcharger l'operateur = ?
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur
comme
une fonction quelconque pour surcharger l'operateur = ?
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur
comme
une fonction quelconque pour surcharger l'operateur = ?
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la maintenance.
De même, peut-on appeler le destructeur de sa classe pour vider une instance
?
pour le destructeur, oui, rien ne t'empeche de faire un delete this
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la maintenance.
De même, peut-on appeler le destructeur de sa classe pour vider une instance
?
pour le destructeur, oui, rien ne t'empeche de faire un delete this
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la maintenance.
De même, peut-on appeler le destructeur de sa classe pour vider une instance
?
pour le destructeur, oui, rien ne t'empeche de faire un delete this
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
Salut !
Par contre, on peut faire
String:String(const String& S)
{
Init(S);
}
const String& String::operator = (const String& S)
{
if(this!= &S)
Init(S);
return *this;
}
void Init(const String& S)
{
[initisalition]
}
Le seul cas où on ne peut pas transformer bêtement ta proposition en mon
code est lorsque le constructeur est écrit comme ca :
String::String(const String& S)
: member1(...), member2(...)
{
[initialisation]
}
Oh, je n'en suis pas encore là ! ;)
Salut !
Par contre, on peut faire
String:String(const String& S)
{
Init(S);
}
const String& String::operator = (const String& S)
{
if(this!= &S)
Init(S);
return *this;
}
void Init(const String& S)
{
[initisalition]
}
Le seul cas où on ne peut pas transformer bêtement ta proposition en mon
code est lorsque le constructeur est écrit comme ca :
String::String(const String& S)
: member1(...), member2(...)
{
[initialisation]
}
Oh, je n'en suis pas encore là ! ;)
Salut !
Par contre, on peut faire
String:String(const String& S)
{
Init(S);
}
const String& String::operator = (const String& S)
{
if(this!= &S)
Init(S);
return *this;
}
void Init(const String& S)
{
[initisalition]
}
Le seul cas où on ne peut pas transformer bêtement ta proposition en mon
code est lorsque le constructeur est écrit comme ca :
String::String(const String& S)
: member1(...), member2(...)
{
[initialisation]
}
Oh, je n'en suis pas encore là ! ;)
Salut !
Est-il
d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la maintenance.
Salut !
Est-il
d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la maintenance.
Salut !
Est-il
d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la maintenance.
"Vincent Lascaux" a écrit dans le message de
news:40980fd7$0$21081$Salut !
Par contre, on peut faire
String:String(const String& S)
{
Init(S);
}
const String& String::operator = (const String& S)
{
if(this!= &S)
Init(S);
return *this;
}
void Init(const String& S)
{
[initisalition]
}
Je n'avais pas pensé à faire ça, c'est pourtant bête comme chou !
Merci à toi, et aux autres, pour vos réponses.
"Vincent Lascaux" <nospam@nospam.org> a écrit dans le message de
news:40980fd7$0$21081$626a14ce@news.free.fr...
Salut !
Par contre, on peut faire
String:String(const String& S)
{
Init(S);
}
const String& String::operator = (const String& S)
{
if(this!= &S)
Init(S);
return *this;
}
void Init(const String& S)
{
[initisalition]
}
Je n'avais pas pensé à faire ça, c'est pourtant bête comme chou !
Merci à toi, et aux autres, pour vos réponses.
"Vincent Lascaux" a écrit dans le message de
news:40980fd7$0$21081$Salut !
Par contre, on peut faire
String:String(const String& S)
{
Init(S);
}
const String& String::operator = (const String& S)
{
if(this!= &S)
Init(S);
return *this;
}
void Init(const String& S)
{
[initisalition]
}
Je n'avais pas pensé à faire ça, c'est pourtant bête comme chou !
Merci à toi, et aux autres, pour vos réponses.
void Init(const String& S)
{
[initisalition]
}
À la réflexion, il faudrait plutôt écrire Init(this, S) : c'est bien
l'instance désignée par this et pas S, qu'on veut initialiser !
Ce qui ne change rien au fait que la méthode est bonne...
void Init(const String& S)
{
[initisalition]
}
À la réflexion, il faudrait plutôt écrire Init(this, S) : c'est bien
l'instance désignée par this et pas S, qu'on veut initialiser !
Ce qui ne change rien au fait que la méthode est bonne...
void Init(const String& S)
{
[initisalition]
}
À la réflexion, il faudrait plutôt écrire Init(this, S) : c'est bien
l'instance désignée par this et pas S, qu'on veut initialiser !
Ce qui ne change rien au fait que la méthode est bonne...
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la
maintenance. De même, peut-on appeler le destructeur de sa classe
pour vider une instance ?
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la
maintenance. De même, peut-on appeler le destructeur de sa classe
pour vider une instance ?
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur comme
une fonction quelconque pour surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la
maintenance. De même, peut-on appeler le destructeur de sa classe
pour vider une instance ?
Jean-Noël Mégoz wrote:Est-il
[ ] possible
[ ] normal
[ ] recommandé
[X] scandaleux
d'appeler un constructeur comme une fonction quelconque pour
surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la
maintenance.
Idée louable s'il en est.
La solution "canonique" en ce moment (et qui ne pose pas de problèmes
avec les exceptions) a l'air d'être :
String::swap(string &other) // throw()
{
std::swap(myInternalBuffer, other.myInternalBuffer);
std::swap(mySize, other.mySize);
}
String::String(String const &other)
{
// Implémentation
}
String &String::operator=(string const &other)
{
String temp(other);
swap(temp);
return *this;
}
Le problème est qu'il faut quand même écrire swap et le constructeur
de copie, mais souvent swap est très simple à écrire.
Jean-Noël Mégoz wrote:
Est-il
[ ] possible
[ ] normal
[ ] recommandé
[X] scandaleux
d'appeler un constructeur comme une fonction quelconque pour
surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la
maintenance.
Idée louable s'il en est.
La solution "canonique" en ce moment (et qui ne pose pas de problèmes
avec les exceptions) a l'air d'être :
String::swap(string &other) // throw()
{
std::swap(myInternalBuffer, other.myInternalBuffer);
std::swap(mySize, other.mySize);
}
String::String(String const &other)
{
// Implémentation
}
String &String::operator=(string const &other)
{
String temp(other);
swap(temp);
return *this;
}
Le problème est qu'il faut quand même écrire swap et le constructeur
de copie, mais souvent swap est très simple à écrire.
Jean-Noël Mégoz wrote:Est-il
[ ] possible
[ ] normal
[ ] recommandé
[X] scandaleux
d'appeler un constructeur comme une fonction quelconque pour
surcharger l'operateur = ?
Par exemple, sur une classe String :
String::String(const String& S) // copy constructor
{
[initialisation]
}
const String& String::operator=(const String& S)
{
if(this != &S) String(S);
return *this;
}
L'idée est de ne pas retaper le même code pour faciliter la
maintenance.
Idée louable s'il en est.
La solution "canonique" en ce moment (et qui ne pose pas de problèmes
avec les exceptions) a l'air d'être :
String::swap(string &other) // throw()
{
std::swap(myInternalBuffer, other.myInternalBuffer);
std::swap(mySize, other.mySize);
}
String::String(String const &other)
{
// Implémentation
}
String &String::operator=(string const &other)
{
String temp(other);
swap(temp);
return *this;
}
Le problème est qu'il faut quand même écrire swap et le constructeur
de copie, mais souvent swap est très simple à écrire.
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur
comme
une fonction quelconque pour surcharger l'operateur = ?
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur
comme
une fonction quelconque pour surcharger l'operateur = ?
Salut !
Est-il possible/normal/recommandé/scandaleux d'appeler un constructeur
comme
une fonction quelconque pour surcharger l'operateur = ?