Journal Programmation C et GTK

Posté par  .
Étiquettes : aucune
0
26
mar.
2003
Bonjour, à tous.

C'est mon premier journal, alors je vais faire bref.

Je désire utiliser les librairies doublement chaînées de la Glib1.2. J'ai déclaré une structure "STRUCTURE", puis un pointeur "POINTEUR" du type de cette structure.
J'ai voulu ensuite allouer la mémoire nécessaire pour insérer mon 1er élément dans la liste en écrivant

POINTEUR = g_malloc(sizeof(STRUCTURE));

Le compilateur ( gcc2.96 ) me retourne qu'il ne peut pas affecter un pointeur void* avec une structure STRUCTURE*.

Au secours, je tourne en rond. Je ne voudrai pas être obligé de réécrire les routines de gestion d'une liste doublement chaînée.

Les programmeurs expérimentés, SVP, aidez-moi !
  • # Re: Programmation C et GTK

    Posté par  (site web personnel) . Évalué à 2.

    ca doit etre un truc du genre

    POINTEUR = (POINTEUR)g_malloc(sizeof(STRUCTURE));
    • [^] # Re: Programmation C et GTK

      Posté par  . Évalué à 1.

      j'essaie tout de suite.
    • [^] # Re: Programmation C et GTK

      Posté par  . Évalué à 2.

      Bon je résume. Pour allouer un emplacement mémoire il faut écrire :

      POINTEUR = (STRUCTURE *)g_malloc(sizeof(STRUCTURE));

      Et maintenant comme ca, ca fonctionne !

      Merci encore à tous. ( même si certains utilisent des languages pour programmer et plus pour se faire chier avec l'allocation mémoire :-) ).
      • [^] # Re: Programmation C et GTK

        Posté par  . Évalué à 2.

        Ceci est dû au fait que g_malloc renvoie un void*, car cette fonction peut être utilisée pour allouer l'espace mémoire pour n'importe quel type de variable. Il faut donc forcer le passage en STRUCTURE*, pour que le compilateur sache ce que tu veux faire.

        Maintenant, on aime ou on aime pas, on trouve ça idiot ou pas, ça n'est pas le problème, c'est juste que c'est la seule façon de faire.

        À propos de ceux qui utilisent des langages pour programmer et plus pour se faire chier avec l'allocation mémoire, je répondrais que je n'utilise plus de langages du tout, même pas pour programmer, et que ça me fait des vacances :-)
        • [^] # Re: Programmation C et GTK

          Posté par  . Évalué à 1.

          Merci pour ta réponse. Effectivement ca marche mieux comme ca. Quand au fait de ne plus utiliser de language du tout, tu a l'air d'avoir gardé au moins celui de l'écrit :-)
  • # Re: Programmation C et GTK

    Posté par  (site web personnel) . Évalué à 2.

    Tu définis ta structure :

    struct machin {
    ....
    };

    et pour allouer tu fais :
    struct machin *truc = g_malloc(sizeof *truc));

    tu peux aussi faire :
    struct machin *truc = g_new(struct machin, 1);
    (c'est une macro)
    • [^] # Re: Programmation C et GTK

      Posté par  . Évalué à 1.

      Ca ne fonctionne pas. Voila la phrase du gcc qui m'énerve depuis toute l'aprés-midi.

      " cannot convert 'void *' to 'STRUCTURE *' in assignment ".

      Par contre, la 1ère réponse à l'air de mieux lui convenir mais avec une petite variante :

      POINTEUR = ( STRUCTURE *)g_malloc(sizeof(STRUCTURE));

      Qu'en pensez-vous ?
      • [^] # Re: Programmation C et GTK

        Posté par  . Évalué à -1.

        Qu'en pensez-vous ?

        Que je suis content de ne plus avoir à me faire chier avec la choucroute mémoire maintenant que je programme avec des langages faits pour écrire des application et à ne pas perdre 95% du temps sur des conneries dont je me fout.
      • [^] # Re: Programmation C et GTK

        Posté par  (site web personnel) . Évalué à 2.

        Naon. Pas bon. g_malloc renvoie un void*, ie un pointeur générique, compatible avec n'importe quel pointeur. Ça ne sert à rien de caster la valeur de retour, juste à masquer le problème.

        Soit :
        - tu as oublié l'include de glib
        - tu as mal déclaré POINTEUR et STRUCTURE
        (et en C les structures sont déclarées avec le mot-clé struct, là je ne le vois pas).

        enfin bref, le pb n'est pas à cette ligne.
        • [^] # Re: Programmation C et GTK

          Posté par  . Évalué à 1.

          Non, non. Je n'ai pas voulu écrire toutes les lignes de code pour essayer de faire bref, mais j'ai bien déclaré la structure avec le mot cléf "struct". J'ai ensuite défini un pointeur du type de cette strucutre. La librairie glib est bien incluse ( # include <glib.h> ).

          La solution c'est qu'il faut donner la la forme de la structure à g_malloc. En écrivant POINTEUR = (STRUCTURE *)g_malloc(sizeof(STRUCTURE)); il n' y a plus d'erreur et j'accède bien, par la suite aux données enregistrées.
          • [^] # Re: Programmation C et GTK

            Posté par  (site web personnel) . Évalué à 1.

            je viens de comprendre : tu fais du C++, c'est ça ?
            • [^] # Re: Programmation C et GTK

              Posté par  (site web personnel) . Évalué à 1.

              Je vote pour une erreur de ce type (emploie de g++ au lieu de gcc).

              Ca fait des annees que je code du C ANSI dans une SSII, et ca fait aussi des annees que je supprime les cast sur malloc.

              En règle générale, l'emploi d'un cast est une mauvaise solution et doit rester une solution très exceptionnelle : il est plus souvent signe d'une mauvaise maîtrise du code, voire d'un simple oubli de l'include qui declare la fonction utilisee.

              Pour exemple :

              #include <stdlib.h>
              int main(int argc, char *argv[])
              {
              char *tutu;
              tutu = malloc(sizeof(char));
              }


              Compile sans erreur et sans warning avec la commande toute simple :
              gcc pointeur.c
          • [^] # Re: Programmation C et GTK

            Posté par  . Évalué à 4.

            > En écrivant POINTEUR = (STRUCTURE *)g_malloc(sizeof(STRUCTURE)); il n' y a plus d'erreur et j'accède bien, par la suite aux données enregistrées.

            Doit y avoir un problème. Tu n'aurais pas fait une connerie du type :
            char toto ;
            toto = g_malloc(10) ;

            Au-lieu de :
            char * toto ;
            toto = g_malloc(10) ;

            (void *), qui est retourné par g_malloc() indique que le type retourné est un pointeur sur l'importe quoi. mais (char) n'est pas un pointeur.

            Avec "toto = (type *)g_malloc(10)", ça marche, mais va pas durer si toto n'est pas un pointeur.
            Je te conseille fortement de te plonger dans un manuel sur le language C.
            • [^] # Re: Programmation C et GTK

              Posté par  . Évalué à 1.

              Bon, je vois que le sujet passionne. Pour finir ce post, je vous donne le code complet.

              struct coups_jouables
              {
              int pos_piece_tab;
              int coup;
              bool case_occupee;
              bool coup_ami;
              };

              coups_jouables *coups;

              coups=g_malloc(sizeof(coups_jouables));

              Voila. En écrivant ca, il y a erreur.
              • [^] # Re: Programmation C et GTK

                Posté par  (site web personnel) . Évalué à 1.

                coups_jouables *coups;

                ben oui c'est :

                struct coups_jouables *coups;
                coups=g_malloc(sizeof(struct coups_jouables));


                ou

                coups=g_malloc(sizeof *coups);
              • [^] # Re: Programmation C et GTK

                Posté par  . Évalué à 3.

                > Bon, je vois que le sujet passionne.

                Si tu donnais rapidement le source qui ne va pas (s'il est gros un lien externe), la ligne de commande pour compiler, un dump du message d'erreur, ça irait plus vite.

                Vivi a donné la réponse, je préfère la second solution.

                L'obligation d'ajouté "struc", a été introduit dans l'une des dernières norme ansi de C. Sinon il faut utiliser typedef qui introduit un synonyme à "struct coups_jouables". un type enum doit aussi être précédé de "enum".

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.