[debutant] créer une constante tableau

**homeostasie** · 29/08/2006, 18h03

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
tab_lettre_t *PointeurTableau(char MyChar)
{
  tab_lettre_t *tab = NULL;
 
  switch (MyChar)
  {
    case 'Z':
      tab = &TabZ;
    break;
  }
  return tab;
}

Au lieu des "cases", il n'est donc pas possible de faire un truc comme cela:

Code :

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

1
2
3
4
5
6
7
8
tab_lettre_t *PointeurTableau(char MyChar)
{
  tab_lettre_t *tab = NULL;
 
  tab = &tab_from_char(MyChar);
 
  return tab;
}

J'ai raté ton message de tout à l'heure concernant l'utilisation de ta macro avec les char ou les chaines de caractères.
En fait, cette macro ne fonctionne qu'avec des entiers alors?

**gege2061** · 29/08/2006, 18h55

Envoyé par homeostasie

J'ai raté ton message de tout à l'heure concernant l'utilisation de ta macro avec les char ou les chaines de caractères.
En fait, cette macro ne fonctionne qu'avec des entiers alors?

Non elle concataine ce que tu veux mais si tu fait :

Code :

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

tab_from_char ('A');

Tu obtients :

Code :

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

Tab'A'

Ce qui n'est pas permis pour un nom de variable

**Emcy** · 30/08/2006, 08h28

Envoyé par gege2061

Oui mais ce que je t'ai donné n'est pas vraiment utile si tu doit obligatoirement passé par des caractères :

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
#include <stdio.h>
 
typedef const int tab_lettre_t[7][5];
 
static tab_lettre_t TabZ = {{1,1,1,1,1},
                            {0,0,0,0,1},
                            {0,0,0,1,0},
                            {0,0,1,0,0},
		                    {0,1,0,0,0},
                            {1,0,0,0,0},
                            {1,1,1,1,1}};
 
tab_lettre_t *PointeurTableau(char MyChar)
{
  tab_lettre_t *tab = NULL;
 
  switch (MyChar)
  {
    case 'Z':
      tab = &TabZ;
    break;
  }
  return tab;
}
 
int main (void)
{
  int i;
  int j;
  tab_lettre_t *tab;
 
  tab = PointeurTableau ('Z');
 
  for (i = 0; i < 7; i++)
  {
    for (j = 0; j < 5; j++)
    {
      printf ("%d", (*tab)[i][j]);
    }
    printf ("\n");
  }
  return 0;
}

=> merci.

maintenant la dernière etape : comment je fais pour que ma fonction soit dans un fichier .c independant ?

quand on defini le tableau en static, on va bien chercher les valeurs directement dans la structure du programe (on ne fait pas de copie des valeurs dans la memoire ?) ?

**Emmanuel Delahaye** · 30/08/2006, 09h56

Envoyé par Emcy

maintenant la dernière etape : comment je fais pour que ma fonction soit dans un fichier .c independant ?

Tu crées un header (.h) avec le prototype des fonctions publiques (aka exportées) et le headers ou définitions nécessaires.
Tu crées un fichier .c.
Tu inclues le header nouvellement crée en premier.
Tu ajoutes les fonctions,
Tu inclues les headers nécessaires pour ces fonctions,
Dans les fichiers qui utilisent ces fonctions, tu inclus le header nouvelement crée.

http://emmanuel-delahaye.developpez.com/codage.htm

quand on defini le tableau en static, on va bien chercher les valeurs directement dans la structure du programe (on ne fait pas de copie des valeurs dans la memoire ?) ?

C'est pas très clair ce que tu dis.

Une tableau static est défini en mémoire statique. Il prend de la place en mémoire de façon permanente.

Si on ajoute le qualificateur const, le compilateur est autorisé à placer le tableau en zone non modifiable, ce qui, en embarqué 'simple' (pas ou peu de système), peut signifier "mémoire code" (PROM, Flash etc.). Il n'y aura, en principe, pas de recopie de cette zone mémoire, et l'accès se fera directement dans la zone de code.

Pour savoir ce qui se passe exactement, consulter le 'mapping' généré par le linker.

