Discussion :

[sidic1982]

Bonjour à tous, je suis débutant en programmation en C et j'ai une question sur le programme ci-dessous.

Résumé sur le programme :

• composé de deux fonctions, la 1ere void initialise_Nb_jours() initialise un tableau avec le nombre de jours du mois { 31 28 31 30 31 30 31 31 … } .
• la 2eme fonction void affiche() affiche le tableau initialisé par la fonction précédente.
• les deux fonctions sont sans paramètres d'entrées et sans paramètres de sorties. Au début de la fonction main, j'ai appelé la fonction initialise_Nb_jours(), ensuite la fonction affiche().

Ma question : malgré le fait que les deux fonctions n'aient aucun paramètre d'entrée ni aucun paramètre de sortie, qu'elles ne retournent aucune valeur et malgré le fait que le tableau Nb_jours[13] soit un pointeur propre à la fonction initialise_Nb_jours(), le tableau affiche_Nb_jours[] (déclaré dans la 2eme fonction affiche() ) arrive à pointer sur les valeurs du tableau Nb_jours[13] afin de les afficher.

SVP, pouvez vous m'expliquer cela ?

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
48
49
50
51
52
53
54
55
56
57
58
59
#include <stdio.h>
 
/* Fonction qui initialise le tableau Nb_jours */
/* Paramètre d'entrée : aucun                  */
/* Paramètre de sortie : rien                  */
 
void initialise_Nb_jours()
{ int Nb_jours[13];
 
  /* Déclaration d'un compteur de mois */
  int RangMoins;
 
  /* Pour tous les mois de l'année */
  for(RangMoins = 1; RangMoins <= 12 ; RangMoins++)
  { /* Si mois est février */
    if(RangMoins == 2)
 
      /* Alors le nombre de jours est 28 */
      Nb_jours[RangMoins] = 28;
 
      /* Sinon, si le rand du mois est pair et <=7 ou impair et >7 */
      /* Alors le nombre de jours est 30                           */
      else if((RangMoins % 2 == 0 && RangMoins<=7) || (RangMoins % 2 != 0) && RangMoins>7)
      Nb_jours[RangMoins] = 30;
 
      /* Sinon le nombre de jours est 31 */
      else Nb_jours[RangMoins] = 31;
  } 
}
 
/* Fonction qui affiche le tableau Nb_jours */
/* Paramètre d'entrée : aucun               */
/* Paramètre de sortie : rien               */
 
void affiche()
{ int affiche_Nb_jours[13];
 
  /* Déclaration d'un compteur de mois */
  int RangMoins;
 
  /* Pour tous les mois de l'année */
  /* Afficher le nombre de jours pour le mois en cours */
 
  for(RangMoins = 1; RangMoins <= 12 ; RangMoins++)
  printf("Le mois numero %d  de l'annee a %d jours\n", RangMoins, affiche_Nb_jours[RangMoins]);
} 
 
/****************************************************************************************/
/*                               Programme principal                                                                                               */
/****************************************************************************************/
 
void main(void) 
{
 /* Initialisation de Nb_jous */
 initialise_Nb_jours();
 
 /* Affichage de contenu du tableau */
 affiche(); 
}

[Xelland]

bonjour

déjà utilise la balise "CODE" pour la lisibilité de ton code

ton code fonctionne, car le compilateur a utilisé les mêmes zones de mémoire pour tes 2 fonctions
lors de la compilation de la 2ème fonction, il savait qu'il pouvait réutiliser la zone mémoire de la 1ère fonction (car interne à la 1ère fonction)


si par exemple, tu rajoutes entre initialise_Nb_jours(); et affiche(); un appel à une nouvelle fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void ma_fonction ()
{
    int tab[7];            /* je prends volontairement une valeur plus petite pour que tu vois qu'il va peut-être écraser une partie de la mémoire) */
    for (int i=0;i<7;i++)tab[i]=2;
}
 
...
{
    initialise_Nb_jours();
    ma_fonction ();   /* appel à la nouvelle fonction */
    /* Affichage de contenu du tableau */
    affiche();
}

mais tu restes sur un comportement indéfini (tout dépend de comment le compilateur gère sa mémoire)

[sidic1982]

Merci beaucoup pour ta réponse détaillée.

[foetus]

Je ne comprends

