fonction qui retourne un tableau d'entiers

Le
steeve_dun
Bonjour,
J'essaye d'écrire une fonction qui retourne un tableau, mùais je n'y
arrive pas.
Quelqu'un pourrait-il m'aider ?
Voilà où j'en suis :
////////////////////////////////////////
#include <iostream>
#include<conio.h>
using namespace std;
const int Nmax=20;

int * Donne_Tableau(int taille)
{
int tableau[10];
for(int i=0;i<taille;++i) tableau[i]=i+1;
cout<< "dans donne_tab, tableau se trouve a "<<&tableau<<" sa valeur
est "<<tableau[0]<<"";
return tableau;
}
void affich_Tableau(const int tab[], int taille){
for (int i=0;i<taille;++i) cout<<"t"<<tab[i];
}
void main()
{
int* monTableau={0};
monTableau = Donne_Tableau(10);
cout<< "dans main, tableau se trouve a "<<&monTableau<<" sa valeur
est "<<*monTableau<<"";
affich_Tableau(monTableau,10);
_getch();
}
///////////////////////////////////////

Merci par avance,
Steeve.
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses Page 1 / 2
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Michel Decima
Le #17534091
a écrit :
Bonjour,
J'essaye d'écrire une fonction qui retourne un tableau, mùais je n'y
arrive pas.
Quelqu'un pourrait-il m'aider ?



Est-ce que tu as une bonne raison de ne pas utiliser std::vector ?
steeve_dun
Le #17534461
On 15 oct, 12:24, Michel Decima
a écrit :

> Bonjour,
> J'essaye d'écrire une fonction qui retourne un tableau, mùais je n' y
> arrive pas.
> Quelqu'un pourrait-il m'aider ?

Est-ce que tu as une bonne raison de ne pas utiliser std::vector ?



Oui, en fait, c'est plus théorique qu'autre chose, je voudrais
comprendre le fonctionnent des fonctions qui retournent des tableaux
et j'en ai trouvé aucun sur le net sans std::vector justement.
Doms
Le #17535121
Bonjour,