Evidemment, en embarqué évolué (PsOS, Linux etc.), on raisonne autrement, et le code est généralement recopié et mappé en RAM.

**gege2061** · 30/08/2006, 09h59

Envoyé par Emcy

maintenant la dernière etape : comment je fais pour que ma fonction soit dans un fichier .c independant ?

Comment bien organiser son développement

Envoyé par Emcy

quand on defini le tableau en static, on va bien chercher les valeurs directement dans la structure du programe (on ne fait pas de copie des valeurs dans la memoire ?) ?

Tu confond deux choses : le programme est sauvegardé sur le disque sous forme de fichier qui contient le code et les données statiques. Lorsque tu exécute le programme, le système le charge en mémoire donc ton tableau statique sera aussi chargé en mémoire.

**Emmanuel Delahaye** · 30/08/2006, 10h06

Envoyé par gege2061

Lorsque tu exécute le programme, le système le charge en mémoire donc ton tableau statique sera aussi chargé en mémoire.

Pas en embarqué 'simple'...

**Emcy** · 30/08/2006, 10h15

Envoyé par gege2061

Tu confond deux choses : le programme est sauvegardé sur le disque sous forme de fichier qui contient le code et les données statiques. Lorsque tu exécute le programme, le système le charge en mémoire donc ton tableau statique sera aussi chargé en mémoire.

=> je travaille sur micro-controlleur donc je n'ai pas de disque dure (juste 4KB SRAM + 64KB flash). Emmanuel à l'air de dire qu'il n'y a pas de recopie pour mon cas...

mais sur un PC, comment fait-on pour travailler directement sur le disque dure (sans passer par la RAM) ? c'est possible ?

**Emmanuel Delahaye** · 30/08/2006, 10h18

Envoyé par Emcy

mais sur un PC, comment fait-on pour travailler directement sur le disque dur (sans passer par la RAM) ? c'est possible ?

Non.

**hegros** · 30/08/2006, 10h22

Sous PC le disque est plutot utilisé comme espace de stockage ou pour faire du swapping.Les variables utilisées dans un programme ne sont pas chargé sur disque mais bien en RAM.

Pour l'embarqué je pensais bien que c'était pareil.En tout cas pour les API(automate programmable industriel) les variables sont bien chargées en RAM...

Emmanuel tu peux nous en dire plus quand tu dis pas en embarqué simple parce que là j'avoue ne pas comprendre

**Emmanuel Delahaye** · 30/08/2006, 10h30

Envoyé par hegros

Pour l'embarqué je pensais bien que c'était pareil.En tout cas pour les API(automate programmable industriel) les variables sont bien chargées en RAM...

Emmanuel tu peux nous en dire plus quand tu dis pas en embarqué simple parce que là j'avoue ne pas comprendre

Contrairement aux PC, il y a des dizaines (le mot est faible) d'architectures possibles en embarquée. Certaines sont très élémentaires (PIC, 8051, voire x86 : les premiers PC etc.). Dans ce cas, les données 'const' (chaines, tableaux initialisées etc.) sont mappées dans la ROM (PROM, Flash). L'accès est direct en ROM (comme pour le code).

