[debutant] créer une constante tableau

**Franck.H** · 29/08/2006, 14h29

Envoyé par Emcy

=> un man c'est quoi (un manuel) ?

Bin si tu est sous Linux, dans ta console tape man et le nom de la fonction, appel système ou autre documentation d'un programme ... à condition d'avoir installé les doc et qu'elles soient sous ce format !

Sinon il existe une page de manuel ici: http://man.developpez.com/

**Emcy** · 29/08/2006, 14h57

d'accord, merci

maintenant j'ai un autre probleme.

j'ai declaré ma variable tableau comme ceci dans mon programme principale :

Code :

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

1
2
3
4
5
6
7
const int 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}}; // initialisation

=> j'ai pas de probleme de compilation.

après pour structurer mon programme, j'ai voulu mettre ce bout de code dans un nouveau fichier "afficheur.c" que j'ai ajouté au projet mais ça ne marche plus (dans le programme principale, j'ai fait un #include "afficheur.c" mais à priori c'est un fichier en .h qu'il faut mettre.
=> j'ai le message : P1: Error (199) - Cannot open include file: afficheur.c

**Franck.H** · 29/08/2006, 15h00

Envoyé par Emcy

après pour structurer mon programme, j'ai voulu mettre ce bout de code dans un nouveau fichier "afficheur.c" que j'ai ajouté au projet mais ça ne marche plus (dans le programme principale, j'ai fait un #include "afficheur.c" mais à priori c'est un fichier en .h qu'il faut mettre.

On n'inclu que des header (fichier d'entête - *.h) pas de fichier source, faut arrêter de faire des bétises ! Ce que tu peux faire si tu veux que le tableau soit rendu public, c'est de le déclarer extern mais c'est peu recommandé d'utiliser des variables globales !

Maintenant, si ton tableau n'est utilisé que par un seul module, tu peux le mettre en privé (static) dans le fichier source qui l'utilise !

**Emcy** · 29/08/2006, 15h43

Excusez-moi pour toutes ces confusions mais je debute.

Je vais essayer d'expliquer clairement mon appli :
J'ai un micro-controlleur qui est relié à un afficheur (5x7).

Donc, je voulais créer mes tableaux de references (TabA, ..., TabZ) qui indiquent les LEDs qui doivent être éclairés suivant la lettre qu'on veut afficher A,...,Z.

Après, je voulais faire une fonction qui ait en paramêtre un "char" (la lettre que je veux afficher) et qui renvoie un Tableau (le tableau de la lettre correspondante) => mais pour gagner de l'espace memoire et de la vitesse, j'aimerais pas faire une copie du tableau mais pointer l'emplacement memoire des tableaux.
=> je voudrais que tout ça soit dans un fichier .c independant

comment ferriez-vous ?

**homeostasie** · 29/08/2006, 15h45

Juste comme cela, j'ai voulu faire un memcpy du tableau 2D dans un tableau dynamique et j'obtiens une erreur de segmentation quand je passe dans ma boucle de memcpy, savez ou est le problème?

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
#define N 7
#define M 5
 
static const int 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}};
 
int main(int argc, char *argv[])
{
  int i = 0, j = 0;
  bool **tab;
 
  /* Allocation de la 1er dimension */
  tab = malloc ( sizeof(*tab)  *  N);
  /* Allocation des tableaux */
  for (i = 0; i<M; i++)
  {
      tab[i] = malloc ( sizeof(**tab) * M);
  }
 
  memcpy(tab,TabZ,(N*sizeof(*tab)));
  for (i = 0; i < M; i++)
  {
      memcpy(tab[i],TabZ[i], (sizeof(**tab) * M));
  }
}

Merci

**homeostasie** · 29/08/2006, 15h53

Après, je voulais faire une fonction qui ait en paramêtre un "char" (la lettre que je veux afficher) et qui renvoie un Tableau (le tableau de la lettre correspondante) => mais pour gagner de l'espace memoire et de la vitesse, j'aimerais pas faire une copie du tableau mais pointer l'emplacement memoire des tableaux.

Tu vas devoir utiliser un pointeur sur ton tableau comme paramètre d'entrée dans ta fonction d'appel. Ainsi tu pourras le modifier à ta guise selon le caractère passé. Pourquoi pas utiliser des "case" pour détecter ton char, et ensuite remplir ton tableau en fonction du caractère.
C'est une solution, peut être est elle lourde....

**Emmanuel Delahaye** · 29/08/2006, 16h00

Envoyé par Emcy

mais à priori, ça fait bien une copie :
http://www.linux-kheops.com/doc/man/.../memcpy.3.html