int * Donne_Tableau(int taille)
{
int tableau[10];



Ici ton tableau est alloué dans la pile d'execution (STACK) de la procedure
il n'existe plus (ou ne devrait plus exister) lorsque tu sors de la
procedure. Il faut allouer le tableau dans le tas (HEAP).

int *tableau = new int[taille]; // parceque tu passes la taille en param
if ( tableau == (int*)NULL )
{
// Si y'a plus de memoire...
return (int*)NULL;
// ou tu lances une exception
// throw xxx;
}

void main()
{
int* monTableau={0};



C'est quoi cette écriture (jamais vu) ?
il vaut mieux ecrire :
int * monTableau = (int*)NULL;

monTableau = Donne_Tableau(10);



Ici, tu doit tester ce que te retourne la fonction Donne Tableau.

C'est plus du C que du C++ d'ou la remarque sur l'utilisation de vector.

Doms.
Michel Decima
Le #17536151
a écrit :
On 15 oct, 12:24, Michel Decima
a écrit :

Bonjour,
J'essaye d'écrire une fonction qui retourne un tableau, mùais je n'y
arrive pas.
Quelqu'un pourrait-il m'aider ?


Est-ce que tu as une bonne raison de ne pas utiliser std::vector ?



Oui, en fait, c'est plus théorique qu'autre chose, je voudrais
comprendre le fonctionnent des fonctions qui retournent des tableaux
et j'en ai trouvé aucun sur le net sans std::vector justement.



Ce qui aurait du te mettre sur la piste: une fonction ne peut pas
retourner un tableau.
Marc Boyer
Le #17536141
On 2008-10-15,
Bonjour,
J'essaye d'écrire une fonction qui retourne un tableau, mùais je n'y
arrive pas.



Et oui. D'ailleurs, en C++, on retournera plutôt un vector.

Quelqu'un pourrait-il m'aider ?



Voui, mais note le crossPsot + fu2 fclc.

Voilà où j'en suis :
////////////////////////////////////////
#include <iostream>
#include using namespace std;
const int Nmax ;

int * Donne_Tableau(int taille)



Une fonction qui retourne un pointeur sur tableau.

{
int tableau[10];



Un tableau "variable locale" qui sera détruit dès
la fin de la fonction.

for(int i=0;i<taille;++i) tableau[i]=i+1;
cout<< "ndans donne_tab, tableau se trouve a "<<&tableau<<" sa valeur
est "<<tableau[0]<<"n";
return tableau;



Retourne l'adresse du tableau, adresse qui sera invalide dès la fin de
la fonction.

}
void affich_Tableau(const int tab[], int taille){
for (int i=0;i<taille;++i) cout<<"t"<<tab[i];
}
void main()
{
int* monTableau={0};



Sais-tu vraiment ce que tu fais là ?

Bon, pour résumer, on ne peut pas retourner un tableau, mais on
peut retourner un pointeur sur tableau ou un tableau dans une structure.

Le pb du pointeur sur tableau, c'est qu'il faut créer le tableau,
et que pour qu'il survive à la fin de la fonction, il faut que ce soit
une variable static ou un tableau alloué dynamiquement.

Par contre, ceci marche
typedef struct { int tab[10]; } tab_10_int;
tab_10_int donneTableau(void){
tab_10_int x;
for(int i=0; i < sizeof(x.tab)/sizeof(x.tab[0]) ; i++)
x.tab[i]= i;
return tab_10_int;
}


Marc Boyer
--
Si tu peux supporter d'entendre tes paroles
Travesties par des gueux pour exciter des sots
IF -- Rudyard Kipling (Trad. André Maurois)
James Kanze
Le #17539631
On Oct 15, 11:35 am, wrote:

J'essaye d'écrire une fonction qui retourne un tableau, mùais
je n'y arrive pas. Quelqu'un pourrait-il m'aider ?



Voilà où j'en suis :
////////////////////////////////////////
#include <iostream>
#include using namespace std;
const int Nmax ;



int * Donne_Tableau(int taille)



Là, tu ne retourne pas un tableau d'entiers, mais un pointeur
vers un entier. Pour un tableau d'entiers, il faudrait écrire :

std::vector< int > Donne_Tableau( int taille )

{
int tableau[10];
for(int i=0;i<taille;++i) tableau[i]=i+1;
cout<< "ndans donne_tab, tableau se trouve a "<<&tableau<<" sa valeur
est "<<tableau[0]<<"n";
return tableau;
}



Ce qui t'amène tout de suite à un comportement indéfini.

Les tableaux de type C sont horriblement cassés. Il ne faut s'en
servir que dans des cas bien précis -- pratiquement, qu'avec des
variables statiques (dont on a besoind d'une initialisation
statique).

void affich_Tableau(const int tab[], int taille){
        for (int i=0;i<taille;++i) cout<<"t"<<tab[i];}



void main()



Ce qui n'est pas légal non plus:-).

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
James Kanze
Le #17539811
On Oct 15, 1:45 pm, "Doms"
>int * Donne_Tableau(int taille)
>{
>int tableau[10];



Ici ton tableau est alloué dans la pile d'execution (STACK) de
la procedure il n'existe plus (ou ne devrait plus exister)
lorsque tu sors de la procedure. Il faut allouer le tableau
dans le tas (HEAP).



Ce qui pose pas mal de problèmes aussi. Il vaut mieux renvoyer
un vrai tableau qui marche : std::vector<int>.

int *tableau = new int[taille]; // parceque tu passes la taille en para m
if ( tableau == (int*)NULL )



Une expression new (sauf certains new de placement) ne renvoie
jamais de pointeur null. Ton if ne serait donc jamais vrai.

{
    // Si y'a plus de memoire...
    return (int*)NULL;
    // ou tu lances une exception
    // throw xxx;
}
> void main()
> {
> int* monTableau={0};



C'est quoi cette écriture (jamais vu) ?



C'est ce qu'on appelle (en anglais) « agglomerate
initialization ». C'est toujours légal, mais c'est vrai qu'il ne
sert pour ainsi dire jamais pour l'initialisation des scalaires.

    il vaut mieux ecrire :
int * monTableau = (int*)NULL;



La conversion explicite est supérflue.

> monTableau =  Donne_Tableau(10);



Et il serait mieux de mettre le tout dans l'initialisation :

int* monTableau = Donne_Tableau( 10 ) ;

Sauf que les noms mentent, parce que ce n'est pas un tableau
qu'on renvoie, mais un pointeur.

Ici, tu doit tester ce que te retourne la fonction Donne
Tableau.



Ou garantir qu'il ne renvoie jamais de pointeur null.

Aussi, il faudrait s'assurer un delete quelque part. Y compris
dans le cas des exceptions.

En somme, c'est une solution ne tient pas la route.

--
James Kanze (GABI Software) email:
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
steeve_dun
Le #17545641
Donc je corrige, c'est bien une fonction qui retourne un pointeur sur
un tableau que je voulais.
Merci à tous pour ces précisions.

-Steeve.
Doms
Le #17586741
Bonjour,

int *tableau = new int[taille]; // parceque tu passes la taille en param
if ( tableau == (int*)NULL )
Une expression new (sauf certains new de placement) ne renvoie
jamais de pointeur null. Ton if ne serait donc jamais vrai.





Je suis d'accord avec ca mais ca peut arriver quand meme (surtout
sur certains compilos specifiques).
J'essayais d'etre pedagogique meme si j'en ai fait trop ;-P

Merci pour les autres infos ! Doms.
xylo
Le #17648331
Le Wed, 15 Oct 2008 02:35:18 -0700, steeve_dun a écrit:

Bonjour,
J'essaye d'écrire une fonction qui retourne un tableau, mùais je n'y
arrive pas.
Quelqu'un pourrait-il m'aider ?
Voilà où j'en suis :
////////////////////////////////////////
#include <iostream>
#include using namespace std;
const int Nmax ;

int * Donne_Tableau(int taille)
{
int tableau[10];
for(int i=0;i<taille;++i) tableau[i]=i+1;
cout<< "ndans donne_tab, tableau se trouve a "<<&tableau<<" sa valeur
est "<<tableau[0]<<"n";
return tableau;
}
void affich_Tableau(const int tab[], int taille){
for (int i=0;i<taille;++i) cout<<"t"<<tab[i];
}
void main()
{
int* monTableau={0};
monTableau = Donne_Tableau(10);
cout<< "ndans main, tableau se trouve a "<<&monTableau<<" sa valeur
est "<<*monTableau<<"n";
affich_Tableau(monTableau,10);
_getch();
}
///////////////////////////////////////

Merci par avance,
Steeve.



sans aucune prétention, une autre façon élégante d'initialiser un tableau
de int:

#include #include #include
static int create_mytab( int **tab, unsigned long size);

/*
************************************************
*/
int main(int argc, char** argv) {
int err = 0;
int *mytab = NULL;
int *ptr;

// je veux un nouveau tableau de 10 int
err = create_mytab(&mytab, 10);
if(!err) {
int i;

// affectation dans le tableau
ptr = mytab;
for(i=0 ; i<10 ; i++) {
*ptr++ = i;
}

// test du contenu
ptr = mytab;
for(i=0 ; i<10 ; i++) {
printf("ntab[%d]: %d", i, *ptr++);
}
printf("n");

// et je le libre
free(mytab); mytab = NULL;
}

return 0;
}

/*
************************************************
*/
static int
create_mytab( int **tab, unsigned long size)
{
assert(NULL == *tab);

// allocation sur la HEAP de mon tableau
*tab = (int*)calloc(size, sizeof(**tab));
if(NULL == *tab) return -1;
return 0;
}

--
Apply rot13 to this e-mail address before using it.
JM Marino
http://jm.marino.free.fr
Publicité
Poster une réponse
Anonyme