Mini-string en C (Windows)

Version imprimable

08/01/2013, 21h47
nanosoft

Mini-string en C (Windows)

Bonjour,

J'envisage de réaliser un ensemble de structures et de fonctions pour gérer les chaînes de caractères un peu dans l'idée des objets C++
Je pense que cela pourrait me faire gagner au global sur le codage de certains projets. Je programme pour l'instant en C et exclusivement pour Windows (et je suis débutant).
Les fonctions de l'API Windows ont un type LPCTSTR, l’investissement serait vraiment intéressant si je pouvais créer des fonctions qui retournent ce type, par exemple :

Code:

LPCTSTR message=myStrcat(str1,str2);

C'est faisable ou juste impossible ?

Merci pour votre réponse et des idées ou des liens sur ce sujet.
09/01/2013, 11h28
phi1981

Sous l'api Windows, LPCTSTR désigne un "pointeur vers une chaine de caractères constante où chaque caractère est de type TCHAR".
En effet, rien ne t'empêche de définir une fonction myStrCat () qui alloue un buffer de TCHARs, y stocke la concaténation des deux chaines passées en paramètre, et retourne un pointeur vers ce buffer. Il faudra juste préciser dans la documentation de myStrCat() que l'appelant ne doit pas oublier de libérer le buffer en question en appelant une fonction désignée.
Qu'est-ce qui te bloque ?
09/01/2013, 22h13
nanosoft

Merci de me répondre, il n'y a rien qui me bloque vraiment :
J'essaie d'en apprendre le plus possible avant de me lancer dans des dev. plus conséquents.
Comme LPCTSTR désigne un pointeur vers une chaine de caractères constante, je craignais que l'on ne puisse pas faire une affectation comme pour une variable.
Est_ce que :

Code:

sizeof(LPCTSTR)

a un sens ?
C'est la taille du pointeur ou de la chaîne ?
Les allocations sont certainement le cœur du sujet et je suis encore peu expérimenté avec les allocations dynamiques.
10/01/2013, 08h45
phi1981

Citation:

Envoyé par nanosoft

Comme LPCTSTR désigne un pointeur vers une chaine de caractères constante, je craignais que l'on ne puisse pas faire une affectation comme pour une variable.

En fait, ce typedef est défini dans l'api windows un peu comme ça :
typedef const TCHAR* LPCTSTR;
Quand un qualifier "const" apparait AVANT l'étoile (*), cela signifie que les données POINTEES sont constantes, pas le pointeur lui même.
On a le droit de modifier le pointeur (le faire pointer vers autre chose), mais on a pas le droit de modifier la chaîne pointée par ce pointeur.

Tu as le droit d'allouer un buffer, y copier des données, et retourner un pointeur CONST vers ce buffer : cela signifie à l'appelant "je te donne accès en lecture seule à une chaîne de caractères".

Citation:

Envoyé par nanosoft

Est_ce que :

Code:

sizeof(LPCTSTR)

a un sens ?
C'est la taille du pointeur ou de la chaîne ?

C'est la taille du pointeur (4 sous Windows 32 bits).
Pour obtenir la taille de la chaine, il faut la parcourir jusqu'à obtenir un 0, c'est le principe des chaînes en C.
10/01/2013, 09h02
phi1981
Citation:

Les fonctions de l'API Windows ont un type LPCTSTR ...

Je viens juste de relire ton message original, et je pense qu'il y a une petite confusion :
Une fonction Win32 dans ce genre :
Code:

1 2 BOOL WINAPI CopyFile(LPCTSTR lpExistingFileName, LPCTSTR lpNewFileName, BOOL bFailIfExists);
prend deux paramètres de type "pointeur vers une chaînes de caractères constante". Mais cela signifie surtout "Moi, fonction CopyFile(), je te promets juré craché que je ne vais pas modifier les chaînes de caractères que tu me passes en paramètre, je vais juste les lire pour savoir quel fichier je dois copier".
Cela ne veut pas dire que toi, appelant de cette fonction, tu doives manipuler des pointeurs vers des constantes. Tu PEUX le faire, mais tu n'y es pas obligé. Tu peux très bien lui passer un pointeur vers une chaine modifiable, c'est juste que le prototype de CopyFile() te promets qu'il ne va pas la modifier.
10/01/2013, 22h14
nanosoft
OK,
Si j'ai ce code :
Code:

