IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

 C Discussion :

pointeur de struc


Sujet :

C

  1. #1
    Membre à l'essai
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    25
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 25
    Points : 16
    Points
    16
    Par défaut pointeur de struc
    salut a tous,donc voila je voudrais savoir si j'ai bien comprit,pour exemple je met ce 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
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
     
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include "joueur.h"
     
    int main(void)
    {
        int i = 0 , pos = 1;
       joueur player[2];
     
         for (i=0;i<2;i++)
         {
             printf("\nJoueur n %d Veuillez entre votre nom :\n", pos);
             scanf("%s", player[i].nom);
             printf("\nVeuillez enter votre prenom :\n");
             scanf("%s", player[i].prenom);
             printf("\nVeuillez entrer votre classe :\n");
             scanf("%s", player[i].classe);
             pos++;
         }
     
     
         printf("joueur 1 :%s | %s | %s\n\n", player[0].nom,player[0].prenom,player[0].classe);
         printf("joueur 2 :%s | %s | %s\n\n", player[1].nom,player[1].prenom,player[1].classe);
     
     
         system("PAUSE");
         return 0;
     
     
     
    }

    donc une fois mes deux joueurs enregistre,si je veux modifier une valeur il faut que je passe par un pointeur ?

    par exemple si j'avais creer un char pseudo[] et qu'admettons le joueur veuille changer son pseudo ce ne serait possible que par pointeur comme dans une fonctions normal ?

    il faudrait que je creer un pointeur sur ma structure pour pouvoir changer le pseudo.

    la question vous semblera peut etre bete mais bon je veux m'assurer que j'ai bien saisi.

    merci a tous.

  2. #2
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 627
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 627
    Points : 10 548
    Points
    10 548
    Par défaut
    Si dans ta structure tu as mis des pointeurs char* data et non pas des tableaux fixes char data[XX], tu n'as pas besoin d'1 pointeur de ta structure pour la passer.

    Par contre, tu vas avoir une "recopie binaire à chaque passage"


    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
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    struct Test {
        char* data;
    };
     
     
    void init_struct(struct Test t, unsigned char len) {
        if (len > 0) {
            printf("Address: %p\n", &t);
     
            memset(t.data, 0x00, len);
        }
    }
     
     
    void test_fill(struct Test t, unsigned char len) {
        if (len > 0) {
            unsigned char pos;
     
            printf("Address: %p\n", &t);
     
            for(pos = 0; pos < (25 - 1); ++pos) {
                t.data[pos] = ('a' + pos);
            }
        }
    }
     
     
    int main(int /*argc*/, char* /*argv*/[])
    {
        struct Test t;
     
        t.data = (char*) malloc(25);
     
        printf("Address: %p\n", &t);
     
        if (t.data != NULL) {
            init_struct(t, 25);
     
            test_fill(t, 25);
     
            printf("data: %s\n", t.data);
     
            free(t.data);
        }
     
        return 0;
     }

    Édit: Merci sambia39

    J'avais testé avec un pointeur et retirer le pointeur sans nettoyer le if.

  3. #3
    Membre à l'essai
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    25
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 25
    Points : 16
    Points
    16
    Par défaut
    merci .
    je t'ai suivi a peu pres au debut mais je t perdu a "copie binaire a chaque passage"

    je debute y'a beaucoup de chose que je n'ai pas encore mais ca viendra

  4. #4
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 627
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 627
    Points : 10 548
    Points
    10 548
    Par défaut
    J'ai mis à jour mon code pour afficher les adresses

    Tu vois bien que les adresses sont différentes. Lorsqu'on passe en paramètre par valeur (et non pas par pointeur), on crée une nouvelle variable identique à la valeur originale avec "une recopie binaire" (en gros un memcpy avec un sizeof de ta variable).

    C'est pour cela qu'avec un passage par valeur il n'y a pas de modifications: on modifie une copie


    Et en plus, sur la pile des appels au lieu d'avoir un pointeur (4 ou 8 octets), on va avoir une copie (sizeof de ta variable).
    Donc si on n'a une grosse structure, ce n'est pas terrible

  5. #5
    Membre à l'essai
    Profil pro
    Inscrit en
    Mai 2009
    Messages
    25
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Mai 2009
    Messages : 25
    Points : 16
    Points
    16
    Par défaut
    ok merci

  6. #6
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 631
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 631
    Points : 30 865
    Points
    30 865
    Billets dans le blog
    1
    Par défaut
    Bonjour
    Citation Envoyé par wil31 Voir le message
    donc une fois mes deux joueurs enregistre,si je veux modifier une valeur il faut que je passe par un pointeur ?

    par exemple si j'avais creer un char pseudo[] et qu'admettons le joueur veuille changer son pseudo ce ne serait possible que par pointeur comme dans une fonctions normal ?
    De façon plus propre (et plus simple), si tu crées une variable dans une fonction ; et que tu veux faire modifier cette variable par une autre fonction, tu es alors obligé de passer l'adresse ce cette variable à cette autre fonction. C'est en effet dû au fait que le transfert de valeurs entre deux fonctions ne se fait que par recopie et que si tu tentes de transférer la variable elle-même, l'autre fonction en recevant une copie ne modifiera que la copie.
    Alors qu'en transférant l'adresse, l'autre fonction en reçoit aussi une copie mais comme la mémoire est la même pour tout le programme, avec la copie de cette adresse elle pourra accéder quand-même à la variable qui y correspond (et donc la modifier).

    Donc c'est valable pour toute fonction, y compris quand tu es dans le main() (qui reste elle-aussi qu'une fonction) et que tu veux la faire remplir par scanf() (qui reste elle aussi une fonction). Tu écriras alors int i; scanf("%d", &i).
    Et c'est aussi valable y compris quand tu écris scanf("%s", player[i].nom) parce que le nom d'un tableau équivaut à l'adresse de son premier caractère. Cela revient donc à écrire scanf("%s", &player[i].nom[0]).

    Mais si tu dois simplement afficher ta variable, alors la simple copie suffit. Tu écriras alors int i=123; printf("i=%d\n", i).

    Et donc ça reste valable même si la variable est une structure. Mais pour ces dernières certaines personnes (dont je fais partie) préfèrent passer toujours les adresses (même pour simplement l'afficher) parce qu'il est plus rapide de copier une adresse (4 octets) qu'une structure de (peut-être) plusieurs milliardscentaines d'octets...
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  7. #7
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 627
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 627
    Points : 10 548
    Points
    10 548
    Par défaut
    @Sve@r: ici c'est un cas un peu spécial: wil31 veut modifier des chaînes de caractères (si j'ai bien tout compris)

    Mais si ces chaînes sont des pointeurs et non pas des tableaux fixes, et comme elles sont contenues dans une structure, pour ces chaînes se sera toujours un passage par pointeur.

    Donc pour le passage de la structure, cela change quasi rien par valeur ou par pointeur.
    Juste une recopie et la taille de la pile des appels pour un cas.

    Et à moins qu'il veut créer/ agrandir/ réduire ces chaînes de caractères

  8. #8
    Membre expérimenté
    Avatar de sambia39
    Homme Profil pro
    No Comment
    Inscrit en
    Mai 2010
    Messages
    543
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loiret (Centre)

    Informations professionnelles :
    Activité : No Comment
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Mai 2010
    Messages : 543
    Points : 1 745
    Points
    1 745
    Par défaut
    Bonjour
    Par défaut les arguments d'une fonction son passés par valeur. Il est donc impossible au sein d’une fonction de modifier la valeur originale d’une donnée (variable par exemple) car la fonction n'a que la copie de la donnée (et ne connaît pas l’adresse mémoire de celle-ci ). Pour pallier à cela il faut passer comme argument un pointeur qui pointe sur la donnée en question et c’est grâce à ce pointeur que la fonction va récupérer l'adresse mémoire de cette variable et ainsi le pointeur va vous permettre d’appliquer les modification nécessaire sur la donnée.

    Citation Envoyé par Sve@r Voir le message
    Bonjour

    De façon plus propre (et plus simple), si tu crées une variable dans une fonction ; et que tu veux faire modifier cette variable par une autre fonction, tu es alors obligé de passer l'adresse ce cette variable à cette autre fonction. C'est en effet dû au fait que le transfert de valeurs entre deux fonctions ne se fait que par recopie et que si tu tentes de transférer la variable elle-même, l'autre fonction en recevant une copie ne modifiera que la copie.
    Alors qu'en transférant l'adresse, l'autre fonction en reçoit aussi une copie mais comme la mémoire est la même pour tout le programme, avec la copie de cette adresse elle pourra accéder quand-même à la variable qui y correspond (et donc la modifier).


    .......
    Mais pour ces dernières certaines personnes (dont je fais partie) préfèrent passer toujours les adresses (même pour simplement l'afficher) parce qu'il est plus rapide de copier une adresse (4 octets) qu'une structure de (peut-être) plusieurs milliardscentaines d'octets...

    Les points que Sve@r à soulevés sont très importants.
    Sachant que les arguments par défaut sont passés par valeur et recopiés dans les paramètres formels (les arguments de la fonction). Il est alors impossible à l’intérieur d’une fonction de modifier la donnée originale car on ne travaille qu’avec une copie. La solution est donc de passer par un pointeur. Il faut comprendre que le mécanisme de recopie d’argument passé par valeur est le même qu’un pointeur passé en argument de fonction. C’est a dire, qu’il est recopié dans les paramètres formels de la fonction et tout comme les arguments de la fonction le pointeur d’origine ne peut être modifié mais comme la case mémoire ou l’adresse mémoire sur lequel le pointeur pointe est strictement la même que le paramètre, il devient alors possible d’accéder et de modifier la donnée depuis l’intérieur de la fonction.

    Je suis également d’accord sur le gain de temps & espace : passer un argument via son pointeur plutôt que le recopier permet de gagner de la place et du temps d’exécution ; surtout si cet argument est de grande taille (structure complexe ou structure tout court). En clair, si vous passez par la recopie une structure à tout va dans les paramètres formels de votre fonction, vous utilisez beaucoup de mémoire.



    Citation Envoyé par foetus Voir le message
    Si dans ta structure tu as mis des pointeurs char* data et non pas des tableaux fixes char data[XX], tu n'as pas besoin d'1 pointeur de ta structure pour la passer.

    Par contre, tu vas avoir une "recopie binaire à chaque passage"


    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
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    struct Test {
        char* data;
    };
    
    
    void init_struct(struct Test t, unsigned char len) {
        if ((t != NULL) && (len > 0) {
            printf("Address: %d\n", &t);
    
            memset(t.data, 0x00, len);
        }
    }
    
    
    void test_fill(struct Test t, unsigned char len) {
        if ((t != NULL) && (len > 0) {
            unsigned char pos;
    
            printf("Address: %d\n", &t);
    
            for(pos = 0; pos < (25 - 1); ++pos) {
                t.data[pos] = ('a' + pos);
            }
        }
    }
    
    
    int main(int /*argc*/, char* /*argv*/[])
    {
        struct Test t;
    
        t.data = (char*) malloc(25);
    
        printf("Address: %d\n", &t);
    
        if (t.data != NULL) {
            init_struct(t, 25);
    
            test_fill(t, 25);
    
            printf("data: %s\n", t.data);
    
            free(t.data);
        }
    
        return 0;
     }
    Le code source proposé ci-dessus comporte des erreurs de logique de programmation et de programmation dus peut-être à des erreurs d’inattention :

    • Manque de parenthèse
    • printf("Address: %d\n", &t);: Pour affiché l'adresse il faut utilisé fprintf( stdout, "(1)\t%p\n", data.data );
    • (t != NULL) && (len > 0) :Le teste ici génère systématiquement une erreur à cause de l’expression car une structure n’est pas une opérande si je peux le dire ainsi ; c’est-à-dire que l’on ne peut effecter de comparaison ou d’arithmétique dessus.
      Pour le faire il faut soit le faire sur un de ces membres ou sur un pointeur qui pointe sur la structure. Les syntaxes valide serait plutôt
      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
      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
      73
      74
      75
      76
      77
      78
      79
      80
      81
       
      /*
       ============================================================================
       Name        : Untitled 6.c
       Author      : SAMBIA39
       Version     : 0.1
       Copyright   : Copyright (c) 2016 SAMBIA39
       Description : Ansi-style
       ============================================================================
       */
       
       
      #define SIZEDEF 26
      #include <stdio.h>
      #include <stdlib.h>
      #include <string.h>
       
      struct Test {
          char* data;
      };
       
      //
      void f_init( struct Test *data, size_t size ){
       
          extern int errno;
       
          errno = 0;
          size = (0 >= size ) ? SIZEDEF: size;
          if( NULL != data->data ){
              fprintf( stdout, "Addr data = %p\n", data->data );
              memset( data->data, 0, size );
          }else{
              if( NULL == (data->data = malloc( size * sizeof(char) )) ){
                  fprintf( stderr, "(%d)\t:%s\n\t:%s\n", errno,
                      "Erreur allocation", strerror(errno) );
                  exit( -1 );
              }
              memset( data->data, 0, size );
          }
      }
       
      //
      void f_init_struct( struct Test *data, size_t size ){
       
          extern int errno;
          unsigned int i = 0;
       
          errno = 0;
          size = (0 >= size ) ? SIZEDEF: size;
          f_init( data, size );
          for( i = 0; i < size; i++ )
              data->data[i] = ( 'a' + i );
          data->data[SIZEDEF] = '\0';
      }
       
       
      //
      int main( void ){
       
          struct Test data;
       
          data.data = NULL;
          fprintf( stdout, "(init)\t%s\n", data.data );
          f_init_struct( &data, SIZEDEF );
       
          fprintf( stdout, "\n(1)\t%s\n", data.data );
          fprintf( stdout, "(1)\t%p\n", data.data );
       
          f_init( &data, SIZEDEF );
          fprintf( stdout, "\n(2)\t%s\n", data.data );
          fprintf( stdout, "(2)\t%p\n", data.data );
          //
          free( data.data );
          data.data = NULL;
       
          //
          fprintf( stdout, "\n(3)\t%s\n", data.data );
          fprintf( stdout, "(3)\t%p\n", data.data );
       
          return EXIT_SUCCESS;
      }


    Ps:Un tableau même de très grande taille est toujours passé par référence et pas par recopie


    à bientôt
    Celui qui peut, agit. Celui qui ne peut pas, enseigne.
    Il y a deux sortes de savants: les spécialistes, qui connaissent tout sur rien,
    et les philosophes, qui ne connaissent rien sur tout.
    George Bernard Shaw

  9. #9
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 631
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 631
    Points : 30 865
    Points
    30 865
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par foetus Voir le message
    @Sve@r: ici c'est un cas un peu spécial: wil31 veut modifier des chaînes de caractères (si j'ai bien tout compris)
    Il n'y a jamais de cas spécial. Même pour des chaines la règle reste la même parce qu'une chaine est avant tout un tableau et que le nom d'un tableau équivaut à une adresse (de son premier caractère).

    Citation Envoyé par foetus Voir le message
    Mais si ces chaînes sont des pointeurs et non pas des tableaux fixes
    Un pointeur est une variable stockant une adresse. Le nom d'un tableau fixe est l'adresse de son premier caractère. Donc si tu passes un pointeur tu passes alors une adresse sur un char, et si tu passes le nom d'un tableau tu passes aussi une adresse sur un char. Donc là aussi dans les deux cas c'est la même chose. Attention, je n'ai jamais dit qu'il fallait toujours mettre "&", j'ai juste dit qu'il fallait toujours que ce soit une adresse. Et dans certains cas, l'élément étant déjà une adresse, le passer tel quel (sans mettre de "&") suffira (ou plutôt sera impératif).

    Citation Envoyé par foetus Voir le message
    et comme elles sont contenues dans une structure, pour ces chaînes se sera toujours un passage par pointeur.
    Là je ne vois pas trop le rapport avec le fait qu'elles soient dans une structure. Quand il écrit scanf("%s", player[i].nom) certes il récupère l'adresse du premier caractère du tableau "nom" de l'élément [i] du tableau de structures "player" mais le principe ne change pas => une adresse

    Citation Envoyé par foetus Voir le message
    Donc pour le passage de la structure, cela change quasi rien par valeur ou par pointeur.
    Ben si. Si tu as (imaginons) (30 + 1) caractères pour le nom, (30 + 1) pour le prénom et (10 + 1) pour la classe (j''aime bien écrire "+ 1" pour montrer que j'ai bien pensé au '\0'); passer la structure par copie fera copier 73 caractères contre 4 (32 bits) ou 8 (64 bits) si tu passes son adresse...

    Citation Envoyé par foetus Voir le message
    Et à moins qu'il veut créer/ agrandir/ réduire ces chaînes de caractères
    Même dans ce cas, ça reste un cas général => tu passeras l'adresse du pointeur à agrandir mais ça reste une adresse
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

  10. #10
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 627
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 627
    Points : 10 548
    Points
    10 548
    Par défaut
    Citation Envoyé par Sve@r Voir le message
    ... Nous sommes d'accord ...
    Si c'est un cas spécial parce que il ne veut pas faire ceci void modify(char* name) mais void modify(MyStuct*) ou void modify(MyStuct).

    Mon code corrigé par sambia39 montre qu'avec un passage par valeur de la structure on peut quand même modifier les tableaux à l'intérieur de celle ci (juste le contenu cela va de soi )


    Et justement (j'ai testé) si tu fais ceci void modify(MyStuct) (passage par valeur) avec un tableau fixe dans ta structure, la copie contient un nouveau tableau fixe

  11. #11
    Expert éminent sénior
    Avatar de Sve@r
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Février 2006
    Messages
    12 631
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Oise (Picardie)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Février 2006
    Messages : 12 631
    Points : 30 865
    Points
    30 865
    Billets dans le blog
    1
    Par défaut
    Citation Envoyé par foetus Voir le message
    Et justement (j'ai testé) si tu fais ceci void modify(MyStuct) (passage par valeur) avec un tableau fixe dans ta structure, la copie contient un nouveau tableau fixe
    Pas mal - Effectivement je n'avais pas pensé à ça.
    Donc si tu as une structure contenant un tableau
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    struct {
        char tab[10];
    } var;
    Et que tu passes une copie de var à une fonction, celle-ci créera une copie de tab.

    Mais si tu as une structure contenant un pointeur
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    struct {
        char *pt;
    } var;
    var.pt=malloc(10);
    Et que tu passes une copie de var à une fonction, celle-ci créera une copie de pt mais cette copie restant l'adresse de la zone allouée, tu pointeras quand-même vers la bonne zone.

    Perso je pense qu'on peut classer ce comportement dans les effets de bords. De plus je ne suis pas certain que ce soit une bonne chose car cela peut amener à des bugs après coup. Si par exemple je commence à programmer avec un pointeur dans ma structure puis que demain mes conditions changent et que mon champ devenant fixe je remplace le pointeur par un tableau ; un code qui utilise des passages de la structure par adresse n'aura aucun souci avec ce changement de détail alors que celui qui utilise des copies de structures partira dans le mur (et ne comprendra pas pourquoi).
    Surtout si j'écris ceci
    Code c : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    struct {
        char tab[10];
        char *pt;
    } var;
    var.pt=var.tab
    Et que je passe une copie de ma structure

    Ca renforce ma volonté de toujours utiliser des passages de structures par adresses
    Mon Tutoriel sur la programmation «Python»
    Mon Tutoriel sur la programmation «Shell»
    Sinon il y en a pleins d'autres. N'oubliez pas non plus les différentes faq disponibles sur ce site
    Et on poste ses codes entre balises [code] et [/code]

Discussions similaires

  1. Comment fait ça avec les pointeurs, la fonction et les struc
    Par mahdianis dans le forum Balisage (X)HTML et validation W3C
    Réponses: 3
    Dernier message: 24/02/2006, 19h01
  2. Pointeur vers un tableau
    Par Nikos dans le forum C
    Réponses: 3
    Dernier message: 09/12/2002, 01h43
  3. [Turbo Pascal] Allocation et désallocation de pointeurs dans une fonction
    Par neird dans le forum Turbo Pascal
    Réponses: 13
    Dernier message: 17/11/2002, 21h14
  4. djgpp et pointeurs far -2
    Par elvivo dans le forum Autres éditeurs
    Réponses: 16
    Dernier message: 29/07/2002, 23h43
  5. djgpp et pointeurs far
    Par elvivo dans le forum C
    Réponses: 2
    Dernier message: 13/07/2002, 01h44

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo