Structure et surcharge d'operateur

Version imprimable

Bonjours,
voila j'aimerais crée une sorte de variable la voici :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#include <cstring>
 
struct SChar
{
    char* data = "";
 
    void operator+=(const char* chr1) {
        strcat(data, chr1);
    }
};
 
using namespace std;
 
int main()
{
    SChar lite;
 
    lite += "yoplaux";
 
    return 0;
}

Mais a chaque fois que je lance le prog il crashe :(

08/07/2014, 02h19
Bousk

std::string
08/07/2014, 02h40
foetus

Bousk explique au moins sa faute évidente :mrgreen:

Documentation fonction strtcat

Citation:

Pointer to the destination array, which should contain a C string, and be large enough to contain the concatenated resulting string.

Bigmlb crois-tu que ta destination soit préparée pour copier ta chaîne de caractères?

:scarymov: ou :fessee:

À ne pas oublier: Prévoir un caractère de plus pour le '\0' final ;)

Pour finir, char* data = ""; me semble suspect: ton compilateur n'a-t-il pas crié très fort avec un warning? :koi: :koi:
08/07/2014, 10h07
ternel

Précisons qu'un littéral de chaine (tel que "truc") est normalement directement inclus dans le code, et jamais recopié.
Son adresse appartient au segment de code, qui n'est ni la pile, ni le tas, et ne peux pas être modifié.

"truc" est normalement un char const *.
Le compilateur devrait donc hurler à l'erreur de conversion.

L'emplacement de l'affectation est illégal sauf en C++11. (et encore, j'aurais tendance à ne pas l'utiliser dans ce cas précis)
08/07/2014, 10h15
Bigmlb
D'accord mais je ne comprend pas trop donc comment faire pour que sa fonctionne
et oui
Code:

1 2 char* data = "";
me dit un warning mais on peut en C++11 ^^
08/07/2014, 10h46
skeud

DAns ta méthode operator+= tu dois allouer ta chaine de caractère de manière à ce qu'elle puisse accepter la concaténation.

En algo:
Créer une chaine de la taille de str1+str2+1(pour le \0 à la fin).
Copier str1 dans ta nouvelle chaine.
Ajouter str2 dans ta nouvelle chaine.
Ajouter un \0 à la fin de la nouvelle chaine.

str1 étant la chaine que tu stock dans ta structure et str2 étant la chaine que tu veux rajouter.

Le plus simple, c'est de garder ça à nullptr plutôt que d'y affecter une chaîne littérale:

Code:

1
2
3
4
5
6
7
class SChar
{
	char* data;
public:
	SChar() : data(nullptr) {}
	char const *get() const { return (data != nullptr ? data : ""); }
};

Ensuite, il faut maintenir son propre buffer dans la chaîne:

Code:

1
2
3
4
5
6
7
8
9
10
11
class SChar
{
	char* data;
public:
	SChar() : data(nullptr) {}
	SChar(char const *s) : data(s!=nullptr ? new char[strlen(s)+1] : nullptr) {
		strcpy(data, s);
	}
	~SChar() { delete[] data; }
	char const *get() const { return (data != nullptr ? data : ""); }
};

Puis on passe en forme canonique pour gérer la copie et l'affectation (par copie-et-swap), et si C++11 le déplacement:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class SChar
{
	char* data;
public:
	//Constructeurs
	SChar() : data(nullptr) {}
	SChar(char const *s) : data(s!=nullptr ? new char[strlen(s)+1] : nullptr) {
		strcpy(data, s);
	}
	//Copie
	SChar(SChar const &src) : SChar(src.data) { }
	//Affectation (copy-and-swap naïf)
	// SChar& operator=( SChar const &src ) { SChar tmp(src); Swap(tmp); return *this; }
	//Affectation (copy-and-swap optimisé)
	SChar& operator=( SChar tmp ) { Swap(tmp); return *this; }
	//Déplacement
	SChar(SChar &&src) : SChar() { Swap(src); }
	void Swap(SChar &obj) { char* tmpData=obj.data; obj.data=data; data=tmpData; }
 
	~SChar() { delete[] data; }
	char const *get() const { return (data != nullptr ? data : ""); }
};

Puis on rajoute la concaténation, d'abord par fonction membre (l'opérateur appellera la fonction).

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class SChar
{
	char* data;
public:
	//Constructeurs/destructeur/swap, forme canonique
	SChar() : data(nullptr) {}
	SChar(char const *s) : data(s!=nullptr ? new char[strlen(s)+1] : nullptr) { strcpy(data, s); }
	SChar(SChar const &src) : SChar(src.data) { }
	SChar& operator=( SChar tmp ) { Swap(tmp); return *this; }
	SChar(SChar &&src) : SChar() { Swap(src); }
	void Swap(SChar &obj) { char* tmpData=obj.data; obj.data=data; data=tmpData; }
	~SChar() { delete[] data; }
 
	char const *get() const { return (data != nullptr ? data : ""); }
 
	static SChar concat(SChar const &left, SChar const &right) {
		if(left.data == nullptr && right.data == nullptr)
			return SChar();
		//Il faut allouer la somme des strlen(), +1 pour le caractère nul
		size_t leftLength = strlen(left.get());
		size_t rightLength = strlen(right.get());
		size_t totalLength = leftLength + rightLength;
		SChar ret;
		ret.data = new char[totalLength+1];
		strcpy(ret.data, left.get());
		strcpy(ret.data+leftLength, right.get());
		return ret;
	}
};

Puis, on ajoute l'opérateur. Et on le fait (ça, je l'ai appris récemment, avant je ne faisais pas ça) sur le même modèle que l'affectation: Le += n'ajoute pas à l'existant, il fait un + et il swappe, de la même manière que le copy-and-swap naîf:

Code:

1
2
3
4
5
6
7
SChar operator+(SChar const &left, SChar const &right) { return SChar::concat(left, right); }
 
SChar& operator+=(SChar const &right) {
	SChar tmp(*this + right);
	Swap(tmp);
	return *this;
}

08/07/2014, 11h21
Bigmlb

Merci,
Grace a vous sa marche maintenant :D
09/07/2014, 15h25
the Hound

Citation:

Envoyé par leternel

Précisons qu'un littéral de chaine (tel que "truc") est normalement directement inclus dans le code, et jamais recopié.
Son adresse appartient au segment de code, qui n'est ni la pile, ni le tas, et ne peux pas être modifié.

Je dirais plutôt dans le segment de données, genre dans .rodata ou .bss.