Partage
  • Partager sur Facebook
  • Partager sur Twitter

Les mots clefs du C

Discussion sur le topic sur les mots clefs du C

Anonyme
    19 juillet 2012 à 15:46:33

    Citation : rz0

    Citation : informaticienzero


    C'est vrai, pour une utilisation poussée je me tournerais vers GCC, mais si c'est une petite routine simple, je préfèrerais faire quelque chose comme avec VC++. De toutes façons, on a pas trop le choix puisque l'assembleur dépend du compilateur choisi.



    Vu les capacités limitées de MSVC regardant l'ASM inline, autant coder tes routines en ASM à part, et assembler à part (avec l'assembleur de ton choix). Et là c'est pas spécifique à un compilateur donné, d'ailleurs.



    C'est vrai, mais à mon avis pour quelqu'un de mon niveau qui fait des programmes relativement basiques je n'aurais jamais besoin d'aller aussi loin. La seule fois où j'ai eu à faire ça c'était quand je codais un mini-système d'exploitation, pour linker le boot avec le noyau.
    • Partager sur Facebook
    • Partager sur Twitter
      19 juillet 2012 à 16:53:47

      int

      Norme : Toute, avec en C99 et c11 possibilité d’affectation dans un for
      Déscription :Type de donnée d'entier positif ou négatif codé généralement sur 16 ou 32 bits(celon l'OS et l'architecture), permet de réaliser des affectations de type et des cast

      ExempleRenvoyer la taille d'un entier
      size_t tailleInt(void)
      {
        //Retourne le nombre d'octet utiliser pour un int
        return sizeof(int);
      
      }
      


      Affectation de type à une variable
      int maVariable;//maVariable est maintenant un entier positif ou négatif
      


      Cast d'une variable:
      Attention au codage qui peuvent être différent comme char->int
      size_t ma_variable = 5;
      int maVariable = (int)ma_variable;//Vaut 5
      maVariable = (int)'5';//Ne vaut pas 5
      


      Déclaration dans un for:
      for(int i=0; i<12; i++)
         printf("Les modérateur du forum C sont les meilleurs!!!!")
      


      Il y a quelque point à revoir je pense(et sans doutes erreur), sinon j'ai hésité à parler de la représentation (complément à 2 sur windows il me semble), mais vus que sa varies en fonction du compilateur et du matérielle.
      • Partager sur Facebook
      • Partager sur Twitter
        19 juillet 2012 à 17:05:56

        Citation : florent m


        Norme : Toute, avec en C90 et C11 possibilité d’affectation dans un if, for, while, ...



        Depuis le C99, il est seulement possible de définir une variable dans la première expression d'un for, mais il n'en est pas question pour un if ou un while.
        • Partager sur Facebook
        • Partager sur Twitter
          19 juillet 2012 à 17:07:36

          Autant pour moi c'est modifier.
          • Partager sur Facebook
          • Partager sur Twitter
          Anonyme
            22 juillet 2012 à 18:27:18

            Ça y est, je pense avoir fini avec le mot-clef asm (enfin on peut parler des autres compilateurs, mais personnellement je connais que GCC et VC++).
            • Partager sur Facebook
            • Partager sur Twitter
            Anonyme
              28 juillet 2012 à 23:41:00

              Voici d'autres mots-clefs écrits en attendant le foot féminin après la belle victoire des filles. Des volontaires pour relire ? Au fait GuilOoo, si tu lis ce message, peut-tu créer le topic officiel où l'on pourra poster les mots-clefs une fois validés s'il-te-plaît ? Merci d'avance.

              Citation : do, while

              do, while

              Norme : toutes
              Description : ces mot-clefs permettent de répéter une instruction ou un bloc d'instructions tant qu'une ou plusieurs conditions sont remplies. Dès qu'une des condition devient fausse, la boucle s'arrête. Ils sont cependant légèrement différent.

              Une boucle de type while teste d'abord la condition avant d'exécuter le code, ce qui fait que si la condition est fausse dès le départ le code ne sera pas exécuté du tout. Schématiquement parlant elle fonctionne ainsi :

              Image utilisateur



              La boucle do while est quand à elle différente car elle exécute d'abord le code avant de tester la condition, et ce même si la condition est fausse dès le départ. Ainsi, on a l'assurance qu'une boucle do while sera toujours exécutée au moins une fois. Schématiquement parlant, elle fonctionne ainsi :

              Image utilisateur



              Les deux boucles sont également différentes sur leur syntaxe :

              while (condition)
              {
                  /* code */
              }
              
              
              do
              {
                  /* code */
              } while (condition);
              



              Exemple et / ou commentaire :

              Exemple illustrant la différence entre les deux boucles :

              while (0)
              {
                  puts("while");
              }
              
              do
              {
                  puts("do while");
              } while (0);
              



              Cette particularité fait qu'on utilise souvent do while conjointement avec le préprocesseur :

              #define VAL(x) \
                  do \
                  { \
                      if (x < 0) \
                          printf("Inferieur a 0.\n"); \
                      else if (x > 0) \
                          printf("Superieur a 0\n"); \
                      else \
                          printf("Egal a 0"); \
                  } while (0)
              





              Citation : const


              const, volatile

              Norme : toutes
              Description : const sert à déclarer un objet comme étant constant, c'est à dire qui ne peut en théorie pas être modifié. Il devient nécessaire de donner une valeur dès la déclaration.

              Exemple simple ci-dessous.

              const double e = 2.718281828;
              e++;  /* interdit ! */
              



              Le mot-clef volatile sert quand à lui à spécifier qu'une variable peut être modifiée indépendamment de la volonté du programmeur ; ce peut être par un autre programme, une interruption, un périphérique, etc. Ainsi, au lieu d'être habituellement placée dans un registre, une variable déclarée avec volatile sera placée uniquement en mémoire vive. Il est important de noter que, excepté dans de rares cas, ce mot-clef ne sert à rien.

              Exemple et / ou commentaire :

              Toutes les explications qui suivent utilisent const, mais le principe est le même pour volatile.

              Le mot-clef const s'applique sur ce qui le précède, excepté s'il est en premier dans l'expression, auquel cas il s'applique sur ce qui le suit immédiatement. Cela n'est pas important dans le cas de variables simples, mais prend son importante dans le cas des pointeurs.


              Pointeurs et const


              Le mot-clef const peut changer la signification d'un pointeur en fonction de sa position. En effet, s'il est placé avant le type T, on obtient un pointeur sur un T constant. Dans ce cas, la modification de l'objet pointé est interdite ; la modification du pointeur reste autorisée.

              int a = 2, b = 3;
              const int * ptr = &a;
              
              *ptr = 3;    /* interdit ! */
              ptr = &b;    /* autorisé */
              



              A l'inverse, si const est situé juste après * alors on obtient un pointeur constant sur un T. La modification du pointeur est interdite mais pas la modification de l'objet pointé.

              int a = 2, b = 3;
              int * const ptr = &a;
              
              ptr = &b;    /* interdit ! */
              *ptr = 3;    /* autorisé */
              



              Bien entendu, les deux possibilités sont combinables. Dans ce cas on obtient un pointeur constant sur un T constant, ce qui interdit de modifier le pointeur ou l'objet pointé.

              int a = 2, b = 3;
              const int * const ptr = &a;
              
              ptr = &b;    /* interdit ! */
              *ptr = 3;    /* interdit ! */
              



              Pointeurs de pointeurs


              Cette règle s'applique également aux pointeurs de pointeurs, et ce peu importe leur nombre. Dans notre exemple, pptr est un pointeur sur un pointeur constant sur un int constant.

              const int * const * pptr;
              
              pptr = OK;
              *pptr = KO;
              **pptr = KO;
              



              Autre exemple dans lequel ptr est un pointeur sur un pointeur constant sur un pointeur sur un pointeur constant sur un int constant.

              const int * const ** const * ptr;
              
              ptr = OK;
              *ptr = KO;
              **ptr = OK;
              ***ptr = KO;
              ****ptr = KO;
              




              Tableaux et const


              Dans le cas d'un tableau, s'il est déclaré avec const, alors tous les éléments du tableau sont constants, et il faut donc l'initialiser dès sa déclaration.

              const int tab[3] = {0, 10, 20};
              
              tab[1] = 0;   /* interdit */
              




              Bien entendu, les règles concernant les pointeurs s'appliquent aussi s'ils sont utilisés.

              Structures, unions et const


              Tout comme une simple variable, si un membre d'une structure ou d'une union est déclaré avec const alors il n'est pas modifiable. Si un objet de type struct T ou union T est déclaré avec const, alors tous les membres sont constants. Il faut alors initialiser la structure / l'union dès sa création. Exemple :

              struct Point
              {
                  int x, y;
              };
              
              int main(void)
              {
                  const struct Point point = {0, 0};
              
                  point.x = 2;  /* interdit ! */ 
                
                  return 0;
              }
              



              const vraiment constante ?


              En fait, const ne déclare pas une expression comme étant vraiment constante. Comme la norme ne précise pas de façon exhaustive les cas que le compilateur doit interdire, des modifications indirectes sont possibles, mais dans ce cas le comportement reste indéterminé. Exemples de modifications ci-dessous (les résultats peuvent varier).

              /* Avec scanf */
              
              const int a = 5;
              
              printf("Donnez a : ");
              scanf("%d", &a);
              printf("a = %d", a);
              

              a = 5
              Donnez a : 5454
              a = 5454


              /* Avec un pointeur */
              
              const int a = 5;
              int * ptr = &a;
              
              printf("a = %d\n", a);
              *ptr = 5 * 5;
              printf("a = %d\n", a);
              

              a = 5
              a = 25


              Cependant, s'il est bien réglé, le compilateur doit prévenir avec un warning dans le premier cas du type :
              warning: writing into constant object

              Et dans le deuxième cas :
              warning: initialization discards qualifiers from pointer target type


              Ainsi, malgré ce que l'on pourrait penser, il est interdit de faire ceci en C89, malgré la présence du qualifieur const :

              const int a = 5;
              int tab[a];
              


              En C99, c'est possible : il s'agit alors d'un <acronym title="Variable Length Array, Tableau à Taille Variable">VLA</acronym>.

              Note : en C++, un identificateur ayant reçu le qualifieur const peut apparaître dans une expression constante (comme l'exemple ci-dessus). Cela vient de la volonté de limiter l'usage des directives de préprocesseur en C++. Ainsi, au lieu de ceci comme en C :

              #define N 10
              


              on fera ainsi en C++ :

              const int N = 10;
              


              const et volatile ensembles



              En théorie, il est possible d'utiliser ces deux qualifieurs ensembles, l'ordre n'important pas. On obtient alors un objet qui n'est pas modifiable dans le programme mais qui l'est "de l'extérieur".

              Dans le cas des pointeurs, les règles vues précédemment s'appliquent :

              const int * volatile ptr;
              


              Dans cet exemple, on obtient un pointeur volatile sur un int constant.
              • Partager sur Facebook
              • Partager sur Twitter
                29 juillet 2012 à 1:09:30

                Dans l'exemple de la structure tu as oublié de la déclarer constante.

                • Partager sur Facebook
                • Partager sur Twitter
                Anonyme
                  29 juillet 2012 à 1:15:33

                  Ah oui bien vu. Merci d'avoir relu jusqu'au bout. :)
                  • Partager sur Facebook
                  • Partager sur Twitter
                    29 juillet 2012 à 11:02:09

                    Déclaration dans un for:
                    ==> manque un ;
                    • Partager sur Facebook
                    • Partager sur Twitter
                    perror(const char * str); will save your life !
                      29 juillet 2012 à 11:11:01

                      Citation : inf0

                      Ainsi, malgré ce que l'on pourrait penser, il est interdit de faire ceci en C, malgré la présence du qualifieur const :

                      const int a = 5;
                      int t[a];
                      


                      Uhm, what ?
                      • Partager sur Facebook
                      • Partager sur Twitter
                      Staff désormais retraité.
                        29 juillet 2012 à 11:14:48

                        Citation : Lucas-84


                        Uhm, what ?



                        La taille d'un tableau statique doit être une constante. Forcément une constante. Or, il est toujours possible de modifier dynamiquement le contenu d'une variable const, par exemple en utilisant un cast ou un pointeur sur la zone mémoire en question. Le compilateur ne peut donc pas vraiment s'y fier pour déterminer la taille du tableau, contrairement à un #define, par exemple.
                        • Partager sur Facebook
                        • Partager sur Twitter
                        J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                          29 juillet 2012 à 11:26:37

                          Citation : GuilOooo

                          Citation : Lucas-84


                          Uhm, what ?



                          La taille d'un tableau statique doit être une constante. Forcément une constante. Or, il est toujours possible de modifier dynamiquement le contenu d'une variable const, par exemple en utilisant un cast ou un pointeur sur la zone mémoire en question. Le compilateur ne peut donc pas vraiment s'y fier pour déterminer la taille du tableau, contrairement à un #define, par exemple.



                          Et les <acronym title="Variable Length Array">VLA</acronym> du C99 ? (oui, je sais que c'est globalement déprécié, mais il ne faut pas en faire une généralité non plus)
                          • Partager sur Facebook
                          • Partager sur Twitter
                          Staff désormais retraité.
                            29 juillet 2012 à 11:32:28

                            Yep, dans ce cas, ça sera un VLA (enfin je crois ?).
                            Mais ça peut être sympa d'être au courant qu'un tableau qui est en fait statique sera en vérité un VLA...
                            • Partager sur Facebook
                            • Partager sur Twitter
                            J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                              29 juillet 2012 à 11:35:58

                              Citation : GuilOooo

                              Yep, dans ce cas, ça sera un VLA (enfin je crois ?).
                              Mais ça peut être sympa d'être au courant qu'un tableau qui est en fait statique sera en vérité un VLA...



                              Oui, ça sera effectivement un VLA. C'est simplement l'expression « il est interdit de faire ceci en C » qui m'a choqué.
                              • Partager sur Facebook
                              • Partager sur Twitter
                              Staff désormais retraité.
                                29 juillet 2012 à 11:36:39

                                Aaah. Disons « il est interdit de faire ceci en C89 », dans ce cas. :-°
                                • Partager sur Facebook
                                • Partager sur Twitter
                                J'ai déménagé sur Zeste de savoir — Ex-manager des modérateurs.
                                  29 juillet 2012 à 11:37:34

                                  Citation : GuilOooo

                                  Aaah. Disons « il est interdit de faire ceci en C89 », dans ce cas. :-°



                                  Voilà. En précisant que c'est optionnel en C11 aussi. (bon, si on ne veut pas embêter le lecteur débutant, il suffit d'avancer une exception pour le C99 ! ^^ ).
                                  • Partager sur Facebook
                                  • Partager sur Twitter
                                  Staff désormais retraité.
                                    29 juillet 2012 à 11:41:22

                                    Citation : GuilOooo

                                    Or, il est toujours possible de modifier dynamiquement le contenu d'une variable const, par exemple en utilisant un cast ou un pointeur sur la zone mémoire en question. Le compilateur ne peut donc pas vraiment s'y fier



                                    Je me rappelle avoir eu cette discussion quelque part sur ce forum avec quelqu'un qui n'était pas d'accord mais de mon point de vue, le compilo peut tout à fait s'y fier parce que si tu modifies un objet déclaré const, c'est indéterminé.
                                    • Partager sur Facebook
                                    • Partager sur Twitter
                                    Anonyme
                                      29 juillet 2012 à 12:44:18

                                      Oui tu as raison de souligner ce point Lucas, j'ai dis "interdit" parce que je suis habitué au C89.
                                      • Partager sur Facebook
                                      • Partager sur Twitter
                                      Anonyme
                                        1 août 2012 à 21:57:49

                                        break, continue, goto

                                        Norme : toutes
                                        Description : ces trois-mots clefs permettent de réaliser des branchements inconditionnels. Ainsi, au contraire des boucles qui agissent selon une condition, ces mots-clefs vont permettre de reprendre l'exécution du code à un endroit bien précis quelque soit la situation. Chacun des trois mots-clefs à un comportement bien précis :

                                        • break permet de quitter la boucle en cours ;
                                        • continue permet de passer au tour suivant d'une boucle sans terminer celui en cours ;
                                        • goto permet carrément de sauter à une autre portion de code identifiée par un label.


                                        Exemple et / ou commentaire :

                                        Le premier exemple ci-dessous montre le comportement de break. On observe que la boucle est quittée et qu'on continue ensuite à exécuter le code normalement.

                                        int i;
                                        
                                        puts("Avant la boucle");
                                        
                                        for (i = 0 ; i < 10 ; i++)
                                        {
                                            if (i == 5)
                                                break;
                                        
                                            printf("i = %d\n", i);
                                        }
                                        
                                        puts("Après la boucle")
                                        

                                        Avant la boucle
                                        
                                        i = 0
                                        i = 1
                                        i = 2
                                        i = 3
                                        i = 4
                                        
                                        Après la boucle


                                        Il faut néanmoins se souvenir que break ne permet de sortir que d'une seule structure de contrôle. Ainsi, dans les cas de boucles imbriquées, on reviendra à la précédente à chaque appel de break.

                                        #include <stdio.h>
                                        
                                        int main(void)
                                        {
                                            int i;
                                        
                                            for (i = 0; i < 10; i++)
                                            {
                                                printf("[for] i = %d\n", i);
                                        
                                                while (i < 5)
                                                {
                                                    if (i == 4)
                                                        break;
                                        
                                                    printf("[while] i = %d\n", i);
                                                    i++;
                                                }
                                            }
                                        
                                            return 0;
                                        }
                                        

                                        [for] i = 0
                                        [while] i = 0
                                        [while] i = 1
                                        [while] i = 2
                                        [while] i = 3
                                        [for] i = 5
                                        [for] i = 6
                                        [for] i = 7
                                        [for] i = 8
                                        [for] i = 9


                                        Le second exemple illustre le fonctionnement de continue. On fait une boucle pour afficher les chiffres de 0 à 9. Si le nombre vaut 5, on passe au tour suivant, ce qu'on remarque à l'affichage.

                                        for (i = 0 ; i < 10 ; i++)
                                        {
                                             if (i == 5)
                                                continue;
                                        
                                             else
                                                 printf("%d\n", i);
                                        }
                                        

                                        i = 0
                                        i = 1
                                        i = 2
                                        i = 3
                                        i = 4
                                        i = 6
                                        i = 7
                                        i = 8
                                        i = 9


                                        Le dernier code montre les sauts effectués dans le code par goto grâce à des labels. Ces derniers permettent de donner un nom à une portion de code, exactement comme en assembleur. C'est comme ça que goto sait à partir d'où il doit reprendre l'exécution du code.

                                        int i;
                                        
                                        for (i = 0 ; i < 10 ; i++)
                                        {
                                             if (i == 5)
                                                 goto Erreur;
                                        
                                             printf("i = %d\n", i);
                                        }
                                        
                                        Erreur:
                                             puts("\ni vaut 5");
                                        

                                        i = 0
                                        i = 1
                                        i = 2
                                        i = 3
                                        i = 4
                                        
                                        i vaut 5


                                        Dans cet exemple, si la variable i atteint la valeur 5, on saute au label Erreur: qui affiche un message.

                                        Cependant, un reproche est fait à goto, celui de rendre le code illisible. C'est durant les années 1960 - 1970 que les critiques ont été formulées. Il a en effet été prouvé qu'on pouvait se passer totalement de goto en utilisant des structures de contrôles appropriées. C'est en effet le cas avec le code précédent :

                                        int i;
                                        
                                        /* code plus court et plus lisible */
                                        for (i = 0 ; i < 10 ; i++)
                                        {
                                             if (i == 5)
                                             {
                                                 puts("i vaut 5");
                                                 break;
                                             }
                                        
                                             printf("i = %d\n", i);
                                        }
                                        


                                        Si goto est très fortement déconseillé aux débutants, il n'est cependant pas à bannir entièrement. En effet, il existe encore un domaine où goto s'avère efficace et pratique : la gestion des erreurs.


                                        case, default, switch

                                        Norme : toutes
                                        Description : l'instruction switch permet de comparer successivement une variable à une ou plusieurs valeurs constantes appelées comparants et définies par un case. Si la comparaison est vraie, alors toutes les instructions jusqu'au prochain break sont exécutées, sinon on passe au comparant suivant. Si aucune comparaison n'est vraie, alors ce sont les instructions associées au default qui sont exécutées. Le modèle est le suivant :

                                        switch(/* variable */)
                                        {
                                            case /* comparant_1 */ :
                                                /* Instructions */
                                                break;
                                        
                                            case /* comparant_2 */ :
                                                /* Instructions */
                                                break;
                                        
                                            /*Etc...*/
                                        
                                            default: /* si aucune comparaison n'est juste */
                                                /* instructions à exécuter dans ce cas */
                                                break;
                                        }
                                        


                                        Exemple et / ou commentaire :

                                        Lorsque une comparaison est juste, toutes les instructions jusqu'au prochain break sont exécutées. Cela permet donc de tester plusieurs comparants en même temps.

                                        int main(void)
                                        {
                                            int note;
                                        
                                            scanf("Quelle note as-tu obtenu : ");
                                            scanf("%d", &note);
                                        
                                            switch(note)
                                            {
                                                /* si la note est comprise entre 0 et 4 inclus */
                                                case 0:
                                                case 1:
                                                case 2:
                                                case 3:
                                                case 4:
                                                    printf("Tu n'as pas la moyenne.\n");
                                                    break;
                                        
                                                /* si au contraire la note est égale ou supérieure à 5 */
                                        
                                                case 5:
                                                case 6:
                                                case 7:
                                                case 8:
                                                case 9:
                                                case 10:
                                                    printf("Tu as la moyenne.\n");
                                                    break;
                                        
                                                default:
                                                    printf("Erreur : note impossible\n");
                                                    break;
                                            }
                                        
                                            return 0;
                                        }
                                        


                                        La variable à tester doit être un caractère ou un entier (char, short, int ou long) et de même pour les comparants. Il est impossible de comparer des flottants, des pointeurs, des tableaux, des chaînes de caractères ou des objets plus complexes à l'aide d'un switch.


                                        signed, unsigned

                                        Norme : toutes
                                        Description : tous les types en C ont des bornes, et elles peuvent varier en fonction du spécificateur. Dans le cas d'une variable signed, les bornes vont de <math>\(-x\)</math> à <math>\(x\)</math> (avec <math>\(x\)</math> dépendant de l'implémentation) alors que dans le cas d'une variable unsigned les bornes vont de <math>\(0\)</math> à <math>\(2 \times x\)</math>. Dans le premier cas on peut stocker des nombres négatifs et positifs alors que dans le deuxième on ne peut stocker que des nombres positifs, mais jusqu'à deux fois plus. Les spécificateurs ne font associables qu'avec des caractères ou des entiers.

                                        Exemple et / ou commentaire :

                                        La présence d'un spécificateur lors de la déclaration d'une variable n'est pas obligatoire, car dans ce cas elle est implicitement déclarée comme étant signed. La seule exception est dans le cas de char : en effet, selon l'implémentation, char peut être signed ou unsigned.
                                        • Partager sur Facebook
                                        • Partager sur Twitter
                                          1 août 2012 à 22:20:37

                                          Lucas, evidemment qu'en C99 ça sera possible! tu peux y mettre une variable entre crochet, donc constante ou pas le compilo s'en fout maintenant...
                                          • Partager sur Facebook
                                          • Partager sur Twitter
                                            1 août 2012 à 22:28:49

                                            bonsoir,

                                            hum, ce serait tout de même bien, je pense, de noter que le mot clef const n'a pas du tout la même signification en C qu'en C++, non?
                                            Peut être faire 1 rappel sur ce const(si il n'existe pas déjà, je n'ai pas tout lu)?
                                            • Partager sur Facebook
                                            • Partager sur Twitter
                                            Zeste de Savoir, le site qui en a dans le citron !
                                              1 août 2012 à 22:32:50

                                              En C++ tu peux le mettre sur des méthodes, et d'une manière général c'est beaucoup plus sévère qu'en C (du genre ça compile pas, contrairement à un simple warning en C).

                                              Y'a d'autres choses à savoir? (c'est une vraie question)
                                              • Partager sur Facebook
                                              • Partager sur Twitter
                                                1 août 2012 à 22:36:09

                                                Dans mes souvenir le const en C, est plutôt une variable en lecture seule.
                                                En C++, il n'y a pas(la plupart du temps, il me semble) d'espace mémoire alloué pour cette variable, c'est une vraie constante(utilisable pour borner 1 tableau statique par exemple).

                                                edit:
                                                d'ailleurs en C++, on préfère souvent définir des constantes typées, à la place de nos define du C.

                                                #define N 100
                                                

                                                const unsigned N = 100;
                                                

                                                qui serait même en C, parfois remplacé par 1 enum
                                                • Partager sur Facebook
                                                • Partager sur Twitter
                                                Zeste de Savoir, le site qui en a dans le citron !
                                                Anonyme
                                                  1 août 2012 à 22:48:56

                                                  Citation : GurneyH

                                                  bonsoir,

                                                  hum, ce serait tout de même bien, je pense, de noter que le mot clef const n'a pas du tout la même signification en C qu'en C++, non?
                                                  Peut être faire 1 rappel sur ce const(si il n'existe pas déjà, je n'ai pas tout lu)?



                                                  Je veux bien, mais sur le coup je vois pas trop comment formuler ça.
                                                  • Partager sur Facebook
                                                  • Partager sur Twitter
                                                    1 août 2012 à 22:53:25

                                                    j'imagine! Surtout que je ne dois pas être très clair, vu que cette histoire de const m'a longtemps embrouillé(et m'embrouille encore).

                                                    peut-être à partir de ton code
                                                    const int a = 5;
                                                    int t[a];
                                                    

                                                    , et partir de l'objection de Lucas84 et des remarques suivantes?
                                                    • Partager sur Facebook
                                                    • Partager sur Twitter
                                                    Zeste de Savoir, le site qui en a dans le citron !
                                                    Anonyme
                                                      1 août 2012 à 22:55:07

                                                      Je pense que c'est effectivement le plus adapté pour faire l'opposition entre le C et le C++. Dommage que les concepteurs du C n'aient pas pensé à faire comme en C++, ça aurait été pratique.

                                                      Sinon ravi de te revoir Gurney. :)
                                                      • Partager sur Facebook
                                                      • Partager sur Twitter
                                                        1 août 2012 à 23:12:32

                                                        GurneyH, alors juste pour les variables, car pour les pointeurs etc. y'a le const_cast qui peut faire sauter le const.

                                                        Bref, j'ai voulu tester ce que tu as dis et je comprend pas... :
                                                        #include        <stdio.h>
                                                        
                                                        int             main(void)
                                                        {
                                                          int const     a = 21;
                                                          int*          p = (int*)&a;
                                                        
                                                          ++*p;
                                                        
                                                          printf("%d\n", *p); /* 22 */
                                                          printf("%d\n", a);  /* 21 ??? alors d'ou vient le 22 d'au dessus? */
                                                        
                                                          printf("%p\n", &a);
                                                          printf("%p\n", p);  /* Même adresse que &a */
                                                        
                                                          return 0;
                                                        }
                                                        
                                                        • Partager sur Facebook
                                                        • Partager sur Twitter
                                                          1 août 2012 à 23:24:26

                                                          yep même résultats en C et en C++ chez moi également!

                                                          Après, ça remonte un peu, mais mes remarques viennent de .

                                                          A creuser, j'ai moins le nez dedans en ce moment il est possible(probable) que je raconte des conneries!^^
                                                          • Partager sur Facebook
                                                          • Partager sur Twitter
                                                          Zeste de Savoir, le site qui en a dans le citron !
                                                            1 août 2012 à 23:42:49

                                                            Citation : Mr21


                                                            int             main(void)
                                                            {
                                                              int const     a = 21;
                                                              int*          p = (int*)&a;
                                                            
                                                              ++*p;
                                                            
                                                              printf("%d\n", *p); /* 22 */
                                                              printf("%d\n", a);  /* 21 ??? alors d'ou vient le 22 d'au dessus? */
                                                            

                                                            Regarde http://www.siteduzero.com/tutoriel-3-6 [...] tml#ss_part_2 sous-chapitre Bénéfices pour le compilateur.

                                                            En gros, le compilateur a le droit de considérer que p ne peut pas pointer sur a, et faire des optimisations en conséquence (comme remplacer printf("%d\n", a); par puts("21");).
                                                            • Partager sur Facebook
                                                            • Partager sur Twitter
                                                              1 août 2012 à 23:54:02

                                                              Ah bah oui.. En voyant que les deux adresses étaient identique ça ne pouvait qu'être ça \o/
                                                              Merci de l'éclaircissement!

                                                              Mais j'ai plusieurs tour dans mon sac :
                                                              #include        <stdio.h>
                                                              
                                                              void            plop(int const* a)
                                                              {
                                                                printf("%d\n", *a); /* Je retrouve mon 22 \o/ */
                                                              }
                                                              
                                                              int             main(void)
                                                              {
                                                                int const     a = 21;
                                                                int*          p = (int*)&a;
                                                              
                                                                ++*p;
                                                              
                                                                printf("%d\n", *p); /* 22 */
                                                                printf("%d\n", a);  /* encore 21  */
                                                              
                                                                printf("%d\n", a * 2); /* 42 et non 44  */
                                                              
                                                                printf("%p\n", (void*)&a); /* Meme adresses */
                                                                printf("%p\n", (void*)p);  /* qu'ici */
                                                              
                                                                plop(&a); /* mais... */
                                                              
                                                                return 0;
                                                              }
                                                              
                                                              Well played gcc! well played :)
                                                              • Partager sur Facebook
                                                              • Partager sur Twitter

                                                              Les mots clefs du C

                                                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                                                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                                                              • Editeur
                                                              • Markdown