Discussion :

[Jimalexp]

Salut,

Comment fais t-on pour passer un tableau en paramètre et l'affecter à un pointeur se trouvant dans une structure ? Un prototype de fonction suffirais ainsi qu'une petite explication sur ce qu'on devrais faire au niveau de l'affectation.

Voici des structs en guise d'exemple.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
typedef struct
{
	char*			Nom;
} TMilieu;
 
typedef struct
{
	long			Nombre;
	TMilieu*		Tableau;
	bool			EstTrie;
} TTabMilieux;

[wakan]

Bonjour,

Comment fais t-on pour passer un tableau en paramètre

En faisant un truc du genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void main (void)
{
 
TOTO tab_struct[50];
Recup_data(tab_struct);
}
 
void Recup_data(TOTO *DATA)
{
for (int i=0;i<50;i++)
{
if (!feof(FICHIER))
fgets(DATA[i]->nom,10,FICHIER);
}
}

simplement, en passant tab_struct en paramètre, tu lui passes l'adresse de début du tableau (équivalent à &tab_struct[0])

Prends garde il me semble qu'il y a certaine incompatibilité entre le c et le c++ pour le passage de tableau en paramètre.

A bientôt

[Jimalexp]

Si j'ai bien compris, on envois la variable tab_struct et on va chercher l'emplacement dans le pointeur dans les paramètres de Recup_data ?

Et prenons un cas où la structure tableau dois être intégrée à une autre structure (disons TTabMilieux représente tous les milieux qui conviennent à une créature). Si un tableau est déjà formé, comment pourrais t-on procéder ?

Cette question m'intéresse particulièrement car je m'y perds au niveau pointeurs et références lorsqu'on passe par des paramètres. D'ailleurs, je n'ai pas su terminer un exercice pour un examen cette semaine pour cette même raison.

[wakan]

Désolé je ne comprend pas très bien ce que tu veux faire exactement est-ce une structure ou un tableau que tu veux passer en paramètre ?

[mister3957]

Alors déjà un tableau d'éléments se matérialise par un pointeur vers le premier élément ainsi que le nombre d'éléments.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
struct SElement
{
    int i;
};
 
SElement* tab1 = new SElement[50];
SElement tab2[50];
 
SElement firstElt;
 
// copies du premier élément
firstElt= tab1[0];
firstElt= tab1 + 0;
firstElt = tab2[0];
firstElt= tab2 + 0;
 
// copies de l'élément n (l'index comment à 0, attention à ne pas dépasser 50)
firstElt= tab1[n];
firstElt= tab1 + n;
firstElt = tab2[n];
firstElt= tab2 + n;

tab1 et tab2 sont tout deux des pointeurs vers le premier élément d'une série de 50.
La différence est que tab1 a été alloué dynamiquement, et il te faudra gérer sa désallocation. Alors que tab2 sera détruit au prochain "}"

Dans la mémoire, voilà ce que tu as :
[00][01][02]...[49]
50 éléments contigüs donc le "tableau" est en fait un pointeur vers l'élément [00]

Donc en général, pour passer un tableau en paramètre, on passe le pointeur ainsi que le nombre d'éléments (pour que la fonction puisse partir du premier élément et savoir où s'arrêter).

Une autre technique si le nombre d'élément est en dur (c'est à dire que le 50 n'a pas été calculé) consiste à utiliser les templates.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
template <std::size_t N>
UneFonction(const SElement (&tab)[N]) const
{
   SElement lastElt = tab[N - 1];
}
 
SElement tab[50] = { ... };
UneFonction(tab); // Implicitement, ça appellera UneFonction<50>(tab)

Quand aux références, plusieurs sujet sur le "référence ou pointeur ?" ont été postés. Une référence est un pointeur qui ne peut pas être nul. Dans le cadre d'un tableau, mieux vaut passer un pointeur, c'est plus explicit à mon goût, mais si tu veux absolument interdire de passer nul, tu peux faire ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
MaFonction(SElement& elt, int count)
{
   SElement* pFirst = (&elt);
   SElement* pLast = pFirst[count - 1];
   SElement lastElt = *pLast;
}

L'intérêt majeur de passer un pointeur ou une référence est que ça ne recopiera pas l'objet. En effet si tu fais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
struct SElement
{
    SElement(const SElement& elt);
    int i;
};
 
MaFonction(SElement elt)
{
 
}
 
SElement eltTemp;
MaFonction(eltTemp); // eltTemp sera recopié, si tu mets un point d'arrêt dans le constructeur de recopie, ça s'arrêtera.

Dans le cadre de gros objets, toute ses données seront recopiés, ce qui peut souvent faire perdre pas mal de performances. Si tu fait passer une référence ou un pointeur (codé en général sur 8 octets, ça ne fera la copie que de ce pointeur/référence.
Donc si tu passe du "int" généralement codé sur 4 octets, le faire passer en référence ou en pointeur est moins performant.

La seconde utilisation du passage par pointeur ou référence sont les paramètres de sorties.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void Sommes(Point* pTab, int iCount, int& x; int&y)
{
   x = 0; y = 0;
   for(int i = 0; i < iCount; i++)
   {
      x += pTab[i].x;
      y += pTab[i].y;
   }
}
 
Point pTab[50] = { ... };
int iSommeX, iSommeY;
Sommes(pTab, 50, iSommeX, iSommeY); // Les adresse de iSommeX/Y sont passé, puis les objets sont remplis dans la fonction, sans aucune copie, donc tes paramètres "ressortent"

Si la notion de pointeur et de référence t'es encore trouble, il faut absolument éclaircir ça avant d'aller plus loin.