1 2 3 LPCTSTR message1; // ... message1="OK";
c'est le compilateur qui alloue la taille ?
est-ce que ensuite dans le programme, je peux avoir une fonction :

Code:

message1=maFonction();

?
11/01/2013, 08h18
phi1981
Citation:
Envoyé par nanosoft

OK,
Si j'ai ce code :

Code:

1 2 3 LPCTSTR message1; // ... message1="OK";

c'est le compilateur qui alloue la taille ?
Oui, enfin précisément les trois caractères qui composent le "OK" (y a aussi un 0 à la fin) sont stockés dans la partie data de l'executable, donc on parle pas vraiment d'allocation (je simplifie un peu, mais l'idée est là).

Citation:

Envoyé par nanosoft

est-ce que ensuite dans le programme, je peux avoir une fonction :

Code:

message1=maFonction();

?

Oui bien sûr, tu fais alors pointer ton pointeur vers une autre chaîne de caractères.

Bonjour,
Pour travailler facilement avec des TCHAR (ou _TCHAR), tu dois utiliser les fonctions de <tchar.h> (ou d'autres fonctions données par Windows).
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <string.h> #include <tchar.h> int _tmain(int argc, _TCHAR const * argv[]) { LPCTSTR message1 = _T("ok"); _TCHAR buf[10] = _T("Test "); _tcscat(buf, message1); _tprintf(_T("Résultat: %s\n"), buf); return 0; }

03/02/2013, 21h53
nanosoft
Merci pour ces infos Medinoc,

Quel est le type ou la structure correspondant à TCHAR ?

Avec le petit exemple ci-dessous je sais passer d'une chaine vers LPCTSTR.
Mais je n'ai pas encore réussi pour passer de LPCTSTR vers une chaîne, c'est forcement plus compliqué puisqu'il faut gérer la longueur de la chaîne.
Je suis preneur d'un petit exemple sur le principe.
Code:

1 2 3 4 5 6 7 8 LPCTSTR saisie="OK"; char chaine[]=" Salut "; _tprintf(_T("saisie : %s \n "),saisie); // => OK saisie = chaine; _tprintf(_T("saisie : %s \n "),saisie); // => Salut
04/02/2013, 06h26
Médinoc

TCHAR
Les conversions sont une plaie, surtout en C. Tu te retrouves à bosser avec des #ifdef partout, ou autres joyeusetés...

En C++ on gagne un peu de répit avec des classes dédiées à la conversion et des surcharges de fonctions.
04/02/2013, 21h29
nanosoft
A la place des #ifdef, est-il possible de s'en sortir avec la taille ?
Code:

1 2 int taille=sizeof(TCHAR); printf("taille = %i \n",taille); // => 1
Si taille = 1, cela veut-il dire que TCHAR est un char ?

Si taille = 2 ou 4 ou autre ?
Comment faire ? y a t-il des "endians" à considérer ?

J'ignore si l'endianness change d'une version de Windows à une autre (quelle est l'endianness d'un ARM?), mais sous x86, c'est du little-endian; aussi, sous Windows un wchar_t fait deux octets.

Pas contre, je ne dois pas l'intérêt de bosser avec des if plutôt que des #ifdef et des macros.

Dans tous les cas, on peut au minimum faire des fonctions de conversion:

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
/*TestConvertStr.h*/
#pragma once
#include <wchar.h>
 
wchar_t * AllocA2W(char const *sczA);
char * AllocW2A(wchar_t const *sczW);
char * AllocA2A(char const *sczA);
wchar_t * AllocW2W(wchar_t const *sczW);
void FreeA(char *szA);
void FreeW(wchar_t *szW);
 
char * AbortIfNullA(char *szA);
wchar_t * AbortIfNullW(wchar_t *szW);
 
#ifdef _UNICODE
	#define AllocA2T AllocA2W
	#define AllocW2T AllocW2W
	#define AllocT2T AllocW2W
	#define AllocT2A AllocW2A
	#define AllocT2W AllocW2W
	#define FreeT FreeW
	#define AbortIfNullT AbortIfNullW
#else
	#define AllocA2T AllocA2A
	#define AllocW2T AllocW2A
	#define AllocT2T AllocA2A
	#define AllocT2A AllocA2A
	#define AllocT2W AllocA2W
	#define FreeT FreeA
	#define AbortIfNullT AbortIfNullA
#endif

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
67
68
69
70
71
72
/*TestConvertStr.c*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdlib.h>
#include <string.h>
#include <wchar.h>
#include <stdio.h>
 
#include "TestConvertStr.h"
 
wchar_t * AllocA2W(char const *sczA)
{
	size_t const cchLenA = strlen(sczA);
	size_t const cchLenW = mbstowcs(NULL, sczA, cchLenA+1);
	wchar_t * szW = calloc(cchLenW+1, sizeof *szW);
	if(szW!=NULL)
		mbstowcs(szW, sczA, cchLenA+1);
	return szW;
}
char * AllocW2A(wchar_t const *sczW)
{
	size_t const cchLenW = wcslen(sczW);
	size_t const cchLenA = wcstombs(NULL, sczW, cchLenW+1);
	char * szA = calloc(cchLenA+1, sizeof *szA);
	if(szA!=NULL)
		wcstombs(szA, sczW, cchLenW+1);
	return szA;
}
 
char * AllocA2A(char const *sczA)
{
	size_t const cchLenA = strlen(sczA);
	char * szA = calloc(cchLenA+1, sizeof *szA);
	if(szA!=NULL)
		strcpy(szA, sczA);
	return szA;
}
wchar_t * AllocW2W(wchar_t const *sczW)
{
	size_t const cchLenW = wcslen(sczW);
	wchar_t * szW = calloc(cchLenW+1, sizeof *szW);
	if(szW!=NULL)
		wcscpy(szW, sczW);
	return szW;
}
 
void FreeA(char *szA)
{
	free(szA);
}
void FreeW(wchar_t *szW)
{
	free(szW);
}
 
char * AbortIfNullA(char *szA)
{
	if(szA==NULL)
	{
		fputs("Echec d'allocation en conversion de chaine!\n", stderr);
		abort();
	}
	return szA;
}
wchar_t * AbortIfNullW(wchar_t *szW)
{
	if(szW==NULL)
	{
		fputs("Echec d'allocation en conversion de chaine!\n", stderr);
		abort();
	}
	return szW;
}

Ainsi, tu peux utiliser directement AllocT2A(s) ou AbortIfNullA(AllocT2A(s))...

05/02/2013, 22h17
nanosoft
Merci pour ces fonctions de conversion.
D'après ton message je comprend qu'elles sont pour Windows sous X86 ?

Plus je me documente sur ce sujet et plus je me pose des questions, je vais résumer mes acquis :

- LPCTSTR est un pointeur sur un tableau de TCHAR
- un TCHAR est soit un char soit un wchar_t

Je cherche à faire des conversions entre TCHAR et char donc dans un cas (qui semble être celui de ma configuration actuelle) il n'y a rien à faire.
Je devrais pouvoir écrire :
Code:

1 2 3 4 5 6 LPCTSTR saisie="OK"; char *chaine="KO"; // et saisie = chaine; // ou chaine = saisie;
Or, avec la ligne 6 j'ai un warning ?

Je pensais que wchar_t était nécessaire pour les accents et je viens de m'apercevoir que je peux mettre des accents dans une chaine de char ?
Un char est-il toujours un octet ?

Éventuellement aussi :
- qu'est ce que : #pragma once ?
- #define _CRT_SECURE_NO_WARNINGS ?
- qu'est ce qui conditionne _UNICODE ?

En tout cas merci d'avance pour ce petit cours en ligne ;)
05/02/2013, 23h35
Médinoc
Bonjour,
alors, tes réponses en vrac:
- C'est pour Windows, indépendamment de l'architecture, normalement.
- LPCTSTR, c'est un pointeur const de tableau de TCHAR (la version non-const, c'est LPTSTR).
- Attention, une chaine littérale de TCHAR doit être entourée d'une des macros suivantes: _TEXT(), _T (définies dans <tchar.h>, dépendant de _UNICODE) ou TEXT() (définie in incluant <windows.h>, dépendant de UNICODE).
- Si les macros UNICODE et _UNICODE ne sont pas définies (il faut définir soit les deux, soit aucune, sinon bonjour le bordel), TCHAR = char et c'est parfaitement interchangeable. Mais limité aux caractères de la page de codes courante (en France, les caractères latins avec la plupart des accents).
- Ton warning en ligne 6 est à cause de const vs. non-const.
- wchar_t c'est pour Unicode UCS-2 (anciennes versions de Windows), UTF-16 (Windows) et UCS-4/UTF-32 (*n*x). Mais char n'est le plus souvent pas limité à l'ASCII pur (ou à EBCDIC), il s'agit généralement d'un ASCII étendu:
  - Sous *n*x dans le monde "occidental", c'est généralement l'encodage ISO 8859-1 (Latin-1) ou ISO 8859-15 (Latin-9), quand ce n'est pas carrément de l'UTF-8
  - Sous Windows, ça dépend du type de programme: pour les applications fenêtrées c'est généralement la page de codes 1252 (alias "Windows-1252"); pour les applications console (et DOS) c'est CP437 aux USA, CP850 (alias "IBM-850") en France.
  Dans tous les cas, tu ne pourras pas saisir de caractères cyrilliques, arabes, japonais etc. dans un programme non-Unicode sans changer ta config de Windows.
- Un char, c'est toujours au moins 8 bits en C (mais ça peut être plus sur certaines plate-formes) et sizeof(char) est toujours égal à 1. C'est tout ce qui est garanti en C, mais quand on bosse en C sous Windows on considère que c'est toujours exactement 8 bits.
- #pragma once est un pragma reconnu par la plupart des compilos, qui remplace les #ifndef/#define/#endif pour empêcher qu'un header soit inclus plusieurs fois.
- Ce #define sert à dire au compilo de Visual Studio de ne pas m'emmerder à se plaindre que les fonctions standard de <string.h> sont "unsafe". Pour le code de ces fonctions, la portabilité (notamment avec l'autre compilo, MinGW) est plus importante à mes yeux.
- Sous un Visual Studio récent, il y a une option du projet qui définit automatiquement UNICODE et _UNICODE si on l'active; sinon, on les rajoute généralement en ligne de commande de compilation (pour MinGW: -DUNICODE -D_UNICODE)

Super :ccool:

Encore 2 questions (pour l'instant !):

- Est ce que le code ci-dessous est correct, en particulier maFonction (ou est-ce que l'on retourne ici un pointeur sur une variable locale) ?

- Qu'est ce qui fait concrètement sous Windows qu'un TCHAR pourrait être différent d'un char, est-ce uniquement lié à ma configuration de compilation (ou faut-il craindre des problèmes de portabilité) ?
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 LPCTSTR saisie=TEXT("OK"); const char *chaine="Chaîne hé hé !"; printf("chaine : %s \n",chaine); // => Chaîne hé hé ! int i=0; while (chaine[i]) { printf("car. : %c \n",chaine[i]);i++; } int taille=sizeof(chaine[3]); printf("taille char = %i \n",taille); // => 1 _tprintf(_T("saisie : %s \n "),saisie); // => OK saisie = chaine; _tprintf(_T("saisie : %s \n "),saisie); // => Chaîne hé hé ! saisie=TEXT("OK"); chaine = saisie; printf("chaine %s \n",chaine); // => OK taille=sizeof(TCHAR); printf("taille TCHAR = %i \n",taille); // => 1 LPCTSTR maFonction() { LPCTSTR local=TEXT("retour"); return local; } chaine=maFonction(); printf("chaine %s \n",chaine); // => retour

06/02/2013, 22h41
Médinoc
Les lignes 14, 19 et 30, et tout ce qui en dépend, ne marcheront que si UNICODE et _UNICODE ne sont pas définis.
Par contre, maFonction est OK, parce que "retour" (ou L"retour" si UNICODE est défini) est une chaîne littérale.

Addition: Si tu utilises des printf() (et surtout des _tprintf()), ces informations peuvent être utiles: Size and Distance Specification
Ce qu'il faut retenir:
- _tprintf(_T("%s"), str); affichera systématiquement des TCHARs.
- Le format %hs marche avec les trois versions pour afficher systématiquement des char.
- Le format %ws marche avec les trois versions pour afficher systématiquement des wchar_t.
- Il n'existe pas de format qui affiche systématiquement des TCHAR sur les trois versions; pour afficher des TCHAR, tu dois absolument utiliser _tprintf().

Bonjour,

J'ai réalisé des fonctions qui me retournent un LPCTSTR, voici un exemple :

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
 
LPCTSTR int2str(int nb)             // conversion int positif vers une chaîne
{
    //printf("%i \n",nb);           // nb entier à convertir
    char *temp = NULL;
    int dec = 1,car = 1;            // nombres de digits
 
    if (nb>9)                       // nombre de chiffres ?
    {
        int nbd = nb;
        while((nbd/10)>=1)
        {
            dec++;
            nbd=nbd/10;
        }
    }
 
    temp = malloc((1+dec)*sizeof(char));
    car = sprintf(temp,"%d",nb);
    //printf("car : %i \n",car);    // nombre de caractères
    //printf("%i \n",dec);          // nombre de chiffres
    LPCTSTR chiffre = temp;
    //free(temp);
    return chiffre;                 // chaîne du nombre
}

En première approche je voulais libérer temp avec la ligne 23, mais évidement il ne faut pas puisque il ne s'agit que d'une même et unique adresse.

Bref, d'après mes tests cela semble OK et je voudrais savoir si cette fonction est 100% sure : pas de souci de portabilité (autre machine 32/64 , version de Windows ...).

Merci pour votre avis et vos conseils :zoubi:

Ce n'est pas un vrai LPCTSTR, c'est un char* (LPSTR) casté en LPCTSTR.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <tchar.h>
 
LPTSTR int2str(int nb)             // conversion int positif vers une chaîne
{
    //printf("%i \n",nb);           // nb entier à convertir
    int dec = _sctprintf(_T("%d"), nb);            // nombres de digits
    TCHAR *buf = malloc((1+dec)*sizeof(TCHAR));
    int car = _stprintf(temp, _T("%d"), nb);
    //printf("car : %i \n",car);    // nombre de caractères
    //printf("%i \n",dec);          // nombre de chiffres
    return buf;                 // chaîne du nombre
}

Et ne pas oublier le free() après usage.

06/04/2013, 18h02
nanosoft
OK, merci pour la correction avec tchar.h

Mais :

Citation:

Ce n'est pas un vrai LPCTSTR, c'est un char* (LPSTR) casté en LPCTSTR.

Quel est l'inconvénient ou le risque ?
si je caste quand même avec LPCTSTR int2str(int nb)
(c'est le type attendu des fonctions API Windows que je veux utiliser)

et pour libérer , c'est comme cela ?
Code:

1 2 3 4 5 // ... // ... message=int2str(2013); // ... free(message);
06/04/2013, 19h23
Médinoc
Citation:

Envoyé par nanosoft

Quel est l'inconvénient ou le risque ?
si je caste quand même avec LPCTSTR int2str(int nb)
(c'est le type attendu des fonctions API Windows que je veux utiliser)

Très simple: D'une part dès que tu compileras en Unicode ça foirera, d'autre part tu ne pourras pas faire le free() sur le pointeur retourné sans faire un autre cast d'abord.
Citation:
et pour libérer , c'est comme cela ?

Code:

1 2 3 4 5 // ... // ... message=int2str(2013); // ... free(message);
Oui, parfaitement.

OK,

Apparemment LPTSTR est accepté sans problème si LPCTSTR est attendu.
Exact ?

Est-ce le cas aussi avec LPCWSTR (quelle est la nuance) ?

P.S. :
j'ai une "undefined reference" pour _sctprintf ??
avec :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 #include <stdlib.h> #include <stdio.h> #include <SDL\SDL.h> #include <windows.h> #include <time.h> #include <tchar.h> #include <dirent.h> #include <commctrl.h> #include <string.h> #include <FMOD/fmod.h> #include <SDL/SDL_ttf.h> #include <unistd.h> #include <SDL/SDL_getenv.h>

07/04/2013, 10h45
Médinoc
Ben oui c'est le principe, on peut copier un pointeur non-const vers un pointeur const, mais pas l'inverse:
- void* -> const void*
- LPSTR -> LPCSTR
- LPWSTR -> LPCWSTR
- LPTSTR -> LPCTSTR
Normalement, le linker ne devrait jamais voir "_sctprintf": Selon les options de compilation du projet, il devrait voir "_scprintf" ou "_scwprintf" (parce que _sctprintf est une macro.

Si ce n'est pas le cas, ça doit vouloir dire que tu utilises MinGW et son <tchar.h> est incomplet. Auquel cas, tu peux rajouter ceci dans ton fichier source:
Code:

1 2 3 4 5 6 7 #ifndef _sctprintf #ifdef _UNICODE #define _sctprintf _scwprintf #else #define _sctprintf _scprintf #endif #endif

Bonsoir,

Encore des questions sur ce sujet avec des structures :

En dehors de la ligne 28 , l'exemple de code ci-dessous est-il 100% correct ?

Sur la ligne 28, j'ai un doute , pouvez m'expliquer si cela est incorrect dans le main.

Je suppose alors qu'il faille faire une fonction telle la ligne 31.
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 typedef struct { char *chaine; // ... } Texte; Texte *createTexte(char *chaine) { Texte *TxtTmp; TxtTmp = malloc(sizeof(Texte)); TxtTmp->chaine = malloc(160*sizeof(char)); strcpy(TxtTmp->chaine,chaine); // ... return TxtTmp; } // Dans le main : // ... Texte *Txt1 = createTexte(" Texte1 "); Texte *Txt2 = createTexte(" Texte2 "); Txt1->chaine =" Texte1 modifié "; // prototype fonction : void modifTexte(Texte *TxtVar, char *chaine); modifTexte(Txt1, " Texte1 modifié ");
PS : en relisant avant de poster, je me demande aussi si il ne faut pas allouer les éléments (TxtTmp->chaine) avant la structure (TxtTmp) elle-même ?
L'ordre a t_il une importance ?

Et pour free (doit-on libérer obligatoirement tous les éléments avant la structure) ?

29/06/2013, 14h20
Franck.H
Citation:

Sur la ligne 28, j'ai un doute , pouvez m'expliquer si cela est incorrect dans le main.

Bin tu fait pointer ton pointeur vers une chaîne constante, ça risque à un moment de peut-être te poser des soucis. L'idéal c'est de faire une fonction comme par exemple strdup qui fait une copie de la chaîne constante passée en paramètre tout en allouant un espace assez grand pour la contenir sur le pointeur qui tu auras définit en avance.

J'ai un module très complet (qu'il faudrait que je mette à jour pour quelques optimisations) qui est fonctionnel: http://sourceforge.net/projects/cstr/, tu peux t'en inspirer si tu le souhaite ou même encore mieux, tu peux l'utiliser ;)

Citation:

en relisant avant de poster, je me demande aussi si il ne faut pas allouer les éléments (TxtTmp->chaine) avant la structure (TxtTmp) elle-même ?
L'ordre a t_il une importance ?

L'idéal c'est d'allouer ta structure puis ensuite ses membres lorsque cela est nécessaire. Par exemple pour ta chaîne, n'alloue l'espace que lorsque tu utilises une fonction qui va la remplir sauf si tu utilises un constructeur qui prend en paramètre une chaîne.

Citation:

Et pour free (doit-on libérer obligatoirement tous les éléments avant la structure) ?

Oui il faut en fait libérer les différents espaces mémoire dans le sens inverse de l'allocation donc par exemple :

Allocations :
- Txt1
- Txt1->chaine
Libérations :
- Txt1->chaine
- Txt1
Si tu libérerais ta structure avant ta chaîne, tu perdrais le pointeur pointant ta chaîne et donc tu as une fuite mémoire.
29/06/2013, 20h35
Médinoc

Pourquoi allouer 160*sizeof(char) quand tu peux allouer (strlen(chaine)+1) * sizeof *chaine ?

Aussi, tu devrais déclarer createTexte() en Texte *createTexte(const char *chaine) vu que la fonction ne modifie pas la chaîne passée en paramètre.
30/06/2013, 17h19
nanosoft

Bonjour,

Merci pour vos réponses :

Citation:

L'idéal c'est de faire une fonction comme par exemple strdup qui fait une copie de la chaîne constante passée en paramètre tout en allouant un espace assez grand pour la contenir sur le pointeur qui tu auras définit en avance.

OK, je n'avais encore jamais vu strdup , mais avec strcpy cela revient au même ? (vers un pointeur alloué et avec const char *chaine)
En l’occurrence le pointeur est celui de ma structure et je veux en modifier la chaine.

Citation:

Pourquoi allouer 160*sizeof(char) quand tu peux allouer (strlen(chaine)+1) * sizeof *chaine ?

Justement, lors de la création, j’alloue une taille maxi ainsi je peux (avec ma fonction modifTexte) remplacer la chaine initiale par une chaine plus longue.
L'idéal serait évidement de "désallouer" puis de ré-allouer à la bonne taille.

Mais, vous l'aurez compris, je suis encore en expérimentation. Notamment avec les structures :

Citation:

L'idéal c'est d'allouer ta structure puis ensuite ses membres lorsque cela est nécessaire.

Je trouve bizarre que l'on puisse réserver de la mémoire pour une structure alors qu'on ne connait pas la taille de ses membres.
Mais bon le C est tout sauf intuitif :mouarf:

Merci Franck pour le module, mais le source n'est pas donné ?

Citation:

Envoyé par nanosoft

OK, je n'avais encore jamais vu strdup , mais avec strcpy cela revient au même ? (vers un pointeur alloué et avec const char *chaine)
En l’occurrence le pointeur est celui de ma structure et je veux en modifier la chaine.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 char * strdup (const char * s_str) { char * s = NULL; if (s_str) { s = malloc (strlen (s_str) + 1); if (s) strcpy (s, s_str); } return s; }
Code:

ta_structure->ta_chaine = strdup ("une chaine");

Citation:

Envoyé par nanosoft

Je trouve bizarre que l'on puisse réserver de la mémoire pour une structure alors qu'on ne connait pas la taille de ses membres.
Mais bon le C est tout sauf intuitif :mouarf:

Disons que la taille de la chaîne on s’en fout car ce n'est qu'un pointeur qui pointera vers une autre zone de la mémoire lorsque l'allocation sera fait par la suite. Sinon la taille de la structure sera égale à la somme de la taille de ses membres, ça c'est suivant l'implémentation de l'OS sur lequel tu travailles mais dans la plupart des cas un pointeur vaut 4 octets si je ne me trompe pas, l'opérateur sizeof (ton_pointeur); devrait te donner le résultat correct.

Citation:

Envoyé par nanosoft

Merci Franck pour le module, mais le source n'est pas donné ?

Bin si il est livré, c'est une archive contenant tous les fichiers ici présent: http://sourceforge.net/p/cstr/code/4/tree/ mais bien entendu, il faut que je retravaille tout ca, ce code date un peu, j'était un peu moins expérimenté par rapport à maintenant :mouarf:

30/06/2013, 18h45
nanosoft
OK,

J'ai fait ma fonction :
Code:

1 2 3 4 5 6 void modifTexte(Texte *txt1, const char *chaine) { free(txt1->chaine); txt1->chaine = malloc((strlen(chaine)+1) * sizeof *chaine); strcpy(txt1->chaine,chaine); }
Cela à l'air de bien marcher est-ce qu'elle est propre ?

Y a t-il un moyen de connaître la taille allouée d'une chaîne ?
Car effectivement avec sizeof on a la taille du pointeur (4).
Et strlen ne donne que le nombre de caractère avant le '\0'

Comme ça c'est mieux:

Tester les arguments passés à la fonction
Tester la chaîne avant de la supprimer
Tester la chaîne avant d'essayer de la remplir
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void modifTexte(Texte *txt1, const char *chaine) { if (txt1 != NULL && chaine != NULL) { if (txt1->chaine != NULL) free(txt1->chaine); txt1->chaine = malloc(strlen(chaine)+1); if (txt1->chaine != NULL) strcpy(txt1->chaine,chaine); } }
Le * sizeof *chaine n'est pas nécessaire dans l'allocation car un char vaut 1 donc inutile d'alourdir le code si ce n'est pas nécessaire ;)

Citation:

Envoyé par nanosoft

Y a t-il un moyen de connaître la taille allouée d'une chaîne ?
Car effectivement avec sizeof on a la taille du pointeur (4).
Et strlen ne donne que le nombre de caractère avant le '\0'

Tu ne peux pas connaître la taille allouée à un moment donné, il faut que tu en garde une trace dans ton programme car il n'existe pas de moyen pour savoir quelle est la taille d'un espace pointé par pointeur. Sinon pour connaître la taille de l'espace pour ta chaîne au moment où tu fais l"allocation bin ce sera simplement strlen(chaine)+1 (rappel toi qu'un char vaut 1 octet donc le calcul est simple à faire ;))

30/06/2013, 19h38
nanosoft

Merci :ccool: