Sujet Précédent Sujet Suivant

SOS déblocker pgm C (en gtk+)!!

Fermé
mumberea - Modifié par mumberea le 21/12/2011 à 09:11
matthoffman Messages postés 405 Date d'inscription lundi 24 mars 2008 Statut Membre Dernière intervention 22 janvier 2013 - 22 déc. 2011 à 09:38
Bonjour,

je ne sais pas pourquoi ce petit code ne trouve pas. La compilation s'exécute sans problème mais à l'exécution, Windows me sort un message d'erreur puis le processus s'arrête sur l'erreur Process terminated with status -1073741819 (0 minutes, 45 seconds)
. Il me semble que le problème soit lié à la gestion de la mémoire. Mais j'avoue que je ne vois pas où est le problème. En supprimant/remettant chaque instruction, histoire de trouver celle à problème, je constate que ce sont les instructions en gras (l'utilisation de conteneur).

#include<stdio.h>
#include<stdlib.h>
#include<gtk/gtk.h>

struct MainWindow
{
GtkWidget *pWindow;
GtkWidget *pEntry;
GtkWidget *pBouton;
GtkWidget *pVbox;
GtkWidget *pLabel1;
};
typedef struct MainWindow MainWindow;

int main(int argc, char **argv)
{
gtk_init(&argc,&argv);

MainWindow *fenetre;

fenetre->pWindow=gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fenetre->pWindow),"Copier-Coller");
gtk_container_set_border_width(GTK_CONTAINER(fenetre->pWindow),10);
gtk_window_set_default_size(GTK_WINDOW(fenetre->pWindow),500,300);
gtk_window_set_position(GTK_WINDOW(fenetre->pWindow),GTK_WIN_POS_CENTER);
g_signal_connect(G_OBJECT(fenetre->pWindow),"destroy",G_CALLBACK(gtk_main_quit),NULL);

fenetre->pVbox=gtk_vbox_new(TRUE,0);
gtk_container_add(GTK_CONTAINER(fenetre->pWindow),fenetre->pVbox);

// entry
fenetre->pEntry=gtk_entry_new();
gtk_container_add(GTK_CONTAINER(fenetre->pWindow),fenetre->pEntry);

gtk_widget_show_all(fenetre->pWindow);
gtk_main();
return EXIT_SUCCESS;
}


7 réponses

Réponse 1 / 7
matthoffman Messages postés 405 Date d'inscription lundi 24 mars 2008 Statut Membre Dernière intervention 22 janvier 2013 47
Modifié par matthoffman le 21/12/2011 à 09:30 
MainWindow *fenetre;   

fenetre->pWindow=gtk_window_new(GTK_WINDOW_TOPLEVEL);


Il n'y a pas un truc qui te choque ici ?

Un indice: 

MainWindow *fenetre = NULL; // Toujours initialiser ses pointeurs ;)  

fenetre->pWindow=gtk_window_new(GTK_WINDOW_TOPLEVEL);


Alors tu vois toujours pas ? :)
0
Réponse 2 / 7
mumberea
21 déc. 2011 à 10:46
as-tu au moins pris le temps de compiler et d'exécuter ce code?
je crois bien que non.

en initialisant ce pointeur : MainWindows *fenêtre=NULL, le compilateur m'envoi un message d'erreur.

