déduction de type qui cause un segfault

Version imprimable

Bonjour.

Je suis en train d'écrire une petite lib C++ qui manipule indifféremment des std::string, des std::wstring et plus généralement n’importe quel std::basic_string<CharT>.
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 30 31 32 33 34 35 36 37 38 39 40 41 42 43 #include <string> #include <sstream> #include <iostream> #include <utility> template<class CharT> class Text { public: typedef std::basic_string<CharT> String; Text(const String& str) { std::cout << "Text()\n"; append(str); } ~Text() { std::cout << "~Text()\n"; } Text(const Text&) = delete; Text(Text && other) { std::cout << "Text(&&)\n"; std::move(other.oss); } Text& append(const String& str) { std::cout << "append()\n"; oss << str; return (*this); } String get() const { std::cout << "get()\n"; return oss.str(); } private: std::basic_ostringstream<CharT> oss; }; template<class CharT> Text<CharT>&& createText(const std::basic_string<CharT>& str) { std::cout << "createText()\n"; return std::move(Text<CharT>(str)); }
J'ai la fonction createText() pour déduire automatiquement le type de string et éviter à l'utilisateur d'avoir à l'écrire.
Code:

1 2 3 4 5 int main(int, char **) { std::string str = "Hello"; auto t = createText(str); std::cout << t.append(" World").get() << std::endl; }
Avec ce main, il n'y a pas de problèmes.
Code:

1 2 3 4 int main(int, char **) { std::string str = "Hello"; std::cout << createText(str).append(" World").get() << std::endl; }
Alors que celui-ci provoque un segfault, il semblerai que l'objet Text retourné par createText() soit détruit juste après qu'il ait été créé.

Citation:

createText()
Text()
append()
~Text()
append()
get()
Erreur de segmentation (core dumped)

Et je n'arrive pas à expliquer pourquoi, est-ce que c'est du à l'utilisation de la sémantique de mouvement ?
Est-ce qu'il y a moyen de rendre la deuxième syntaxe utilisable ?
Par ailleurs, est-ce qu'il est possible que le code s'adapte entre cout et wcout automatiquement ?

Cordialement.

27/04/2015, 08h23
stendhal666

Oui, c'est bien dû à la sémantique de mouvement.
La règle, c'est qu'il ne faut pas appliquer std::move pour retourner un objet local non statique.
En effet:
- de toute façon, l'optimisation est automatique si l'objet en question a un constructeur de mouvement (cf NRVO)
- les références à des rvalues restent des références; comme l'objet est détruit à la sortie de la fonction, la référence est à un objet détruit -> d'où le segfault.
27/04/2015, 09h05
Daïmanu

Ah, j'ignorai que le déplacement de variable locale était automatique, c'est pour ça que je suis parti directement sur du move.
En effet, en enlevant la rvalue reference ça marche mieux.

Il reste le problème d'adapter std::(w)cout en fonction du paramètre template CharT. Est-ce que c'est possible ?

Cordialement.

Salut,

Tu peux utiliser std::enable_if pour activer une méthode en fonction de tel ou tel paramètre/type de données:

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
#include <string>
#include <sstream>
#include <iostream>
#include <utility>
 
template<typename CharT>
class Text {
	public:
		typedef std::basic_string<CharT> String;
 
		Text(const String& str) {
			std::cout << "Text()\n";
			append(str);
		}
		~Text() {
			std::cout << "~Text()\n";
		}
		Text(const Text&) = delete;
		Text(Text && other) {
			std::cout << "Text(&&)\n";
			std::move(other.oss);
		}
 
		Text& append(const String& str) {
			std::cout << "append()\n";
			oss << str;
			return (*this);
		}
 
		String get() const {
			std::cout << "get()\n";
			return oss.str();
		}
 
    template<typename Char=CharT>
    //Méthode utilisée seulement si CharT == wchar_t
    typename std::enable_if<std::is_same<Char, wchar_t>::value, void>::type
    print() const {
         std::wcout << oss.str();
    }
 
    template<typename Char=CharT>
    //Méthode utilisée seulement si CharT == char_t
    typename std::enable_if<std::is_same<Char, char>::value, void>::type
    print() const {
         std::cout << oss.str();
    }
 
    template<typename Char=CharT>
    //Méthode utilisée seulement si CharT != wchar_t && CharT != char_t (en gros la méthode par défaut)
    typename std::enable_if<!(std::is_same<Char, wchar_t>::value) &&
                            !(std::is_same<Char, char>::value), void>::type
    print() const {
         std::cout << oss.str();
    }
 
 
	private:
		std::basic_ostringstream<CharT> oss;
};
 
template<typename CharT>
Text<CharT> createText(const std::basic_string<CharT>& str) {
	std::cout << "createText()\n";
	return Text<CharT>(str);
}

Et tu l'utiliserais de cette façon:

Code:

1
2
3
4
5
6
7
8
9
10
int main(int, char **) {
	std::string str = "Hello";
	std::string world = " World\n";
  createText(str).append(world).print();
 
	std::wstring wstr(str.begin(), str.end());
  std::wstring wWorld(world.begin(), world.end());
	createText(wstr).append(wWorld).print();
        std::cout << std::endl;
}

J'ai testé avec le compilateur clang et je pense qu'avec gcc ça fonctionnera aussi. Par contre aucune idée pour le compilateur de VS.

27/04/2015, 11h53
Daïmanu

Merci beaucoup, c'est précisément ce dont j'avais besoin.

J'ai juste remplacé print par un opérateur (), mais ça fonctionne avec gcc.

Cordialement.