comment faire alors pour que ça ne prenne pas plus de memoire (si c'est possible)?

La fonction recopie exactement le nombre de bytes du tableau. Utilise sizeof.

Code :

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

1
2
 
   memcpy(t_dest, t_src, sizeof t_dest);

**Emmanuel Delahaye** · 29/08/2006, 16h06

Envoyé par Emcy

d'accord, merci

maintenant j'ai un autre probleme.

j'ai declaré ma variable tableau comme ceci dans mon programme principale :

Code :

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

1
2
3
4
5
6
7
const int 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}}; // initialisation

=> j'ai pas de probleme de compilation.

après pour structurer mon programme, j'ai voulu mettre ce bout de code dans un nouveau fichier "afficheur.c" que j'ai ajouté au projet mais ça ne marche plus (dans le programme principale, j'ai fait un #include "afficheur.c" mais à priori c'est un fichier en .h qu'il faut mettre.
=> j'ai le message : P1: Error (199) - Cannot open include file: afficheur.c

Il ne faut pas inclure de .c. Les objets (aka variables) et fonctions doivent être définis de façon uniques dans un .c. Ensuite, il existe des mécanismes de déclaration, comme le mot-clé extern utiisé pour les objets, qui permettent d'utiliser un objet n'importe-où. C'est un peu crade, mais ça fonctionne.

http://emmanuel-delahaye.developpez....s.htm#globales

Par exmple :

Code :

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

extern const int TabZ[7][5];

**gege2061** · 29/08/2006, 16h10

Envoyé par Emcy

comment ferriez-vous ?

Tout simplement :

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
#include <stdio.h>
 
#define tab_from_char(c) Tab##c
 
static const int 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}};
 
int main(void)
{
  int i;
  int j;
  const int (*tab)[7][5] = tab_from_char (Z);
 
  for (i = 0; i < 7; i++)
  {
    for (j = 0; j < 5; j++)
    {
      printf ("%d", (*tab)[i][j]);
    }
    printf ("\n");
  }
  return 0;
}

Temps de recherche du tableau correspondant à la lettre nul, c'est le préprocesseur qui s'en charge ! Pas de mémoire supplémentaire alloué, tu utilise un pointeur sur le tableau static !
Reste plus qu'a créer les tableaux TabA...TabY

Bon courrage

**Emmanuel Delahaye** · 29/08/2006, 16h12

Envoyé par Emcy

Après, je voulais faire une fonction qui ait en paramêtre un "char" (la lettre que je veux afficher) et qui renvoie un Tableau (le tableau de la lettre correspondante) => mais pour gagner de l'espace memoire et de la vitesse, j'aimerais pas faire une copie du tableau mais pointer l'emplacement memoire des tableaux.

Ah, c'est autre chose. Tu ne veux pas faire de copie. Oublie memcpy(). Tu veux simplement rendre le tableau accessible en lecture par tes fonctions. il suffit de passer l'adresse du premier élément du tableau (son nom, en fait) via un pointeur de ce type :

Code :

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

int const p[5][7]

et les données du tableau seront accessibles en lecture

http://emmanuel-delahaye.developpez.....htm#param_tab

**Emcy** · 29/08/2006, 16h13

Envoyé par homeostasie

Tu vas devoir utiliser un pointeur sur ton tableau comme paramètre d'entrée dans ta fonction d'appel. Ainsi tu pourras le modifier à ta guise selon le caractère passé. Pourquoi pas utiliser des "case" pour détecter ton char, et ensuite remplir ton tableau en fonction du caractère.
C'est une solution, peut être est elle lourde....

=> c'est ce que j'essaye de faire

**Emmanuel Delahaye** · 29/08/2006, 16h15

Envoyé par homeostasie

Code :

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

1
2
3
4
5
6
7
8
9
10
  /* Allocation de la 1er dimension */
  tab = malloc ( sizeof(*tab)  *  N);
  /* Allocation des tableaux */
  for (i = 0; i<M; i++)
  {
      tab[i] = malloc ( sizeof(**tab) * M);
  }
 
  memcpy(tab,TabZ,(N*sizeof(*tab)));
}

Merci

Tu fais n'importe quoi... Tu as écrasé les adresses de tous les blocs que tu as alloué (tab)...

Il ne faut pas utiliser memcpy dans ce cas là...

**Pragmateek** · 29/08/2006, 16h22

Juste comme cela, j'ai voulu faire un memcpy du tableau 2D dans un tableau dynamique et j'obtiens une erreur de segmentation quand je passe dans ma boucle de memcpy, savez ou est le problème?

Ceci à l'air de fonctionner:

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
#define N 7
#define M 5
 
void f(bool**p){
     for(int i=0;i<N;i++){
             for(int j=0;j<M;j++){
                     printf("%d ",p[i][j]);
                     }
                     printf("\n");
                     }
                     }
 