Je sais bien qu'il faut toujours initialiser une variable avant de l'utiliser, mais là ca me donnais un message d'erreur. J'ai donc laisser pcq tout va bien sans initialisation. La preuve en est que en enlevant les instructions à problème (celle que j'ai écris en gras) l'interface apparaît sans message d'erreur et se ferme aussi sans problèmes.
ce qui confirme bien que le problème réside au niveau des instructions écrites en gras
0
Réponse 3 / 7
matthoffman Messages postés 405 Date d'inscription lundi 24 mars 2008 Statut Membre Dernière intervention 22 janvier 2013 47
21 déc. 2011 à 11:10
Incroyable !! Je suis la pour aider la personne et on m'envoie valser:

Ou est ce que je t'ai dit que je t'avais donne la solution ? Je t'ai donne un indice pour que tu trouves la solution par toi meme.

Donc je vais te repondre sur le meme ton:
"as-tu au moins pris le temps de lire tes cours et d'apprendre le C ?"
Je crois bien que non

Si tu avais appris a programmer correctement en C et non pas comme un porc, tu saurais qu'on ne dereference jamais un pointeur NULL.

Maintenant la encore je ne t'ai pas ecrit ta ligne de code qui corrigera parce que ta reponse ne me plait pas du tout, donc j'arrete de suivre ce topic.

Bon vent.
0
Réponse 4 / 7
mumberea
21 déc. 2011 à 14:27
milles excuse matthofffman pour tous ce que j'ai écris. Mon intension n'était pas telle.
Je dois avouer que je viens d'apprendre à peine le C, ce qui fais que j'accuse beaucoup de lacunes dans la notion de pointeur.

Mercis pour la lumière que tu m'a apporté.
C'est gentil!
0
matthoffman Messages postés 405 Date d'inscription lundi 24 mars 2008 Statut Membre Dernière intervention 22 janvier 2013 47
Modifié par matthoffman le 21/12/2011 à 15:35
Je ne sais pas si tu as resolu ton probleme du coup, le probleme est que tu utilises un pointeur qui n'est tu n'as pas alloue en memoire.

Lorsque tu declares un pointeur sans l'initialiser a NULL, ton pointeur va pointer n'importe ou dans ta memoire, donc ton pointeur ne sera pas vide mais il contiendra des trucs present a une adresse memoire au pif.
D'ou l'interet de toujours initialiser ses pointeurs a NULL, pour eviter ce genre de problemes. Au moins tu seras sur d'avoir un segfault si tu dereferences un pointeur NULL ;). C'est donc ca l'indice que je te donnais.


Pour en revenir a ton probleme, ce que tu fais c'est donc ceci:
- Tu declares un pointeur qui pointe au pif dans ta memoire, tu y fous des donnees ne sachant meme pas comment ces donnees sont stockees vu que tu ne sais pas vraiment quel espace tu utilises avec ton pointeur non initalise.
- Ensuite tu utilises ces donnees qui ont du se stocker n'importe comment du coup.
Ce qui mene a tes lignes en gras, puisque concretement c'est la que tu fais usage de ton pointeur. Donc oui tu ne te gourais pas le programme plante sur tes lignes en gras, mais le probleme est anterieur !

Donc enfin la reponse: 

MainWindow *fenetre = NULL; // Toujours initialiser ses pointeurs ;)       

fenetre = malloc(sizeof (struct MainWindow));     
fenetre->pWindow=gtk_window_new(GTK_WINDOW_TOPLEVEL);      

...     

free(fenetre);     
fenetre = NULL;   

return EXIT_SUCCESS;


Le malloc() va te permettre d'allouer une case en memoire de la bonne taille et bien formatee pour accueillir une variable du type MainWindow
Le free() est tres important !! Il permet de liberer la memoire, sinon la memoire que tu auras allouee pour ton pointeur ne seras plus accessible jusqu'au reboot de ta machine ... Ce qui est tres porc, surtout si tu manipules 36000 pointeurs, en gros en 2 secondes l'ordi fume parce que t'as plus de RAM qui peut etre accessible ^^.
Le fenetre = NULL; est juste une securite pour que tu t'apercoives de ton erreur si jamais tu veux le derefencer par la suite, et retomber dans ton erreur ou tu comprends pas ce qu'il se passe.


Je te conseille de lire ca si tu veux en savoir plus (notamment la partie initialisation d'un pointeur qui te paraitra peut etre plus claire que mon explication):
https://www.commentcamarche.net/contents/116-les-pointeurs-en-langage-c


Voila, je terminerais sur le fait que j'ai par principe de faire comprendre les choses aux gens que j'aide, je donne pas juste 2 lignes de code, "soit heureux avec ca, ca marche". Et puis 2 semaines plus tard tu reposteras ici ne comprenant pas ce qui se passe, alors que ton probleme etait similaire.
Voila pourquoi je voulais que tu t'apercoives toi meme de ton erreur.

PS: Eh oui j'ai quand meme repondu, je ne suis pas un jeune ptit con aigri ^^
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 7
mumberea
21 déc. 2011 à 16:52
mercis d'avoir éclairer ma lanterne en ce qui concerne l'allocation dynamique. Je connais cette théorie, mais je me suis toujours demander dans quelle cas il fallait allouer dynamiquement une adresse à une variable.
en revanche, il y a un autre problème, le prototype de la fonction malloc() est :
void* malloc(sizeof(typeVariable));
Le type de sortie étant un "pointeur sur n'importe quel type variable (notamment le type de ma variable).
Seulement voilà, il y a un message d'erreur disant exactement:
error: invalid conversion from 'void*' to 'MainWindow*'
je continue d'y réfléchir, si tu as un peu de temps, j'apprécierai que tu y jette un coup d'oeil!
0
matthoffman Messages postés 405 Date d'inscription lundi 24 mars 2008 Statut Membre Dernière intervention 22 janvier 2013 47
21 déc. 2011 à 17:00
Ok tu peux me dire quel compilateur (et sa version tu utilises ?), et aussi quelle est l'extension de ton fichier ?

Dans tous les cas tu peux faire un dynamic cast mais en general faut eviter donc j'attends ta reponse et si le pb ne vient pas du compilateur alors tu auras toujours une solution de secours au moins, ecrit ca: 

fenetre = (MainWindow *) malloc(sizeof (struct MainWindow));
0
Réponse 6 / 7
mumberea
22 déc. 2011 à 01:07
Bingo!!!
Il compile sans erreur et tourne à merveille!! Mercis pour tous le temps passé sur mon petit problème...Au faite, c'est quoi ce (MainWindow *) ? dans

fenetre = (MainWindow *) malloc(sizeof (struct MainWindow));
Comprend mon ignorance en C, je ne suis qu'un novice.
0
Réponse 7 / 7
matthoffman Messages postés 405 Date d'inscription lundi 24 mars 2008 Statut Membre Dernière intervention 22 janvier 2013 47
22 déc. 2011 à 09:38
Comme je l'ai dit dans mon post precedant c'est un dynamic cast (cast explicite), en gros tu indiques au compilateur que de toute facon le type que tu vas donner sera de type MainWindow*.

Mais comme je te l'ai dit precedemment, normalement il ne faut pas faire ca ! Encore moins pour un malloc(). Si le compilateur te sort une erreur c'est surement que tu utilises un compilateur C++.
Je te conseille donc de plutot utiliser un compilateur C.

Si tu preferes rester avec ton compilateur C++ alors tu peux laisser le dynamic cast, mais bon c'est moche !
0

Discussions similaires

c quoi GTK ???
samirz -
lys -

4 réponses
GTK ou SDL
bonzime -
bonzime -

2 réponses
[gtk+]
salafista -
salafista -

5 réponses
ecran 27p fox spirit quelqu'un connait ?
kokiri -
Whithe -

4 réponses
PGM sous Pascal ....
Hipou -
rafa -

2 réponses