Discussion :

[ram-0000]

Bonjour,

J'essaye de formatter un nombre sur 4 caractères et complété avec des 0 à droite

2 ==> "0002"

Le code que j'ai, c'est cela:

Code :

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

1
2
3
 
std::stringstream str;
str << std::setw(4) << std::setfill('0') << 2;

et cela marche très bien. Par contre, j'essaie de faire la même chose avec un string wide char

Code :

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

1
2
3
 
std::wstringstream str;
str << std::setw(4) << std::setfill('0') << 2;

Et là, je me fait jeter à la compilation à cause du setfill(). Qu'est ce que je fait mal et comment dois je m'y prendre ?

error C2679: '<<' binaire*: aucun opérateur trouvé qui accepte un opérande de partie droite de type 'std::_Fillobj<_Elem>' (ou il n'existe pas de conversion acceptable)

[Haze.]

Le problème est sur le setfill : les wstring utilisent des wchar_t alors que le caractère de remplissage utilisé est de type char.
Tu peux simplement utiliser le préfixe L pour indiquer que le littéral est un wchar_t :

Code :

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

1
2
3
 
std::wstringstream str;
str << std::setw(4) << std::setfill(L'0') << 2;

[ram-0000]

Merci pour la réponse, c'est effectivement cela

Je viens de faire un petit test pour mesurer la différence de vitesse entre le std::streamstring C++ et le sprintf() C

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
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
67
68
69
70
71
72
73
74
 
#include <stdio.h>
#include <io.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <fstream>
#include <windows.h>
#include <iostream>
#include <sstream>
#include <iomanip>
 
DWORD _chrono = 0;
void _start_chrono(void)
{
	_chrono = GetTickCount();
}
 
void _display_chrono(const char * Message)
{
DWORD diff = GetTickCount() - _chrono;
	printf("%s : Elapsed time is %.2f s\n", Message, (double)diff / 1000);
}
 
void _test_write_string_stream(const unsigned long Nb1, const unsigned long Nb2)
{
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			std::wstringstream str;
			str
				<< std::setw(5) << std::setfill(L'0') << boucle1
				<< L", "
				<< std::setw(5) << std::setfill(L'0') << boucle2
				<< L"\n"
				;
		}
	}
}
 
void _test_write_sprintf(const unsigned long Nb1, const unsigned long Nb2)
{
	for(int boucle1 = 0; boucle1 != Nb1; boucle1++)
	{
		for(int boucle2 = 0; boucle2 != Nb2; boucle2++)
		{
			wchar_t buffer[1024];
			swprintf(buffer, sizeof(buffer) / sizeof(buffer[0]), L"%.5d, %.5d\n", boucle1, boucle2);
		}
	}
}
 
int main(int argc, char* argv[])
{
	int nb0 = 10;
	int nb1 = 1000;
	int nb2 = 1000;
 
	for(int boucle = 0; boucle != nb0; boucle++)
	{
		printf("\n", boucle);
		printf("Passe %d\n", boucle);
 
		_start_chrono();
		_test_write_sprintf(nb1, nb2);
		_display_chrono("write_sprintf");
 
		_start_chrono();
		_test_write_string_stream(nb1, nb2);
		_display_chrono("write_stringstream");
	}
 
	return 0;
}

Le programme est exécuté en mode release sur un Windows Xp pro SP3 Pentium IV double coeur à 2,8Ghz avec 512 Mo de RAM
Les résultats sont les suivants:

write_sprintf : 1.50, 1.50, 1.48, 1.50, 1.50, 1.50, 1.50, 1.50, 1.50, 1.50
write_stringstream : 7.36, 7.27, 7.33, 7.28, 7.26, 7.27, 7.27, 7.26, 7.27, 7.27

Il semble donc que l'usage du sprintf (solution du C) soit sur ma machine au moins 5 fois plus rapide que le stringstream (solution du C++)

[Arzar]

C'est un résultat connu.
En 2001 Herb Sutter obtenait une différence de x8 à x14 suivant les compilateurs.

La conclusion de son article linké plus haut reste toujours valable de nos jours il me semble. Utiliser par défaut les flux C++, sauf si le profiler révèle un goulet d'étranglement ou si le formatage est extrêmement complexe. Dans ce cas, pas de remord à utiliser snprintf.

[ram-0000]

Ben disons que je commence à découvrir le C++ et que pour l'instant, je n'avais pas fait le pas pour aller vers les stringstream. Je trouvais sprintf tellement plus "naturel" pour moi (j'ai débuté il y a très longtemps à une époque où l'on commencait à parler de compilateurs qui allait peut être implémenter le C++)

Ce que je viens de mesurer et lire (merci pour le lien) ne va pas m'encourager à persévérer sur cette voie.

[Sylvain Togni]

C'est quoi cette manie à toujours regarder les performances ? De nos jours les processeurs effectuent plusieurs milliards d'instructions par secondes, ce qui fait que dans 99% du code, les performances ne sont pas un problème.

Les problèmes de nos jours sont la sécurité, la robustesse, la maintenance, ... Et dans ces domaines la solution avec stringstream surpasse aisément la solution avec sprintf.

[JolyLoic]

La conclusion de son article linké plus haut reste toujours valable de nos jours il me semble.

A la dernière réunion ISO C++ à laquelle j'ai participé, certains (j'ai oublié qui, désolé) débattaient chaudement de ce sujet, et prétendaient que les mauvaises performances des flux n'étaient pas inéluctables, et résultaient en grande partie de mauvaises implémentations.

Quelques questions :
- Que se passe-t-il si tu sorts la création du flux de la boucle ?
- Que se passe-t-il si tu te débrouilles pour que le buffer à l'intérieur du flux soit assez grand dès le début ?