Séquences d'échappements, interprétation à l'exécution.

Version imprimable

13/02/2012, 19h58
minnesota

Séquences d'échappements, interprétation à l'exécution.

Salut,

Je voudrais savoir si vous connaissez une méthode élégante et rapide (peut être déjà incluse dans la SL), ou une option de compilation, qui permettrait d'interpréter dynamiquement n'importe quelles chaines de caractères comme le ferait le préprocesseur, je pense notamment aux séquences de saut de ligne "\n", de tabulation "\t" et consoeur sans que je code moi même une phase de remplacement de chaque séquence par le caractère correspondant à coup de str::replace ou quelque chose du genre.

Merci.
17/02/2012, 12h54
Médinoc

À ma connaissance, il n'y en a pas dans le standard.

En plus, les séquences d'échappement C/C++ sont mal pensées car elles ne sont pas un code déchiffrable: Une séquence d'échappement numérique ne peut pas être suivie d'un chiffre par exemple (car il sera considéré comme en faisant partie). Au moins en C# ils ont corrigé ça.
17/02/2012, 13h48
minnesota

Merci,

d'ailleurs moi même j'ai toujours trouvé le c++ très bancal.

Celà dit, est-ce que tu vois une autre piste pour faire cela très vite sans utiliser les regexpressions de Boost, en faisant les remplacements en une seule passe, ou dois-je en venir à une boucle et traiter chaque caractère séparément ?

Pour moi, la seule façon de le faire en une seule passe, c'est traiter chaque caractère séparément.

Le bon côté des choses, c'est qu'il doit être en plus possible de le faire en in-place.

Je verrais donc un truc du genre (pardonne le C):

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
char* unescape(char *dst, char const *src)
{
	int end = 0;
	size_t iDst = 0;
	for(size_t iSrc=0 ; src[iSrc]!='\0' && !end ; iSrc++)
	{
		if(src[iSrc] != '\\')
		{
			dst[iDst++] = src[iSrc];
			continue;
		}
 
		iSrc++;
		switch(src[iSrc])
		{
		case '\0': /*Peut-être signaler une erreur? Je ne sais pas.*/
			end = 1;
			break;
		case '\\': dst[iDst++] = '\\'; break;
		case 'r': dst[iDst++] = '\r'; break;
		case 'n': dst[iDst++] = '\n'; break;
		/*même chose pour \a, \b, etc.*/
		case '0':
			/*Un Boucle pour lire les chiffres en octal*/
			break;
		case 'x':
			/*Un Boucle pour lire les chiffres en hexa*/
			break;
		default:
			/*Erreur? On ignore? On copie juste?*/
		}
	}
 
	dst[iDst++] = '\0';
	return dst;
}

17/02/2012, 14h26
minnesota

Parfait. On va faire comme ça alors...

Merci pour tout Médinoc.
17/02/2012, 15h41
Médinoc

Une précision pour l'octal et l'hexa: Pense a rajouter des conditions de sortie sur \0, comme je l'ai fait pour la boucle principale.
18/02/2012, 01h20
minnesota

Bien vu Médinoc. Merci beaucoup pour ton intérêt. Comme j'ai pas encore commencé, parce que j'ai pas toutes les clefs en main, je sais pas si je serais tombé d'dans, mais tu fais bien de le rappeler. Très souvent, c'est les petites erreurs qui sont à l'origine des grands maux. Alors, c'est toujours ça de moins...

Encore merci... beaucoup