retour de tableau a plusieurs dimention??

Le
elekis
bonjour, voila je sui amener a manipuler des tableaux a deux dimentions
dans des classes, je ne pige pas ces retours, quelle est la conventions
exacte???

voici le simple code que j'essaie de faire.

planete.cpp
**********************************************
#include<iostream>
#include"salle.h"
using namespace std;

main(){
int A[3][3] = {1,1,1,1,0,1,1,0,1};
salle S1(A);
int T[3][3] = S1.rac();
for(int i=0; i<3; i++)
{
for(int j=0; j<3; j++)
cout << T[i][j];
cout << endl;
}
}
*-*********************************************

class.h
********************************************////
class salle
{
public:
salle(int[3][3]);
int* rac();
private:
int S[3][3];

};
salle::salle(int A[3][3])
{
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
A[3][3]=S[i][j];
}

int** salle::rac()
{
return S;
}
*****************************************************

voici ce que me met le compile comme erreur

elekis@carla:~/Projet-AG1/projet 4$ g++ Palais.cpp salle.h -o Palais
In file included from Palais.cpp:2:
salle.h:18: error: prototype for `int** salle::rac()' does not match any in
class `salle'
salle.h:5: error: candidate is: int* salle::rac()
salle.h:18: error: `int** salle::rac()' and `int* salle::rac()' cannot be
overloaded
salle.h: In member function `int** salle::rac()':
salle.h:19: error: cannot convert `int (*)[3]' to `int**' in return
Palais.cpp: In function `int main()':
Palais.cpp:8: error: invalid initializer
g++: compilation of header file requested
elekis@carla:~/Projet-AG1/projet 4$

qqn pourrait il m'aider dans ces conventions, et comment fiare un retour
de tableau a plusieurs dimmenttion??? merci

a++
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Mystic
Le #722968
Salut,
Je ne pourrai malheuresement pas t apporter de reponse par contre
jai le mm probleme ou plutot la mm question sauf qu il sagit dun tableau
a une dimension et d un tableau de string.
voila ce que je souhaiterai faire en gros mais ca marche pas :)

int ::first()
{
string myAr[2];

myAr = func();
}

string ::func()
{
string ar[2] = {"xXx", "Zone"};

return ar;
}


"elekis" news:408e5676$0$10903$
bonjour, voila je sui amener a manipuler des tableaux a deux dimentions
dans des classes, je ne pige pas ces retours, quelle est la conventions
exacte???

voici le simple code que j'essaie de faire.

planete.cpp
**********************************************
#include<iostream>
#include"salle.h"
using namespace std;

main(){
int A[3][3] = {1,1,1,1,0,1,1,0,1};
salle S1(A);
int T[3][3] = S1.rac();
for(int i=0; i<3; i++)
{
for(int j=0; j<3; j++)
cout << T[i][j];
cout << endl;
}
}
*-*********************************************

class.h
********************************************////
class salle
{
public:
salle(int[3][3]);
int* rac();
private:
int S[3][3];

};
salle::salle(int A[3][3])
{
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
A[3][3]=S[i][j];
}

int** salle::rac()
{
return S;
}
*****************************************************

voici ce que me met le compile comme erreur

:~/Projet-AG1/projet 4$ g++ Palais.cpp salle.h -o Palais
In file included from Palais.cpp:2:
salle.h:18: error: prototype for `int** salle::rac()' does not match any
in

