Discussion :

[Zeeraptor]

Bonjour tout le monde.

j'utilise Visual c++ 2008.
Je m'attaque sérieusement au pointeur et j'aurais aimé savoir si ce petit programme (qui fonctionne) ne crée pas de problème (fuite mémoire et autre):

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 <stdio.h>
#include <stdlib.h>
#include <string.h>[/B]
 
int main(int argc, char *argv[])
{	
	void* vp;
	char* cp;
	vp=(void*)malloc(sizeof(char*));
	vp="a333";
	printf("%s\n",vp);
	vp="a22";
	cp=(char*)vp;
	vp=NULL;
	free(vp);
	printf("%s\n",cp);
	cp="a1";
	printf("%s\n",cp);
	system("PAUSE");	
	return 0;
}

[CGi]

Oui, il y a une fuite mémoire !

Tu alloues de la mémoire et tu mets l'adresse de cette zone mémoire dans le pointeur vp. Là c'est bon !
Ensuite tu fait pointer ce pointeur sur une chaîne de caractère. Donc à ce moment là, tu perds l'adresse de la zone mémoire que tu y avais mis auparavant !

[Lintel-oo]

A première vue je dirais que si , même si je suis loin d'être un grand spécialiste du domaine

Code :

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

void* vp;

Pourquoi ne pas mettre char* ? Même si c'est correct je pense qu'il vaut mieux éviter des variables de type void* sauf dans des cas particuliers. Après je conçois tout à fait que tu souhaites t'entraîner

Code :

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

1
2
vp=(void*)malloc(sizeof(char*));
vp="a333";

Tu déclares allouer la taille d'un pointeur de char, c'est à dire sur beaucoup de machines 4 octets. Cependant cela ne sert à rien puisque tu déclares ensuite

Code :

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

vp="a333";

Donc il y a fuite de mémoire puisque tu ne libères pas ce que tu as alloué avant d'écrire vp="a333";

Il faut donc ici écrire :

Code :

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

vp=(void*)malloc(X*sizeof(char));

Avec X le nombre de caractères que tu souhaites mettre dans ta chaîne (ici 4 donc) et faire ensuite :

Code :

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

1
2
3
4
5
 
*vp = 'a';
*(vp+1) = '3';
*(vp+2) = '3';
*(vp+3) = '3';

Ou sinon tu déclares directement :

Code :

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

vp = "a333"

Ensuite :

Code :

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

1
2
3
 
vp=NULL;
free(vp);

Mettre à nul le pointeur ne sert à rien si tu libères ce pointeur après donc ici le

Code :

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

free(vp);

est totalement inutile. D'ailleurs si tu l'avais mis avant la mise à 0 du pointeur tu aurais eu une fuite de mémoire, car, lorsque tu déclares

Code :

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

cp=(char*)vp;

cela signifie que le pointeur cp va prendre la valeur du pointeur vp, donc si tu libères vp à cet instant, cp ne va pointer sur plus rien.
Donc "Heureusement" encore une fois que tu ais mis le pointeur vp à NULL avant de le libérer, sinon tu aurais eu une fuite

Enfin, tu as une dernière fuite de mémoire puisque tu n'appelle pas free() pour libérer le pointeur cp, anciennement vp, mais comme tu as mis vp à NULL tu dois libérer cp, sinon tu aurais eu le choix entre libérer l'un ou libérer l'autre mais pas les 2 ! Si tu as besoin d'autres explications n'hésite pas !