Sur des architectures plus évoluées (68k etc.), on recopie la ROM en RAM (Obligé pour pouvoir modifier les vecteurs d'interruptions). Il faut donc plus de RAM...

**Emcy** · 30/08/2006, 10h36

Envoyé par gege2061

Comment bien organiser son développement

=> je ne comprends pas trop le ficiher .h

Code :

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

1
2
3
4
5
6
7
8
#ifndef H_HELLO
#define H_HELLO
 
/* hello.h */
 
void hello (void);
 
#endif /* guard */

=> H_HELLO, ça sort d'ou ?

Pour la memoire : il me semble que quand il n'y a pas assez de memoire RAM, on peut utiliser le disque dure => comment on fait ? c'est fait automatiquement ?

**gege2061** · 30/08/2006, 10h45

Envoyé par Emmanuel Delahaye

Contrairement aux PC, il y a des dizaines (le mot est faible) d'architectures possibles en embarquée. Certaines sont très élémentaires (PIC, 8051, voire x86 : les premiers PC etc.). Dans ce cas, les données 'const' (chaines, tableaux initialisées etc.) sont mappées dans la ROM (PROM, Flash). L'accès est direct en ROM (comme pour le code).

Sur des architectures plus évoluées (68k etc.), on recopie la ROM en RAM (Obligé pour pouvoir modifier les vecteurs d'interruptions). Il faut donc plus de RAM...

Ok, mais la ROM c'est tout de même de la mémoire (en lecture seul).

Envoyé par Emcy

=> H_HELLO, ça sort d'ou ?

C'est expliqué dans le paragraphe au dessus

Envoyé par Emcy

Pour la memoire : il me semble que quand il n'y a pas assez de memoire RAM, on peut utiliser le disque dure => comment on fait ? c'est fait automatiquement ?

C'est un mécanisme mis en place dans l'OS mais de toute façon le processeur ne lit pas ses intructions sur le disque dur, ce n'est pas (encore) possible et de toute façon le temps de réponse est trop long pour que ça serve à queque chose.

**homeostasie** · 30/08/2006, 10h49

Pour la memoire : il me semble que quand il n'y a pas assez de memoire RAM, on peut utiliser le disque dure => comment on fait ? c'est fait automatiquement ?

LA mémoire RAM est la mémoire centrale de la machine, elle contient le système et les processus.

Le disque dur est une mémoire dite de masse pour stocker des informations. Puis seules des portions de disque sont impliquées dans la gestion de la mémoire centrale.

La mémoire cache ou anté mémoire, présente notamment sur les cartes CPU, est plus rapide et augmente la puissance de traitement par anticipation sur les intructions et les données.

Sur des architectures plus évoluées (68k etc.), on recopie la ROM en RAM (Obligé pour pouvoir modifier les vecteurs d'interruptions). Il faut donc plus de RAM...

Ca ne serait pas le swapping en opposition à la pagination dans les deux manières de gérer la mémoire?

**Emmanuel Delahaye** · 30/08/2006, 10h51

Envoyé par Emcy

=> je ne comprends pas trop le ficiher .h

Code :

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

1
2
3
4
5
6
7
8
#ifndef H_HELLO
#define H_HELLO
 
/* hello.h */
 
void hello (void);
 
#endif /* guard */

=> H_HELLO, ça sort d'ou ?

Tu es censé connaitre les directives du préprocesseur (sinon, relis ton livre de C).

C'est un identificateur, censé être unique dans l'univers, qui sert à protéger contre les inclusions multiples d'un header dans la même unité de compilation.

Si il n'est pas encore défini, il est alors défini (#define) et la suite du header est incluse.

Si il est déja défini (par exemple, on l'inclue une deuxième fois dans la même unité decompilation, ça peut arriver dans une application un peu complexe avec beaucoup de headers), la suite du header (entre #ifdef et #endif) n'est pas inclue. Ca évite bien des problèmes (définitions multiples, inclusion infinie...)

Ce mécanisme de protection est mis en oeuvre dans tous les .h de ton implémentation.

Tu remarqueras que, conformément à la définition du langage C, les identificateurs de l'implémentation commencent par _, ce qui est interdit pour les identificateurs de l'application.

Pour la memoire : il me semble que quand il n'y a pas assez de memoire RAM, on peut utiliser le disque dure => comment on fait ? c'est fait automatiquement ?

Oui, par le système (swapping).

**Emcy** · 30/08/2006, 12h42

d'accord, merci (cette fois ça va bientot être bon)

Dans mon fichier principale "main.c" j'ai :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <ez8.h>
#include <stdio.h>
#include <sio.h> // non-standard I/O
#include "main.h"
#include "afficheur.h"
#include "timer.h"
#include "test_button.h"
#include "uart.h"
 
void main ()
{   
	MyMain();
}

Dans mon module "afficheur.c", j'ai :

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
#include "afficheur.h"
#include <stdio.h>

typedef const int TypeTableau[7][5];

static const TypeTableau TabA[7][5] = {{0,1,1,1,0},
                               		   {1,0,0,0,1},
                               		   {1,0,0,0,1},
                               		   {1,1,1,1,1},
		                       		   {1,0,0,0,1},
                               		   {1,0,0,0,1},
                               		   {1,0,0,0,1}};

static const TypeTableau TabZ[7][5] = {{1,1,1,1,1},
                               		   {0,0,0,0,1},
                              		   {0,0,0,1,0},
                               		   {0,0,1,0,0},
		                       		   {0,1,0,0,0},
                               		   {1,0,0,0,0},
                               		   {1,1,1,1,1}};

TypeTableau *RenvoieTableau(char MyChar)
{	
	
	TypeTableau *PtTab = NULL;

	switch(MyChar)
	{
	 case 'A':      
		PtTab = &TabA;
	    break;
	 case 'Z':				
		PtTab = &TabZ;
		break;
	}
}


int MyMain(void)
{
  int i;
  int j;
  TypeTableau *PtTab;
  
  PtTab = RenvoieTableau('A');
	
  for (i = 0; i < 7; i++)
  {
    for (j = 0; j < 5; j++)
    {
      printf ("%d", (*tab)[i][j]);
    }
    printf ("\n");
  }
  return 0;
}

dans le fichier "afficher.h", j'ai :

Code :

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

1
2
3
4
5
#ifndef TOTO
#define TOTO	
	TypeTableau *RenvoieTableau(char MyChar);
	int MyMain (void);
#endif

=> j'ai des erreurs sur les lignes en rouge

**Emmanuel Delahaye** · 30/08/2006, 17h16

Envoyé par Emcy

=> j'ai des erreurs sur les lignes en rouge

Ceci compile et fonctionne. Pose des questions si tu ne comprends pas.

EDIT

Code :

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

1
2
3
4
5
6
7
8
9
10
 
/* main.c */
 
#include "afficher.h" /* EDIT */
 
int main ()
{
   MyMain();
   return 0;
}

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#ifndef H_AFFICHER
#define H_AFFICHER
 
/* afficher.h */
 
typedef const int TypeTableau[7][5];
 
TypeTableau *RenvoieTableau(int MyChar);
int MyMain (void);
 
#endif

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
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
 
/* afficher.c */
 
#include "afficher.h" /* EDIT */
#include <stdio.h>
static const TypeTableau TabA =
   {
      {
         0, 1, 1, 1, 0
      }
      ,
      {
         1, 0, 0, 0, 1
      }
      ,
      {
         1, 0, 0, 0, 1
      }
      ,
      {
         1, 1, 1, 1, 1
      }
      ,
      {
         1, 0, 0, 0, 1
      }
      ,
      {
         1, 0, 0, 0, 1
      }
      ,
      {
         1, 0, 0, 0, 1
      }
   }
   ;
static const TypeTableau TabZ =
   {
      {
         1, 1, 1, 1, 1
      }
      ,
      {
         0, 0, 0, 0, 1
      }
 
      ,
      {
         0, 0, 0, 1, 0
      }
      ,
      {
         0, 0, 1, 0, 0
      }
      ,
      {
         0, 1, 0, 0, 0
      }
      ,
      {
         1, 0, 0, 0, 0
      }
      ,
      {
         1, 1, 1, 1, 1
      }
   }
   ;
 
TypeTableau *RenvoieTableau(int MyChar)
{
   TypeTableau *PtTab = NULL;
   switch (MyChar)
   {
   case 'A':
      PtTab = &TabA;
      break;
   case 'Z':
      PtTab = &TabZ;
      break;
   }
   return PtTab;
}
 
int MyMain(void)
{
   int i;
   TypeTableau *PtTab = RenvoieTableau('A');
   for (i = 0; i < 7; i++)
   {
      int j;
      for (j = 0; j < 5; j++)
      {
         printf ("%d", (*PtTab)[i][j]);
      }
      printf ("\n");
   }
   return 0;
}

**Emcy** · 31/08/2006, 08h28

merci, mais j'ai un probleme

j'ai les message :
C:\PROGRA~1\ZILOG\ZDSII_~1.0\SAMPLES\Z8F640~1\SRC\AFFICHEUR.C (6,30) : ERROR (121) Illegal declaration specifier

C:\PROGRA~1\ZILOG\ZDSII_~1.0\SAMPLES\Z8F640~1\SRC\AFFICHEUR.C (15,6) : ERROR (181) Too many initializers for object

=> l'erreur est sur les lignes de declaration :
static const TypeTableau TabA =
static const TypeTableau TabZ =

Et pourquoi MyChar est un int ?

**homeostasie** · 31/08/2006, 10h01

merci, mais j'ai un probleme

J'ai essayé chez moi le code fournit par Emmanuel et çà marche très bien...

Et pourquoi MyChar est un int ?

Un char, un int sont en fait tout les deux des entiers en C. Ce qui les différencie, c'est le nombre de bits pour le type, définit selon l'implémentation.
Un char a au minimum 8 bits.
Un integer doit être dans une plage de valeur minimale de -32767 à 32767.

J'ai deux questions:

Code :

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

1
2
 
typedef const int TypeTableau[7][5];

Pourquoi ici faire un typedef? Serais ce pour spécifier que TypeTableau a deux dimension de profondeur 7 et 5, sera constant et de type int?

Code :

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

static const TypeTableau TabZ =

Pourquoi respécifier que TypeTableau est "const"?

**Emmanuel Delahaye** · 31/08/2006, 10h02

Envoyé par Emcy

merci, mais j'ai un probleme

j'ai les message :
C:\PROGRA~1\ZILOG\ZDSII_~1.0\SAMPLES\Z8F640~1\SRC\AFFICHEUR.C (6,30) : ERROR (121) Illegal declaration specifier

C:\PROGRA~1\ZILOG\ZDSII_~1.0\SAMPLES\Z8F640~1\SRC\AFFICHEUR.C (15,6) : ERROR (181) Too many initializers for object

=> l'erreur est sur les lignes de declaration :
static const TypeTableau TabA =
static const TypeTableau TabZ =

Petite erreur de ma part : c'est
EDIT (mal réveillé, décidément...)

Code :

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

#include "afficher.h"

désolé. J'ai modifié les fichiers sources.

Code :

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

Et pourquoi MyChar est un int ?

Parce qu'une constante caractère a le type int en C. Ca tombe bien, c'est aussi le type de EOF.

**Emcy** · 31/08/2006, 11h22

Envoyé par Emmanuel Delahaye

Petite erreur de ma part : c'est

Code :

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

#include "afficher.c"

=> non, ça ne dois pas venir de ça : a priori dans mes fichier d'exemples, il faut bien mettre un .h

si j'enleve les lignes en rouge, je n'ai plus d'erreurs de construction du projet

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
/* afficher.c */
#include <ez8.h>
#include <sio.h> // non-standard I/O
#include "afficheur.h"

static const TypeTableau TabA =
   {
      {0, 1, 1, 1, 0},
      {1, 0, 0, 0, 1},
      {1, 0, 0, 0, 1},
      {1, 1, 1, 1, 1},
      {1, 0, 0, 0, 1},
      {1, 0, 0, 0, 1},
      {1, 0, 0, 0, 1}
   };

static const TypeTableau TabZ =
   {
      {1, 1, 1, 1, 1},
      {0, 0, 0, 0, 1},
      {0, 0, 0, 1, 0},
      {0, 0, 1, 0, 0},
      {0, 1, 0, 0, 0},
      {1, 0, 0, 0, 0},
      {1, 0, 0, 0, 1}
   };
   
TypeTableau *RenvoieTableau(int MyChar)
{
   TypeTableau *PtTab = NULL;
   switch (MyChar)
   {
   case 'A':
      PtTab = &TabA;
      break;
   case 'Z':
      PtTab = &TabZ;
      break;
   }
   return PtTab;
}

int MyMain(void)
{
   int i;
   TypeTableau *PtTab = RenvoieTableau('A');
   for (i = 0; i < 7; i++)
   {
      int j;
      for (j = 0; j < 5; j++)
      {
         printf ("%d", (*PtTab)[i][j]);
      }
      printf ("\n");
   }
   return 0;
}

aussi, ce que je trouve de bizzare, c'est que dans le projet d'exemple que j'ai chargé, la definition de tous les prototype sont uniquement dans mon fichier main.h....

[debutant] créer une constante tableau

C

Discussions similaires

Partager

Partager