Discussion :

[Bigmlb]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Bousk]

std::string

[foetus]

Bousk explique au moins sa faute évidente

Documentation fonction strtcat

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?

ou

À 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?

[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)

[Bigmlb]

D'accord mais je ne comprend pas trop donc comment faire pour que sa fonctionne
et oui

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
char* data = "";

me dit un warning mais on peut en C++11 ^^

[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.

[Médinoc]

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

Code C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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 C++ :

Sélectionner tout - Visualiser dans une fenêtre à part

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;
}

[Bigmlb]

Merci,
Grace a vous sa marche maintenant

[the Hound]

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.