Logo GNT
Actualités Tests & Guides Bons Plans
Twitter iPhone pliant OnePlus 11 PS5 Disney+ Orange Livebox Windows 11
Entraide Développement Développement Langage C++ fonction qui retourne un tableau d'entiers

fonction qui retourne un tableau d'entiers

12 réponses
Avatar
steeve_dun
Bonjour,
J'essaye d'=E9crire une fonction qui retourne un tableau, m=F9ais je n'y
arrive pas.
Quelqu'un pourrait-il m'aider ?
Voil=E0 o=F9 j'en suis :
////////////////////////////////////////
#include <iostream>
#include<conio.h>
using namespace std;
const int Nmax=3D20;

int * Donne_Tableau(int taille)
{
int tableau[10];
for(int i=3D0;i<taille;++i) tableau[i]=3Di+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=3D0;i<taille;++i) cout<<"\t"<<tab[i];
}
void main()
{
int* monTableau=3D{0};
monTableau =3D 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.
Signaler un problème avec ce contenu

10 réponses

Supprimer
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire

Veuillez sélectionner un problème

Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
1 2
Avatar
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 ?
Avatar
steeve_dun
On 15 oct, 12:24, Michel Decima wrote:
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.
Avatar
Doms
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.
Avatar
Michel Decima
a écrit :
On 15 oct, 12:24, Michel Decima wrote:
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.
Avatar
Marc Boyer
On 2008-10-15, wrote:
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<conio.h>
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)
Avatar
James Kanze
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<conio.h>
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
Avatar
James Kanze
On Oct 15, 1:45 pm, "Doms" wrote:

>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
Avatar
steeve_dun
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.
Avatar
Doms
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.
Avatar
xylo
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<conio.h>
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 <stdio.h> /* pour printf() */
#include <stdlib.h> /* pour calloc() */
#include <assert.h> /* pour assert() */

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
1 2