Discussion :

[ded jay]

ce problème m'avait l'air idiot quand je me le suis posé, mais quand j'ai voulu le réaliser, c 'est moi qui avait l'air idiot ...

donc :

Code :

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

1
2
3
4
5
6
 
char tableau [30] [50];
 
char ** pointeur;
 
pointeur = tableau;

passe pas ....

cannot convert 'char (*)[50]' to 'char**'

l'idée étant de passer par un pointeur où je ne suis pas obligé de spécifier le nombre d'éléménts et de pouvoir y acceder

Code :

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

1
2
3
4
 
char * texte = pointeur [5];
 
char car = pointeur [5][10];

j'ai tout essayé ... sauf la bonne réponse (si il y en a une)

[diogene]

Code :

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

1
2
3
char tableau [30] [50];
char ** pointeur; 
pointeur = tableau;

Le type de pointeur ne peut être char ** . Il doit être du type de tableau (à l'évaluation) soit " adresse d'un élément de tableau". Les éléments de tableau sont ici des char[50] et le type de pointeur est alors char (*)[50] (avec les parenthèses : pointeur sur un tableau de 50 char)

Toutefois, utiliser ce type peut présenter des problèmes lors du passage du tableau en argument d'une fonction car alors la fonction est spécialisée pour des char [50] , il y a obligation de spécifier la dimension (50) et on ne peut la changer.
Une autre possibilité est de "voir" le tableau sous une forme à une dimension. Dans cette optique, le tableau est vu comme un char [] et le type de pointeur sera char * , la dimension (50) est passée en argument (et la fonction peut travailler sur des tableaux dont la dimension est quelconque) mais c'est au programmeur de faire explicitement le calcul des indices

Code :

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

1
2
3
4
5
6
7
char tableau [30] [50];
char (*p1)[50] = tableau;
char * pointeur = (char *) tableau; 
....
 
tableau[i][j] <-> p1[i][j]
tableau[i][j] <-> pointeur [ i*50+j]

Enfin, une autre possibilité est de construire ce tableau à partir d'un tableau de pointeur sur char : char *[30], chaque pointeur contenant l'adresse d'un sous- tableau char [50]. Il n'intervient plus alors que des tableaux à une dimension. Le type de pointeur serait alors char ** et on peut accéder aux éléments comme d'habitude par pointeur [ i][j].

Code :

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

1
2
3
4
5
6
7
char tab[30*50];
char *tableau[30];
char ** pointeur = tableau;
for(i=0;i<30;i++) tableau[i] = tab+i*50;
.....
tableau[i][j] = ...; // ou
pointeur[i][j] = ...;

Voir la FAQ pour plus de détails.

[souviron34]

Enfin, une autre possibilité est de construire ce tableau à partir d'un tableau de pointeur sur char : char *[30], ....

Une autre possibilité est de construire un tableau à partir d'un tableau de pointeur sur char....

Code :

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

1
2
3
4
5
6
7
8
9
10
11
char **Tableau ;
 
Tableau = malloc ( 30*sizeof(char*) );
....
for ( i = 0 ; i < 30 ; i++ )
    Tableau[i] = malloc ( 50 ) ;
 
Tableau[i][j] = ....
...
strcpy ( Tableau[i], "..." );
...

[ded jay]

impeccable

ca c'est de la réponse comme je les aime

[ded jay]

par contre, j'ai un autre problème maintenant ...

comment on créer une fonction qui renvoi ce tableau ?

[souviron34]

Procède logiquement :

Comment créer une fonction qui renvoie un entier ?

2 possibilités :

Code :

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

int Fonction ( .. )

ou bien

Code :

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

void Fonction ( .... , int *toto )

Donc .....

A toi d'essayer... Pour apprendre c'est mieux...

Note : une indication : en général dans ce cas, la 2ième forme est la plus utilisée...

[ded jay]

je voudrais plutot une fonction qui me retourne le pointeur
pour faire

Code :

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

1
2
 
char (*pointeur) [50] = getTableau ();

le prob, c'est que je ne sais pas comment déclarer la fonction getTableau ()

[souviron34]

pas très pratique....

Mais les 2 solutions sont :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
int Fonction ( ..... , char ***Tableau )
{
....
 
*Tableau = malloc ( 30*sizeof(char*) );
....
for ( i = 0 ; i < 30 ; i++ )
    (*Tableau)[i] = malloc ( 50 ) ;
 
 
  return statut ;
}

où statut sera erreur si allocation échoue et succès si ça a marché.

ou bien

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
char **Fonction ( ..... )
{
  char **Tableau ;
....
 
 Tableau = malloc ( 30*sizeof(char*) );
....
for ( i = 0 ; i < 30 ; i++ )
     Tableau[i] = malloc ( 50 ) ;
 
 
  return Tableau ;
}

Et je dis que dans le cas des tableaux dans le style (2D, 3D, ND), en général la forme la plus courante est la première...

[ded jay]

en fait c'est du c++ que je fait

et donc

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
 
class Machin
 {
 private :
  char tableau [30][50];
 
 public :
  char ** getTableau ();
 };
 
//avec
 
char ** Machin::getTableau ()
 {
 return tableau;
 }

cannot convert 'char (*)[50]' to 'char**'

[souviron34]

en fait c'est du c++ que je fait

ben à ce compte-là fallait aller sur C++


Mais sinon prend la 1ière solution...

Et d'autre part je ne crois pas que le compilo accepte que tu fasses

char[30][50] = char**

mais plutôt char[][]

mais dans ce cas ça ne passera pas en retour de fonction...

Encore une fois

Code :

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

int getTableau ( char ***tableau )

[poukill]

Procède logiquement :

Comment créer une fonction qui renvoie un entier ?

2 possibilités :

En fait : 3 possibilités!

En C++, il ne faut pas oublier le passage par référence...
qui est mieux qu'un pointeur quand on peut l'utiliser

Code :

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

1
2
3
4
void Fonction ( .... , int &toto )
{
   toto = 3;
}

[loufoque]

Modifier des arguments passés par référence (ou par pointeur) c'est quand même une pratique à éviter à mon avis -- cela a cependant du sens dans certains cas.

[ded jay]

donc,

je suis obligé de passer un pointeur en parametre de la fonction ?

je peu pas retourner simplement l'adresse de mon tableau ?

[r0d]

Non, tu n'es pas obligé, mais c'est tout de même la meilleure solution. Cela te permetra d'éviter automatiquement certains écueils, et puis ça te permet également une gestion d'erreur plus simple: chaque fonction retourne un code d'erreur (un int typiquement).

Ensuite, il y a un point à prendre en compte: le scope de la variable. Ici il s'git d'un tableau. On pourrait dire ça autrement: où va-t-il être alloué et détuit?

Si ta fonction retourne un pointeur sur le tableau, cela signifie que c'est elle qui va l'allouer. Et cela signifie aussi que ce n'est pas elle qui va le détruire. D'un point de vue 'conception', ce n'est pas terrible (bien que j'avoue que cela puisse être nécessaire). L'avantage avec le passage par référence (en paramètre de ta fonction), c'est que tu peux faire en sorte que le bloc qui va appeler cette fonction soit "entièrement propriétaire" de ton tableau.