Edit : CGi dit plus ou moins la même chose en omettant toutefois la dernière fuite de mémoire (ou alors c'est moi qui me trompe )

Edit bis : je dirais que ce code est correct :

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(int argc, char *argv[])
{
void* vp;
char* cp;
vp=(void*)malloc(sizeof(char)*//ce que tu veux//); //ligne ici totalement inutile
free(vp); //inutile si ligne précédente absente
vp="a333";
printf("%s\n",vp);
vp="a22";
cp=(char*)vp;
printf("%s\n",cp);
free(cp); // ou free(vp) puis vp=NULL;
cp="a1";
printf("%s\n",cp);
//plus besoin de libérer cp ni de le mettre à NULL
system("PAUSE");	
return 0;
}

[CGi]

Voir commentaires dans code :

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
 
#include <stdio.h>
#include <stdlib.h>
//#include <string.h> // Pas utile ici
int main(void)
{
    void* vp;
    char* cp;
    vp = (void*)malloc(sizeof(char*)); // Transtypage pas necessaire et taille pas bonne.
    vp = "a333"; // ICI tu perds l'adresse de ton bloc mémoire
    printf("%s\n",(char*)vp); //Là tu peux mettre un transtypage
                                // pour éviter le warning
    vp="a22";
    cp=(char*)vp;
    vp=NULL;  // On met le pointeur à null
    free(vp); // après avoir libéré la mémoire.
    printf("%s\n",cp);
    cp="a1";
    printf("%s\n",cp);
    system("PAUSE"); // "Pause" spécifique à Windows
    return 0;
}

[Zeeraptor]

Merci les gars!

J'utilise void* car j'ai dans l'idée de créer un struct qui en contienne pour y stocker des int,char*,et float.je ferai des cast pour récuperer les valeurs.

Donc en gros,a chaque fois que je cherche a envoyer une chaine dans un pointeur qui a déja initialisé,il va pointer sur une nouvelle zone mémoire sans libérer la précédente?

Et ça,c'est correcte?

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
int main(int argc, char *argv[])
{	
	void* vp;
	vp="a333";
	printf("%s\n",(char*)vp);
	free(vp);
	vp="a22";
	printf("%s\n",(char*)vp);
	free(vp);
	system("PAUSE");	
	return 0;
}

[mitkl]

non, il n'y a rien à free

[Zeeraptor]

Ok.

Donc je crois que je vais utiliser la solution de Lintel-oo,je vais utiliser "vp=(void*)malloc(X*sizeof(char));".

Merci a tous!

[CGi]

CGi dit plus ou moins la même chose en omettant toutefois la dernière fuite de mémoire

Il n'y a qu'une seule fuite mémoire. Par contre dans ton code (Edit Bis) il y a un free de trop !

@Zeeraptor, si c'est copier une chaîne de caractères dans la zone mémoire que tu avais allouée que tu désirais faire, c'est strcpy ou strncpy qu'il faut utiliser.

Et pour l'allocation avec malloc, c'est un malloc un free.

[Zeeraptor]

Et ça c'est possible?

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void* str2void(char* str)
{	
	void* vp;
	vp=(void*)malloc(sizeof(char)*(strlen(str)+1));
	strcpy((char*)vp,str);
	return vp;
}
 
int main(int argc, char *argv[])
{	
	void* vp=str2void("go1");
	printf("%s",(char*)vp);
	free(vp);
	vp=NULL;
	vp=str2void("go2");
	printf("%s",(char*)vp);
	free(vp);
	vp=NULL;
	system("PAUSE");	
	return 0;
}

[CGi]

Ça me semble bon !

Le transtypage sur le retour de malloc n'est pas nécessaire.

[Zeeraptor]

Je peux donc faire ça:

Code :

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

vp=malloc(sizeof(char)*(strlen(str)+1));

[CGi]

Tout à fait !

[Zeeraptor]

Merci!

j'ai bien fait de m'inscrire au forum.

A plus peut être(pour les pointeurs de fonction).

[Lintel-oo]

@CGi :

Code :

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

il y a un free de trop !

Autant pour moi désolé pour cette erreur même si je vois que le sujet est résolu

[lilington]

Tout à fait !

Je souligne tout de meme que meme si le transtypage n'est pas neccessaire, il faut toutefois garder a l'esprit que si ton code passe par un copilateur C++ tu auras des problemes.
dans ton cas c'est du C et rien que du C donc ca va. mais dans mon cas je suis obliger de transtyper car mes collegues font du C++ et utilise mes fonctions ecrite en C et ca cale quand je ne le fais pas.

juste une info quoi

[Bktero]

Pour savoir si ton code a des fuites mémoire, le mieux est d'utiliser un débogueur mémoire. Sous Linux / Unix, on utilise généralement Valgrind. Sous Windows, tu peux utiliser Dr Memory. J'ai fait un post sur cet outil : http://www.developpez.net/forums/d12...ows-and-linux/

PS : pourquoi faire chaine = "toto"; après un malloc émet une fuite ? C'est parce que malloc est une allocation dynamique quand chaine = "toto"; est une allocation statique. Tu peux regarder ce thread et ce message à propos.

[Zeeraptor]

je vais donc transtypé.je compile en c++,parce que j'utile les surcharges et occasionellement les templates.

Donc: allocation statique->donnée constante->donnée non modifiable.

je commence a y voir plus clair sur le fonctionnement du compilateur.

Dr memory peut-ètre intéréssant pour corriger les fautes.Je m'en servirais certainement pour de gros programmes.

Encore merci les Gars!

[Bktero]

Si tu utilises des templates et des surcharges, alors tu codes en C++. Pourquoi ne pas utiliser les fonctions C++ new() et delete() dans ce cas ?

[CGi]

Mais dans mon cas je suis obliger de transtyper car mes collegues font du C++ et utilise mes fonctions ecrite en C et ca cale quand je ne le fais pas.
juste une info quoi

Oui en fesant des copier collé du code, mais si tu mets tes fonctions C
dans des fichiers séparées C ou des lib écrite en C, le C++ est tout à fait capable de s'interfacer avec.

[Zeeraptor]

Si tu utilises des templates et des surcharges, alors tu codes en C++. Pourquoi ne pas utiliser les fonctions C++ new() et delete() dans ce cas ?

Je préfere rester au maximum dans l'esprit C.J'utilise la surcharge parce ce que c'est bien pratique,et que c'est très simple a utiliser (je ne comprend pas pourquoi il ne l'intègre pas au C standard).Les templates peuvent être pratique aussi,mais la syntaxe est C++,dons j'évite de les utiliser.