class `salle'
salle.h:5: error: candidate is: int* salle::rac()
salle.h:18: error: `int** salle::rac()' and `int* salle::rac()' cannot be
overloaded
salle.h: In member function `int** salle::rac()':
salle.h:19: error: cannot convert `int (*)[3]' to `int**' in return
Palais.cpp: In function `int main()':
Palais.cpp:8: error: invalid initializer
g++: compilation of header file requested
:~/Projet-AG1/projet 4$

qqn pourrait il m'aider dans ces conventions, et comment fiare un retour
de tableau a plusieurs dimmenttion??? merci

a++



Alexandre
Le #722680
bonjour,


"Mystic" news:c6m2ed$hm5$
Salut,
Je ne pourrai malheuresement pas t apporter de reponse par contre
jai le mm probleme ou plutot la mm question sauf qu il sagit dun tableau
a une dimension et d un tableau de string.
voila ce que je souhaiterai faire en gros mais ca marche pas :)


int ::first()
{
string myAr[2];

myAr = func();
}


où est le retour ? La fonction est sensée renvoyée un int.
De plus, myAr ne peut pas changer d'adresse car c'est un tableau statique.


string ::func()
{
string ar[2] = {"xXx", "Zone"};

return ar;
}


la aussi, erreur. ar est un tableau de string, donc équivalent à un pointeur
sur string, (soit string *) pas string... Le type de retour n'est pas bon
ici.

Une version correcte :
string* func()
{
string ar[2]={"xxx","zo,e"};
return ar;
}

int first()
{
string* pMyAr;
pMyAr = func();

return 0 ; // ?
}

mais je conseille de regarder ce qu'est un vector<> pour la gestion des
tableaux...



"elekis" news:408e5676$0$10903$
bonjour, voila je sui amener a manipuler des tableaux a deux dimentions
dans des classes, je ne pige pas ces retours, quelle est la conventions
exacte???

voici le simple code que j'essaie de faire.

planete.cpp
**********************************************
#include<iostream>
#include"salle.h"
using namespace std;

main(){
int A[3][3] = {1,1,1,1,0,1,1,0,1};
salle S1(A);
int T[3][3] = S1.rac();
for(int i=0; i<3; i++)
{
for(int j=0; j<3; j++)
cout << T[i][j];
cout << endl;
}
}
*-*********************************************

class.h
********************************************////
class salle
{
public:
salle(int[3][3]);
int* rac();
private:
int S[3][3];

};
salle::salle(int A[3][3])
{
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
A[3][3]=S[i][j];
}

int** salle::rac()
{
return S;
}
*****************************************************

voici ce que me met le compile comme erreur

:~/Projet-AG1/projet 4$ g++ Palais.cpp salle.h -o Palais
In file included from Palais.cpp:2:
salle.h:18: error: prototype for `int** salle::rac()' does not match any
in

class `salle'
salle.h:5: error: candidate is: int* salle::rac()
salle.h:18: error: `int** salle::rac()' and `int* salle::rac()' cannot
be


overloaded
salle.h: In member function `int** salle::rac()':
salle.h:19: error: cannot convert `int (*)[3]' to `int**' in return
Palais.cpp: In function `int main()':
Palais.cpp:8: error: invalid initializer
g++: compilation of header file requested
:~/Projet-AG1/projet 4$

qqn pourrait il m'aider dans ces conventions, et comment fiare un retour
de tableau a plusieurs dimmenttion??? merci

a++







kanze
Le #722679
elekis news:
voila je sui amener a manipuler des tableaux a deux dimentions dans
des classes, je ne pige pas ces retours, quelle est la conventions
exacte???


En C++, si tu utilises des tableaux C++ (std::vector), il n'y a rien de
particulier à dire -- un std::vector fonctionne comme n'importe quel
autre type.

En C, ou en C++ quand on est amené à utiliser des tableaux C (en général
pour des raisons de compatibilité avec un logiciel existant, mais aussi
parfois pour des raisons de l'ordre d'initialisation), en revanche, on
ne peut ni passer un tableau comme paramètre, ni le renvoyer d'une
fonction. Règle simple, mais pas toujours commode. Pour passer un
tableau, on arrive en général en se basant sur les conversions
implicites des tableaux en pointeurs, bien que la sémantique n'est plus
celui de passage par valeur. Pour les renvoyer, en principe, on pourrait
appiquer les mêmes règles. Seulement, puisqu'on ne travaille plus par
valeur, mais par référence, il y a le problème de la durée de vie du
référencié.

voici le simple code que j'essaie de faire.

planete.cpp
**********************************************
#include<iostream>
#include"salle.h"
using namespace std;

main(){
int A[3][3] = {1,1,1,1,0,1,1,0,1};


C'est un tableau de type C. Au moins qu'une utilisation d'un logiciel
existant exige autrement, j'aurais tendance à préférer std::vector --
dans ce cas-ci, peut-être au moyen d'un typedef :

typedef std::vector< std::vector< int > >
DonneesDeSalle ;

Mais dans le cas où 1) les dimensions sont fixes, et 2) on veut des
tableaux initialisés, ce n'est pas sans problèmes non plus. Les
dimensions d'un std::vector sont déterminé lors de l'execution, ce qui
ouvre la porte à un certain nombre d'erreurs, et la syntaxe
d'initialisation, surtout pour les tableaux à plusieurs dimensions, et
moins commode.

Alors, il m'arrive souvent de me servir d'une solution de compromise :

struct DonneesDeSalle
{
int donnees[ 3 ][ 3 ] ;
} ;

Le résultat, c'est une classe que je peux initialiser comme un tableau,
statiquement, à la C, mais qui se comporte quand même comme un type
entier, avec passage par valeur, etc.

Dans ce cas-là, il faudrait écrire :

DonneesDeSalle a = { { { 1, 1, 1 }, { 1, 0, 1 }, { 1, 0, 1 } } } ;

L'initialisation comme tu as fait ci-dessus est également valide, mais
(AMHA) moins clair (y compris avec int [3][3], d'ailleurs).

salle S1(A);


À cause de la converion implicite en pointeur, le type réelement passé
ici serait en fait int (*)[3] -- un pointeur à un tableau de trois int.

Si c'est le type auquel salle::salle s'attend, tout va bien.

int T[3][3] = S1.rac();


Et ici, ça ne peut pas marcher du tout. Le type voulu est un int[3][3],
et c'est un type qu'on ne peut pas renvoyer d'une fonction.

Ça pourrait marchait si tu te servais d'une des types ci-dessus.

for(int i=0; i<3; i++)
{
for(int j=0; j<3; j++)
cout << T[i][j];
cout << endl;
}
}
*-*********************************************

class.h
********************************************////
class salle
{
public:
salle(int[3][3]);


Puisqu'il n'existe pas la possibilité de passer des tableaux par valeur,
cette déclaration est automatiquement convertie en : int (*)[3], un
pointeur à un tableau de trois int.

Le premier 3 n'est que commentaire.

int* rac();
private:
int S[3][3];

};
salle::salle(int A[3][3])
{
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
A[3][3]=S[i][j];
}

int** salle::rac()
{
return S;
}


Ne peut pas marcher, pour deux raisons :

- d'abord, dans le .h, tu as déclaré que salle::rac() renvoie un int*,
et non un int**, et

- S n'est pas un int**, et ne se convertit pas implicitement en
int**. Il peut se convertir implicitement en int (*)[3] ; quelque
chose du genre :

int (* salle::rac*())[ 3 ] {
return S ;
}

serait légal. Mais même alors, la valeur de retour ne pourrait pas
servir à l'initialisation d'un int [3][3], parce que la conversion
est à sens unique -- une fois qu'on a le int (*)[3], il n'y a aucun
moyen, implicit ou explicit, à le réconvertir en int [3][3].

Compte tenu de ce que tu essaies de faire, je crois que la solution avec
le struct conviendrait parfaitement.

--
James Kanze GABI Software mailto:
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34

Mystic
Le #722678
merci merci pour les infos

"Alexandre" news:408e9b3b$0$26992$
bonjour,


"Mystic" news:c6m2ed$hm5$
Salut,
Je ne pourrai malheuresement pas t apporter de reponse par contre
jai le mm probleme ou plutot la mm question sauf qu il sagit dun tableau
a une dimension et d un tableau de string.
voila ce que je souhaiterai faire en gros mais ca marche pas :)


int ::first()
{
string myAr[2];

myAr = func();
}


où est le retour ? La fonction est sensée renvoyée un int.
De plus, myAr ne peut pas changer d'adresse car c'est un tableau statique.


string ::func()
{
string ar[2] = {"xXx", "Zone"};

return ar;
}


la aussi, erreur. ar est un tableau de string, donc équivalent à un
pointeur

sur string, (soit string *) pas string... Le type de retour n'est pas bon
ici.

Une version correcte :
string* func()
{
string ar[2]={"xxx","zo,e"};
return ar;
}

int first()
{
string* pMyAr;
pMyAr = func();

return 0 ; // ?
}

mais je conseille de regarder ce qu'est un vector<> pour la gestion des
tableaux...



"elekis" news:408e5676$0$10903$
bonjour, voila je sui amener a manipuler des tableaux a deux
dimentions



dans des classes, je ne pige pas ces retours, quelle est la
conventions



exacte???

voici le simple code que j'essaie de faire.

planete.cpp
**********************************************
#include<iostream>
#include"salle.h"
using namespace std;

main(){
int A[3][3] = {1,1,1,1,0,1,1,0,1};
salle S1(A);
int T[3][3] = S1.rac();
for(int i=0; i<3; i++)
{
for(int j=0; j<3; j++)
cout << T[i][j];
cout << endl;
}
}
*-*********************************************

class.h
********************************************////
class salle
{
public:
salle(int[3][3]);
int* rac();
private:
int S[3][3];

};
salle::salle(int A[3][3])
{
for(int i=0; i<3; i++)
for(int j=0; j<3; j++)
A[3][3]=S[i][j];
}

int** salle::rac()
{
return S;
}
*****************************************************

voici ce que me met le compile comme erreur

:~/Projet-AG1/projet 4$ g++ Palais.cpp salle.h -o Palais
In file included from Palais.cpp:2:
salle.h:18: error: prototype for `int** salle::rac()' does not match
any