• ni le but de l'exercice: travailler avec les variables globales. mais pourquoi ?
• ni l'utilité de l'exercice: utiliser les variables globales. Sauf cas spécifiques (l'embarqué par exemple), les variables globales sont à éviter
• ni ce qu'il faut faire: afficher juste 30 et 31 pour le mois 1 à 12 c'est moche

1 solution

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
#include <stdio.h>
#include <stdlib.h>
 
 
char list_nb_days[12];
 
void init_nb_days() {
    list_nb_days[0] = list_nb_days[2] = list_nb_days[4] = list_nb_days[ 6] =
                      list_nb_days[7] = list_nb_days[9] = list_nb_days[11] = 31;
 
    list_nb_days[3] = list_nb_days[5] = list_nb_days[8] = list_nb_days[10] = 30;
 
    list_nb_days[1] = 28;
}
 
void display_nb_days() {
    char day;
 
    for(day=0; day < 12; ++day) {
        printf("month %2d, number of days: %d\n", (day + 1), list_nb_days[day]);
    }
}
 
 
int main()
{
    init_nb_days();
    display_nb_days();
 
 
    return EXIT_SUCCESS;
}

[sidic1982]

Je suis débutant et j'ai rien compris dans tous ce que tu as dit.

Pour résumer, je m'entraine à programmer en C pour évoluer. C'est un programme que j'ai retrouvé dans un livre, le tableau est déclaré en global.
J'ai effectué une petite modification, j'ai supprimé le tableau déclaré en globale et je l'ai remplacé par deux tableaux en local pour chaque fonction et le résultat était le même.
J'avais un doute que le compilateur utilise la même zone mémoire pour les deux tableaux, du coup j'ai posé la question ici et j'ai eu la confirmation de Xelland.

[gerald3d]

Bonjour.

Pour essayer de faire le plus simple possible (je vais tenter de vulgariser au maximum ) en C (et en C++ aussi) ce qu'il faut avoir en tête c'est la division de la mémoire en deux parties distinctes:

• la mémoire dans la pile ;
• la mémoire dans le tas.

La pile

Tout d'abord sa taille. Elle est définie par ton système d'exploitation. En général 1Mo. Mais bien entendu elle peut être différente. Il est aussi possible de la modifier. En règle générale personne n'y touche.

À quel moment je sais que j'utilise cette mémoire ?
C'est tout simple. Un bloc mémoire est alloué à chaque fois que tu ouvres une accolade . Chaque fonction est définie par une paire d'accolades. À l'intérieur je peux donc déclarer des variables sans dépasser la taille allouée. Tu peux faire un essai en déclarant par exemple un tableau de int d'une taille de 10Mo. Regarde le résultat en console .

Quelle est la durée de vie des variables déclarées dans une parie d'accolades ?
La réponse est dans la question. Tant que ton code reste dans les accolades les variables déclarées à l'intérieur perdurent. Ainsi si tu appelles une fonction à l’intérieur d'une paire d'accolades et que tu y transmets ces variables, elles seront toujours viables dans la fonction appelée.

Le tas

Le tas correspond au reste de la mémoire de la machine sur laquelle tourne ton application. Pour y accéder nous faisons une allocation dynamique. C'est à dire nous utilisons la fonction malloc() (et ses dérivées). Cette méthode permet de dépasser la limitation que nous impose la taille de la pile.
Et c'est là que nous allons entrer dans les problèmes . Qui dit allocation dynamique dit libération des blocs devenus inutiles. Ceci se fait avec la fonction free(). Bon nombre de programmeurs oublient de libérer certains blocs ce qui peut entrainer le crash de l'application et aussi permettre certains exploits pour pénétrer dans les systèmes. Mais ça c'est une autre histoire.


En résumé avoir des variables globales, c'est à dire accessibles en tout point du programme est à fortement éviter. Le code devient rapidement difficile à maintenir voir à déboguer. L'art du C (et du C++) est en grande partie contenu ici. Arriver à faire en sorte de ne pas en avoir. Pour y parvenir il te faut maitriser les deux notions décrites ici. J'espère avoir pu apporter une petite pierre à ta compréhension.

[henderson]

Si ça fonctionne c'est parce que le compilateur aura pris la liberté de compiler les deux fonctions en "inline", c'est à dire aura placé leur contenu dans la fonction principale.
Ce qui évite en arrière plan, au bas niveau, les CALL et RET... C'est de l'optimisation de code !!!

Par contre, il faut respecter tout ce qui a été dit sur les déclarations globales, locales et la PILE (qui est ici un dispositif de bas niveau... niveau CPU) !