static const bool 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}};
 
int main(int argc, char *argv[])
{
  int i = 0, j = 0;
  bool **tab;
 
  /* Allocation de la 1er dimension */
  tab = malloc ( sizeof(*tab)  *  N);
  /* Allocation des tableaux */
  for (i = 0; i<N; i++)
  {
      tab[i] = malloc ( sizeof(**tab) * M);
  }
 
  //memcpy(tab,TabZ,(N*sizeof(*tab)));
  for (i = 0; i < N; i++)
  {
      memcpy(tab[i],TabZ[i], (sizeof(**tab) * M));
  }
f(tab);

**Emcy** · 29/08/2006, 16h23

Envoyé par gege2061

Tout simplement :

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
#include <stdio.h>
 
#define tab_from_char(c) Tab##c
 
static const int 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}};
 
int main(void)
{
  int i;
  int j;
  const int (*tab)[7][5] = tab_from_char (Z);
 
  for (i = 0; i < 7; i++)
  {
    for (j = 0; j < 5; j++)
    {
      printf ("%d", (*tab)[i][j]);
    }
    printf ("\n");
  }
  return 0;
}

Temps de recherche du tableau correspondant à la lettre nul, c'est le préprocesseur qui s'en charge ! Pas de mémoire supplémentaire alloué, tu utilise un pointeur sur le tableau static !
Reste plus qu'a créer les tableaux TabA...TabY

Bon courrage

je comprends pas trop ce que fait cette ligne :
#define tab_from_char(c) Tab##c

**homeostasie** · 29/08/2006, 16h28

Code :

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

memcpy(tab,TabZ,(N*sizeof(*tab)));

Tu fais n'importe quoi... Tu as écrasé les adresses de tous les blocs que tu as alloué (tab)...

Ouhla, oui en effet....

**gege2061** · 29/08/2006, 16h32

Envoyé par Emcy

je comprends pas trop ce que fait cette ligne :
#define tab_from_char(c) Tab##c

C'est l'opérateur ## du préprocesseur qui concataine ses deux opérandes : ici Tab et c. c est l'argument passé à la macro donc quand tu écrit :

Code :

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

tab_from_char (Z)

C'est remplacé par :

Code :

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

Tab##Z

Et ensuite :

Code :

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

TabZ

Le seul problème c'est que tu ne peux pas utiliser de caractère ou de chaine de caractère :

Code :

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

1
2
3
tab_from_char ('Z')
/* ou */
tab_from_char ("Z")

N'est pas possible

**homeostasie** · 29/08/2006, 16h56

Temps de recherche du tableau correspondant à la lettre nul, c'est le préprocesseur qui s'en charge ! Pas de mémoire supplémentaire alloué, tu utilise un pointeur sur le tableau static !
Reste plus qu'a créer les tableaux TabA...TabY

En fait ici, on privéligie la rapidité à la mémoire, non?
Car obligation de définir en static les 26 tableaux.
L'utilisation des "cases", ralentit l'application au niveau temps de recherche mais me parait moins riche en mémoire, même si le nombre de ligne de code est accrue et va donc enrichir le segment text du system image.

Mais ta méthode proposée me semble bien plus agréable à lire en tout cas.

**Emcy** · 29/08/2006, 17h10

Envoyé par gege2061

C'est l'opérateur ## du préprocesseur qui concataine ses deux opérandes : ici Tab et c. c est l'argument passé à la macro donc quand tu écrit :

Code :

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

tab_from_char (Z)

C'est remplacé par :

Code :

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

Tab##Z

Et ensuite :

Code :

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

TabZ

Le seul problème c'est que tu ne peux pas utiliser de caractère ou de chaine de caractère :

Code :

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

1
2
3
tab_from_char ('Z')
/* ou */
tab_from_char ("Z")

N'est pas possible

=> d'accord donc si j'ai bien compris ma fonction doit ressembler à ça , non ?

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

**homeostasie** · 29/08/2006, 17h19

d'accord donc si j'ai bien compris ma fonction doit ressembler à ça , non ?

A moins que j'ai mal compris, ca ne doit pas ressembler à cela, tu ne dois pas utiliser de "case" puisque la variable de ton tableau sera celle fourni par la macro:

Code :

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

#define tab_from_char(c) Tab##c

Faut que tu récupères le caractère de l'alphabet, t'appelles la macro et tu vas pointer ensuite sur le résultat de la macro, c'est à dire le tableau correspondant à la lettre à afficher.

**gege2061** · 29/08/2006, 17h48

Envoyé par Emcy

=> d'accord donc si j'ai bien compris ma fonction doit ressembler à ça , non ?

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;
}

[debutant] créer une constante tableau

C

Discussions similaires

Partager

Partager