[diogene]

Pour répondre spécifiquement au post #9, la situation n'a pas changé par rapport aux réponses du post #2 (y compris les contraintes sur la dimension 50). Par conséquent, on aurait :

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
class Machin
 {
 private :
  char tableau [30][50];
 public :
  char (*getTableau ())[50];
 };
 
//avec
 
char (*Machin::getTableau ())[50]
 {
 return tableau;
 }
....
class Machin m;
 char (*p)[50] = m.getTableau();

ou pour alléger l'écriture lourdingue des déclarations de fonctions :

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
typedef   char (*pTableau)[50];
class Machin
 {
 private :
  char tableau [30][50];
 
 public :
  pTableau getTableau ();
 };
 
//avec
 
pTableau Machin::getTableau ()
 {
 return tableau;
 }
.....
class Machin m;
 pTableau p = m.getTableau();

[loufoque]

Non, tu n'es pas obligé, mais c'est tout de même la meilleure solution. Cela te permetra d'éviter automatiquement certains écueils

Si une fonction doit produire un résultat, ce résultat doit être retourné.
Modifier une variable passée en argument pour fournir un résultat est souvent une mauvaise conception.
Il est mieux de faire en sorte que la fonction n'ait pas d'effet de bord d'un point de vue de l'état mémoire de ses paramètres (sauf s'il s'agit d'une fonction de transfert de ressources). C'est en partie pour ça qu'on préfère mettre des const partout.

et puis ça te permet également une gestion d'erreur plus simple: chaque fonction retourne un code d'erreur (un int typiquement).

En C++ on utilise les exceptions.

Bon, reprenons donc ce sujet. Que cherches-tu exactement ?
Déjà, construis ta structure de données avec les bons outils. Tu veux un tableau à deux dimensions ou un tableau de pointeurs vers des tableaux alloués dynamiquement ? Dans le deuxième cas, utilise un tableau de std::vector<char>, ou de std::string puisque ça a l'air d'être des chaînes de caractères.
Tu veux pouvoir retourner ton tableau par valeur ? Remplace ton tableau par un boost::array, qui est la même chose, mais copiable.

[ded jay]

merci pour tout

la réponse de diogene convient parfaitement a ce que je veux faire