passage d'un tableau en parametre d'une fonction

Version imprimable

24/10/2005, 23h28
ataya

passage d'un tableau en parametre d'une fonction
Bonjour, je suis debutant, donc voici mon probleme:

dans mon programme, j'ai un tableau int T[10], je souhaite ecrire une fonction qui va modifier le contenu de ce tableau, mais je ne sait pas comment passer mon tableau en parametre

j'essaie ceci:

En parametre, dois-je passer le tableau ou un pointeur de ce tableau?
Bref comment ecrire cette fonction?
Code:

1 2 3 4 5 6 7 8 void setTab(const tab* myTab) { for(int i=0;i<10;i++){ myTab[i]=rand()%100; } }
mais ca marche po!!! Merci.
25/10/2005, 00h12
Gilles Louïse
Le mieux est de déclarer une constante pour éviter d'avoir à utiliser des nombres "en dur".

Code:

const int NbVal=10;

Dans ces conditions, vous déclarez votre tableau ainsi :

Code:

int myTab[NbVal];

Vous déclarez ainsi le prototype de votre fonction dans la classe principale :

Code:

void __fastcall SetTab(int[]);

La fonction s'écrit ainsi :
Code:

1 2 3 4 void __fastcall TForm1::SetTab(int T[]) { for(int i=0;i<NbVal;i++) T[i]=rand()%100; }
Vous l'appelez ainsi :

Code:

SetTab(myTab);

Notez qu'il serait bon de faire un "randomize" au début de l'exécution du programme, par exemple dans le constructeur de la classe principale, sinon le programme choisira chaque fois les mêmes nombres aléatoires.

Code:

randomize();

À bientôt
Gilles
25/10/2005, 12h54
Freeze
moi je suis plutot partisan du define :

Code:

#define NBVAL 10

Code:

int myTab[NBVAL];

Code:

void __fastcall SetTab(int*);
Code:

1 2 3 4 void __fastcall TForm1::SetTab(int *T) { for(int i=0;i<NBVAL;i++) T[i]=rand()%100; }
je sais pas si ca change quelque chose ... mais je donne juste mon avis ...
25/10/2005, 13h47
Gilles Louïse

Citation:

Envoyé par Freeze

je sais pas si ca change quelque chose ... mais je donne juste mon avis ...

Il y a à peu près autant de différence qu'entre bonnet blanc et blanc bonnet, l'internaute n'aura qu'à choisir ce qui lui convient.

À bientôt
Gilles

merci pour vos deux codes, mais en fait aucuns ne marche, en effet dans les deux cas il me met l'erreur:

"[C++ Erreur] Unit1.cpp(23): E2316 '_fastcall TForm1::SetTab(int *)' n'est pas un membre de 'TForm1'"

C'est surement une erreur grossiere de ma part mais je ne sait pas ou.

La declaration de prototype est elle faite au bon endroit?
Au fait qu'est-ce/a quoi sert cette declaration?

Voici mon code complet:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
//---------------------------------------------------------------------------
 
#include <vcl.h>
#include <stdlib.h>
#pragma hdrstop
#include <math.hpp>
#include "Unit1.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma resource "*.dfm"
 
TForm1 *Form1;
 
 
void __fastcall SetTab(int[]);  //declaration du prototype de la fonction
//---------------------------------------------------------------------------
__fastcall TForm1::TForm1(TComponent* Owner)
        : TForm(Owner)
{
}
//--------------------------------------------------------------------------
void __fastcall TForm1::SetTab(int T[])
{
for(int i=0;i<NbVal;i++) T[i]=rand()%100;
}
 
//---------------------------------------------------------------------------
 
 
void __fastcall TForm1::btn_GenClick(TObject *Sender)
{
//On randomize pour avoir des suites differentes
randomize();
 
const int NbVal=10;
int myTab[NbVal];
 
 
//Remlissage du tableau
setTab(myTab);
 
 
 
//Remplissage de la form
Label0->Caption=myTab[0];
Label1->Caption=myTab[1];
Label2->Caption=myTab[2];
Label3->Caption=myTab[3];
Label4->Caption=myTab[4];
Label5->Caption=myTab[5];
Label6->Caption=myTab[6];
Label7->Caption=myTab[7];
Label8->Caption=myTab[8];
Label9->Caption=myTab[9];
 
}

25/10/2005, 19h04
Pasqualini
Code:

1 2 void __fastcall SetTab(int[]); //declaration du prototype de la fonction
le prototype doit être déclaré dans la classse de la Form1, qui se trouve dans le fichier *.h pour être une fonction de la Form1 et pouvoir écrire
Code:

1 2 void __fastcall TForm1::SetTab(int T[])

Citation:

Envoyé par ataya

Au fait qu'est-ce/a quoi sert cette declaration?

Toutes vos fonctions et variables générales doivent être déclarées dans la classe principale, dans la partie "public" dédiéé à l'utilisateur. (un commentaire automatique de C++ Builder indique clairement "Déclarations de l'utilisateur")
Code:

1 2 3 4 5 6 7 8 9 10 class TForm1 : public TForm { __published: // Composants gérés par l'EDI private: // Déclarations de l'utilisateur public: // Déclarations de l'utilisateur -------------- ICI ------------------ __fastcall TForm1(TComponent* Owner); };
De cette manière, elle est connue partout et vous pouvez l'invoquer.

À bientôt
Gilles

25/10/2005, 19h39
ataya

Merci beaucoup, ca marche beaucoup mieux quand on fait les declarations au bon endroit...

Amicalement, Sébastien
26/10/2005, 10h25
gandf
Je vais peut-être dire une bêtise mais ne vaut-il pas mieux mettre le 2ème paramètre en paramètre pour la fonction pour éviter d'avoir une variable globale?

Code:

void __fastcall SetTab(int[], int NbVal);
Code:

1 2 3 4 void __fastcall TForm1::SetTab(int T[], int NbVal) { for(int i=0;i<NbVal;i++) T[i]=rand()%100; }
Code:

SetTab(myTab, int NbVal);
26/10/2005, 13h20
Gilles Louïse

Citation:

Envoyé par gandf

Je vais peut-être dire une bêtise mais ne vaut-il pas mieux mettre le 2ème paramètre en paramètre pour la fonction pour éviter d'avoir une variable globale?

Ce n'est pas une variable globale, c'est une constante.

Votre proposition est risquée car si la variable envoyée est supérieure au nombre d'entiers alloués dans le tableau, ça va buguer. Ici NbVal est une constante (le mieux serait d'ailleurs de le signaler dans son nom, par exemple C_NbVal, ce qui rend un programme beaucoup plus lisible), elle est utilisée aussi bien à la création du tableau par new que dans le sous- programme. Votre proposition serait correcte si d'une part, on créait le tableau en même temps qu'on le remplit, auquel cas il ne peut pas y avoir de débordement et si (autre condition) le tableau était appelé à changer de dimension par la suite. Si le tableau doit rester de même taille tout le temps, une constante s'impose.

On pourra se dire : pourquoi par exemple ne pas écrire "10" en dur dans le programme si on est sûr qu'il n'y aura que 10 entiers? C'est tout simple. Si vous écrivez "10" à chaque fois, il vous sera difficile de changer ce nombre par la suite. Imaginez que vous vouliez plus tard non pas 10 mais 15 entiers. Vous allez devoir cherchez partout dans le programme les occurrences "10", en vérifiant bien qu'elle est en relation avec le tableau (sinon vous allez faire buguer une autre partie du programme) et les changer en 15. Sur un petit programme, ça peut le faire, sur un grand, c'est plus difficile.

Maintenant, si vous avez une constante et que l'avez utilisée partout, il suffira de changer la constante, de la faire passer à 15 et de tout recompiler, vous ne vous occupez de rien, ça marchera tout de suite.

C'est ça, l'amusant d'une constante, c'est qu'elle est précisément susceptible d'être variable! Une constante n'est constante qu'à l'intérieur d'une compilation, on peut la modifier entre deux compilations.

La règle est donc de toujours utiliser des constantes, le programme n'en est que plus lisible et facilement modifiable.

À bientôt
Gilles
26/10/2005, 14h30
gandf

OK, je n'avais compris que c'était une constante que l'on voulais.
En effet, cela permet de simplifier le travail par la suite.

Rajouter le 2ème paramètre ne sert que si l'on utilise un tableau de taille variable.

on peut aussi garder la constante et le 2ème paramètre pour la fonction. Ainsi, on peut gérer aussi bien un tableau de taille fixe que de taille variable. Dans ce cas, il ne faut pas se tromper pour le 2ème paramètre.