C++

operator+= vs operator+

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : operator+= vs operator+

in_your_phion

bonjour,
j'aimerais savoir s'il y a une difference avec les operateur "+" et "+=" quand on additionne deux string par exemple ?

Code :

string a("aa" ); string b("bb" );
a = a+b;
a+=b;

?

est ce que l'un est plus rapide que l'autre ? y'a t'il une différence?
merci

ps:j'ai une autre question, pour le code suivant "friendly string operator" :

Code :

#include <iostream>
#include <string.h>
using namespace std;
class String{
public:
String();
String(const char *const);
String(const String & );
~String();
char & operator[](int offset);
char operator[](int offset) const;
String operator+(const String& );
friend String operator+(const String&, const String& );
void operator+=(const String& );
String & operator= (const String & );
int GetLen()const { return itsLen; }
const char * GetString() const { return itsString; }
private:
String (int);
char * itsString;
unsigned short itsLen;
};
String::String()
{
itsString = new char[1];
itsString[0] = '\0';
itsLen=0;
}
String::String(int len)
{
itsString = new char[len+1];
for (int i = 0; i<=len; i++)
itsString[i] = '\0';
itsLen=len;
}
String::String(const char * const cString)
{
itsLen = strlen(cString);
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen; i++)
itsString[i] = cString[i];
itsString[itsLen]='\0';
}
String::String (const String & rhs)
{
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = '\0';
}
String::~String ()
{
delete [] itsString;
itsLen = 0;
}
String& String::operator=(const String & rhs)
{
if (this == &rhs)
return *this;
delete [] itsString;
itsLen=rhs.GetLen();
itsString = new char[itsLen+1];
for (int i = 0; i<itsLen;i++)
itsString[i] = rhs[i];
itsString[itsLen] = '\0';
return *this;
}
char & String::operator[](int offset)
{
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
char String::operator[](int offset) const
{
if (offset > itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
String String::operator+(const String& rhs)
{
int totalLen = itsLen + rhs.GetLen();
String temp(totalLen);
int i, j;
for (i = 0; i<itsLen; i++)
temp[i] = itsString[i];
for (j = 0, i = itsLen; j<rhs.GetLen(); j++, i++)
temp[i] = rhs[j];
temp[totalLen]='\0';
return temp;
}
String operator+(const String& lhs, const String& rhs)
{
int totalLen = lhs.GetLen() + rhs.GetLen();
String temp(totalLen);
int i, j;
for (i = 0; i<lhs.GetLen(); i++)
temp[i] = lhs[i];
for (j = 0, i = lhs.GetLen(); j<rhs.GetLen(); j++, i++)
temp[i] = rhs[j];
temp[totalLen]='\0';
return temp;
}
int main()
{
String s1("String One " );
String s2("String Two " );
char *c1 = { "C-String One " } ;
String s3;
String s4;
String s5;
cout << "s1: " << s1.GetString() << endl;
cout << "s2: " << s2.GetString() << endl;
cout << "c1: " << c1 << endl;
s3 = s1 + s2;
cout << "s3: " << s3.GetString() << endl;
s4 = s1 + c1;
cout << "s4: " << s4.GetString() << endl;
s5 = c1 + s2;
cout << "s5: " << s5.GetString() << endl;
return 0;
}

Je ne comprend pas pourquoi s4 = s1 + c1; appel operator+ avec un seul argument, alors que s5 = c1 + s2; appelle celui avec deux argument, car dans les deux cas il y a une conversion implicite de char* en string.

merci...

Message cité 1 fois
Message édité par in_your_phion le 31-03-2011 à 14:27:48

Publicité

Joel F

Real men use unique_ptr

in_your_phion a écrit :

est ce que l'un est plus rapide que l'autre ? y'a t'il une différence?
merci

a += b evite une copie inutile.

in_your_phion a écrit :

s1 + c1 c'est string::operator+(char*)
c1 + s2 c'est operator+(char*,string)

En general les gens civilisés ecrivent operator+(X,Y) non friend en appelant +=

Code :

class Foo
{
public:
operator+=(Foo const& )
{
// some code
}
};
operator+(Foo const& a, Foo const& b )
{
Foo tmp(a);
tmp += b;
return tmp;
}

pas de friend, pas de copie

Message cité 2 fois

in_your_phion

hello,

merci! mais je ne comprend pas tout

Joel F a écrit :

a += b evite une copie inutile.

où est ce que la copie ce fait quand on fait a = a + b ?

car pour moi cela équivaut à a = a.operator+(b), donc juste des affectations

Joel F a écrit :

s1 + c1 c'est string::operator+(char*)
c1 + s2 c'est operator+(char*,string)

Code :

class Foo
{
public:
operator+=(Foo const& )
{
// some code
}
};
operator+(Foo const& a, Foo const& b )
{
Foo tmp(a);
tmp += b;
return tmp;
}

pas de friend, pas de copie

on n'est pas obligé de mettre de type de retour ?

haa... la il y a une copie ok! mais dans le cas où ce n'est pas friendly, il n'y a jamais de copie non ?

merci

in_your_phion

hello & up

Joel F a écrit :

a += b evite une copie inutile.

est ce que ça veut dire que pour a = a + b on a :
- creation d'un buffer temporaire a1, où l'on stoque a + b (addition)
- creation d'un second buffer temoraire a2 où l'on copie a+b (égal)

alors que pour a+=b, on a :
- creation d'un buffer temporaire a2, où l'on stoque a + b (addition et egal)

c'est ça ?

Joel F a écrit :

s1 + c1 c'est string::operator+(char*)
c1 + s2 c'est operator+(char*,string)

par contre la je comprend toujours pas ...

Message édité par in_your_phion le 01-04-2011 à 11:10:53

mr simon

Dans "a = a + b", il y a d'abord un appel a "string operator+(const string& )" qui retourne donc un nouvel objet. Ensuite il y a appel a l'operateur d'affectation (operator=) pour copier cet objet temporaire dans a.

Alors que "a += b", il y a un appel a operator+= qui se contente d'ajouter au buffer de a le contenu de b.

Enfin, dans s1 + c1, vu que s1 est avant c1, le compile appel string::operator+(char*) (et vice versa pour c1 + s2)

Message cité 1 fois

in_your_phion

mr simon a écrit :

Enfin, dans s1 + c1, vu que s1 est avant c1, le compile appel string::operator+(char*) (et vice versa pour c1 + s2)

hello,
merci pour ta réponse, je crois que j'ai compris pour le 1.

Par contre le 2. pour moi c'est :

s1 + c1, qui équivaut à s1.operator+( String(c1) ) ....ok là je comprend

c1 + s2 .... le je pige plus .... car pour moi ce serait donc c1 qui est convertit en String, donc ensuite, c'est juste c1.operator+(String& ) qui serait appelé, puisque que c1 est déjà une String et non plus une C-String ....

:cry:

help me ...

Message édité par in_your_phion le 04-04-2011 à 10:13:15

FORUM HardWare.fr

Programmation

C++

operator+= vs operator+

Sujets relatifs
friend operator	chainage d'appel surcharge operator
syntaxe : operator T&() const;	[Résolu]pb compilation operator ++
operator&	operator << (std::ostream& O, const A& a)
operator = et const	T_OBJECT_OPERATOR
Conflits avec les operator >> et <<	std::sort et operator d'affectation
Plus de sujets relatifs à : operator+= vs operator+

Page générée en 0.098 secondes