Discussion :

[maa]

Bonjour,

Je me suis récemment lancé dans l'apprentissage du C. J'ai une question dont la réponse est sans doute très simple, mais je ne l'ai pas encore trouvée..

voici le code que j'essaie d’exécuter:

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
 
#include <windows.h>
#include <stdio.h>
#include <tchar.h>
 
TCHAR* GetText(){
	TCHAR text[200];
	_tcscpy(text, "Hello world");
	return text;
}
 
int main(void)
{
	TCHAR text[200];
	_tcscpy(text, "Hello world");
	_tprintf("%s\n", text); // >output : Hello world
 
	_tprintf("%s\n", GetText()); // >output : ╝¹2
 
    return 0;
}

Pourquoi est-ce que j'obtiens :

Hello world
╝¹2

En d'autres termes, pourquoi est-ce que j'obtiens n'importe quoi quand j'essaie d'imprimer le texte retourné par la fonction GetText() ?

Merci d'avance pour vos éclaircissements.

max

[ternel]

Parce que tu retournes l'adresse d'une variable temporaire, qui a été détruite à la sortie du programme de la fonction. En l'occurence, l'adresse du premier élément de text

[maa]

Merci pour la réponse. Je pense que tu voulais dire "détruite à la sortie de la fonction". C'est vrai que le problème est résolu si j’écris:

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
TCHAR text[200];
 
TCHAR* GetText(){
	_tcscpy(text, "Hello world");
}
 
int main(void)
{
	TCHAR text2[200];
	_tcscpy(text2, "Hello world");
	_tprintf("%s\n", text2);
 
	GetText();
	_tprintf("%s\n", text);
 
    return 0;
}

Mais n'y a t-il y a pas moyen d'exploiter la valeur de retour d'une fonction? (que la valeur ne soit pas détruite)

[Médinoc]

Note: Les fonctions basées sur les TCHAR ne sont pas vraiment "l'apprentissage du C" (en fait, elles ne sont pas standard et sont spécifiques à Windows) mais ça reste un excellent réflexe pour le dev sous Windows.

Par contre, les chaînes littérales doivent elles aussi être déclarées comme étant des chaînes de TCHAR:

Code C :

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

1
2
3
	TCHAR text2[200];
	_tcscpy(text2, _T("Hello world"));
	_tprintf(_T("%s\n"), text2);

Sinon tu auras des erreurs de compilation quand tu basculeras l'option qui détermine sur quel type TCHAR est mappé.

Mais n'y a t-il y a pas moyen d'exploiter la valeur de retour d'une fonction? (que la valeur ne soit pas détruite)

Hélas, pour des chaînes alphanumériques, en C il n'y a pas de panacée (contrairement au C++): Tu dois soit passer un buffer à la fonction, soit gérer toi-même la destruction (auquel cas, oublier de le faire causera une "fuite de mémoire"):

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
TCHAR* GetText(){
	/*Note: Je vais bien détailler le calcul ici, pour montrer comment c'est calculé*/
	size_t lengthInTChars = _tcslen(_T("Hello world"));
	size_t sizeInTChars = lengthInTChars+1;
	size_t sizeInBytes = sizeInTChars * sizeof(TCHAR);
	TCHAR *text = malloc(sizeInBytes);
	_tcscpy(text, _T("Hello world"));
	return text;
}
 
int main(void)
{
	TCHAR * text = GetText();
	_tprintf(_T("%s\n"), text);
	free(text);
	return 0;
}

Note que dans le cas précis des "chaînes littérales", tu peux directement retourner la chaîne, vu qu'elle est stockée statiquement, comme les variables globales:

Code C :

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

1
2
3
4
5
6
7
8
9
10
11
12
TCHAR const * GetLitText()
{
	return _T("Hello world");
}
 
int main(void)
{
	TCHAR const * text = GetLitText();
	_tprintf(_T("%s\n"), text);
	/*pas de free() ici, vu que les chaînes littérales ne sont pas allouées dynamiquement*/
	return 0;
}

[maa]

Merci pour ta réponse très complète.

Si j'ai bien compris, TCHAR est mappé sur des types représentant des caractères encodés en ANSI, DBCS ou Unicode, sur Windows. Est-ce qu'il y a un équivalent sur Linux ? Est-ce que TCHAR peut être utilisé sur linux est mappé vers les types approprié pour la platforme ?

[Invité]

Bien le bonjour,

Si je ne dis pas d'ânerie, les wchar sont utilisé dans la norme.