Discussion :

[catzy]

Bonjour ,

Il parait que pour concaténer deux chaines de caractères, il faut utiliser l'opérateur + :

Code :

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

1
2
3
4
5
6
7
8
9
#include <string>
#include <iostream>
 
using namespace std;
 
int main()
{
    cout << "Hello " + "world!" << endl;
}

Pourtant, il y a une erreur ligne 9 :

Code :

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

error: invalid operands of types 'const char [7]' and 'const char [7]' to binary 'operator+'|

Vous pouvez m'aider ?

PS : Je sais qu'on peut utiliser << avec cout, mais justement, je veux pouvoir les concaténer SANS utiliser cout...

[catzy]

Par contre, on peut les concaténer si 1 des 2 chaines est dans une variable :

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <string>
#include <iostream>
 
using namespace std;
 
int main()
{
    string world("world!");
    cout << "Hello " + world << endl;
}

[foetus]

Il parait que pour concaténer deux chaines de caractères, il faut utiliser l'opérateur +

Pour une explication plus détaillée : le C++ hérite du C : donc une chaîne de caractères, c'est un tableau de caractères. il y a 2 types - char (1 octet) ou wchar_t (soit 2 soit 4 octets).
Mais ces 2 types sont des P.O.D. (Plain Old Data) (<- lien en anglais) : en gros ce sont des morceaux de mémoire - et donc la concaténation automatique n'est pas possible

Mais en C++, on a une surcouche objet (qui permet de surcharger les opérateurs, et notamment l'opérateur +) et la bibliothèque standard stl qui apporte entre autres, la classe std::string.
Et effectivement, on peut concaténer 2 std::string parce que cette classe le permet.

Et un dernier point, il y a les conversions implicites qui viennent du C : lorsque tu codes

• "world!" -> c'est un [const] char*
• "Hello " + world -> la chaîne "Hello " est convertie en std::string. Mais il faut faire attention à la partie la plus à gauche, parce que, en théorie, les conversions se sont de gauche à droite.

[jo_link_noir]

Concernant le dernier point de foetus:

On peut faire hello + "World" avec hello un std::string.

On peut aussi faire hello + "World" + "!" car le compilateur va traduire cela en (hello + "World") + "!", donc une concaténation de std::string avec "!".

Mais on ne peut pas faire "Hello" + "World" + exclamation parce que dans "Hello" + "World" il n'y a pas de std::string.

[catzy]

Merci, donc j'ai qu'à faire comme ça :

Code :

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

1
2
3
4
5
6
7
8
9
#include <string>
#include <iostream>
 
using namespace std;
 
int main()
{
    cout << string("Hello ") + "world!" << endl;
}

Ou alors (ça fait plus joli) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
#include <string>
#include <iostream>
 
using namespace std;
 
int main()
{
    const string concat("");
 
    cout << concat + "Hello " + "world!" << endl;
}

Merci

[Bktero]

"Hello " + world -> la chaîne "Hello " est convertie en std::string. Mais il faut faire attention à la partie la plus à gauche, parce que, en théorie, les conversions se sont de gauche à droite.

Je ne pense pas que "Hello" soit convertie en std::string, je pense simplement que cette opération utilise l'opérateur qui va bien (*) pour ajouter les données pointées par par le const char* "Hello" à la std::string word
(*) voir https://en.cppreference.com/w/cpp/st...ng/operator%2B forme (2)

Merci, donc j'ai qu'à faire comme ça :

Tu n'as surtout qu'à faire ceci :

Code :

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

1
2
3
4
5
6
#include <iostream>
 
int main()
{
   std:: cout << "Hello ") << "world!" << std::endl;
}

[catzy]

Je ne pense pas que "Hello" soit convertie en std::string, je pense simplement que cette opération utiliser l'opérateur qui va bien (*) pour ajouter les données pointées par par le const char* "Hello" à la std::string word
(*) voir https://en.cppreference.com/w/cpp/st...ng/operator%2B forme (2)

Dsl, mais là, j'ai rien compris...

Tu n'as surtout qu'à faire ceci :

Code :

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

1
2
3
4
5
6
#include <iostream>
 
int main()
{
   std:: cout << "Hello ") << "world!" << std::endl;
}

J'ai utilisé cout pour pouvoir tester rapidement si ça marche, mais à la base, je voulais faire quelque chose dans le genre : (Et je voulais éviter de créer un flux ou un truc dans le genre juste pour pouvoir utiliser les chevrons ^^')

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <string>
 
using namespace std;
 
int main()
{
    string chaine = "Hello " + "world!";
 
    return 0;
}

[foetus]

Dsl, mais là, j'ai rien compris...

Là on touche à des chapitres plus complexes : la redéfinition d'un opérateur et la notion friend.

Et Bktero a raison , il y a un opérateur + friend qui prend à gauche une chaîne de caractères const char* et à droite une chaîne de caractères std::string.

template< class CharT, class Traits, class Alloc > basic_string<CharT,Traits,Alloc> operator+(const CharT* lhs, basic_string<CharT,Traits,Alloc>&& rhs ); -> donc pas de conversion implicite.

[catzy]

Là on touche à des chapitres plus complexes : la redéfinition d'un opérateur et la notion friend.

Bon bah je vais me contenter de la technique "plus jolie"

(Tout ça pour une concaténation quand même hein...)

Merci

[gl]

Sur un compilateur récent (supportant C++14) et en activant C++14, il est aussi possible d'utiliser des littéraux de type std::string :

Code :

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

1
2
3
4
5
6
7
 
#include <iostream>
 
int main()
{
   std:: cout << "Hello "s + "world!"s << std::endl;
}

[Bktero]

Dsl, mais là, j'ai rien compris...

Code :

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

1
2
3
4
template< class CharT, class Traits, class Alloc >
    basic_string<CharT,Traits,Alloc>
        operator+( const CharT* lhs,
                   const basic_string<CharT,Traits,Alloc>& rhs );

C'est vrai que ce n'est pas facile à lire pour un novice...

En gros, tu peux en déduire qu'il existe un opérateur comme ceci :

Code :

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

std::string operator+(const char* lhs, const std::string& rhs);

C'est lui est appelé quand tu fais :

Code :

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

std::string result = "Hello" + std::string("word");

lhs est "Hello", un const char* ; rhs est la chaîne temporaire créée avec std::string("word"). Stricto sensu, "Hello" n'est pas converti std::string.

gl a donné la meilleure solution à mon avis !

[catzy]

Sur un compilateur récent (supportant C++14) et en activant C++14, il est aussi possible d'utiliser des littéraux de type std::string :

Code :

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

1
2
3
4
5
6
7
 
#include <iostream>
 
int main()
{
   std:: cout << "Hello "s + "world!"s << std::endl;
}

En gros, tu peux en déduire qu'il existe un opérateur comme ceci :

Code :

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

std::string operator+(const char* lhs, const std::string& rhs);

C'est lui est appelé quand tu fais :

Code :

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

std::string result = "Hello" + std::string("word");

lhs est "Hello", un const char* ; rhs est la chaîne temporaire créée avec std::string("word"). Stricto sensu, "Hello" n'est pas converti std::string.

gl a donné la meilleure solution à mon avis !

Ah bah oui

Au final, le C++ c'est un peu plus compliqué que le js

Encore une fois merci pour les réponses