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();
}
///////////////////////////////////////
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
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.
On 15 oct, 12:24, Michel Decima <michel.dec...@orange-ft.com> wrote:
steeve_...@yahoo.fr 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.
> 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
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.
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.
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
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.
steeve_dun@yahoo.fr a écrit :
On 15 oct, 12:24, Michel Decima <michel.dec...@orange-ft.com> wrote:
steeve_...@yahoo.fr 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.
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
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)
On 2008-10-15, steeve_dun@yahoo.fr <steeve_dun@yahoo.fr> 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)
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)
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
On Oct 15, 11:35 am, steeve_...@yahoo.fr 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=20;
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:james.kanze@gmail.com
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
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
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
On Oct 15, 1:45 pm, "Doms" <D...@fr.invalid> wrote:
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:james.kanze@gmail.com
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
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
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.
Donc je corrige, c'est bien une fonction qui retourne un pointeur sur
un tableau que je voulais.
Merci à tous pour ces précisions.
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
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.
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
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 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
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
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