in
class `salle'
salle.h:5: error: candidate is: int* salle::rac()
salle.h:18: error: `int** salle::rac()' and `int* salle::rac()' cannot
be


overloaded
salle.h: In member function `int** salle::rac()':
salle.h:19: error: cannot convert `int (*)[3]' to `int**' in return
Palais.cpp: In function `int main()':
Palais.cpp:8: error: invalid initializer
g++: compilation of header file requested
:~/Projet-AG1/projet 4$

qqn pourrait il m'aider dans ces conventions, et comment fiare un
retour



de tableau a plusieurs dimmenttion??? merci

a++











kanze
Le #722671
"Alexandre" news:
"Mystic" news:c6m2ed$hm5$

Je ne pourrai malheuresement pas t apporter de reponse par contre
jai le mm probleme ou plutot la mm question sauf qu il sagit dun
tableau a une dimension et d un tableau de string. voila ce que je
souhaiterai faire en gros mais ca marche pas :)

int ::first()
{
string myAr[2];

myAr = func();
}


où est le retour ? La fonction est sensée renvoyée un int. De plus,
myAr ne peut pas changer d'adresse car c'est un tableau statique.


Question : qui a parlé de chaangé une adresse ? Apparamment, il s'attend
à ce que func() renvoie un string[2]. Le langage ne le permet pas, mais
ce n'est qu'une raison de plus à utiliser vector.

string ::func()
{
string ar[2] = {"xXx", "Zone"};

return ar;
}


la aussi, erreur. ar est un tableau de string, donc équivalent à un
pointeur sur string, (soit string *) pas string...


Pas équivalent -- des tableaux et des pointeurs sont deux choses bien
distinctes. La seule chose, c'est qu'un tableau se convertit en pointeur
à son premier élément dans beaucoup (trop) de contextes.

Le type de retour n'est pas bon ici.


Ça, c'est vrai.

Une version correcte :
string* func()
{
string ar[2]={"xxx","zo,e"};
return ar;
}

int first()
{
string* pMyAr;
pMyAr = func();


Sauf que la sémantique est tout à fait différente. Ici, à la place d'une
erreur de compilation, tu as un comportement indéfini -- je ne suis pas
sûr que c'est ce qu'il voulait non plus. Dans la pratique, évidemment,
il n'aurait pas de problème tant qu'il n'essaie pas de se servir de
pMyAr. Mais pMyAr pointe bien à quelque chose qui n'existe plus, ce qui
n'est pas très utile.

return 0 ; // ?
}

mais je conseille de regarder ce qu'est un vector<> pour la gestion
des tableaux...


Tout à fait. Sauf qu'écrire l'équivalent de :

int array[3][3] = { { 1, 1, 1 }, { 1, 0, 1 }, { 0, 1, 0 } } ;

(avec l'initialisation) avec std::vector, ce n'est pas aussi simple.

Sans savoir ce qu'il veut faire dans l'ensemble, c'est impossible à
dire. Mais pour le peu qu'il a montré, je crois que :

struct Array
{
int data[ 3 ][ 3 ] ;
} ;

ferait l'affaire, malgré ces faiblesses.

Ce qui est dommage. Mais je crois qu'il y a des gens qui travaillent
dessus, pour trouver une vraie solution avec vector.

--
James Kanze GABI Software mailto:
Conseils en informatique orientée objet/ http://www.gabi-soft.fr
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34


Publicité
Poster une réponse
Anonyme