Discussion :

[Mat 74]

salut a ts

voila je voudrais juste savoir comment on peut gerer une fonction qui a un nombre de parametres indefinis avec un protype dans ce genre :

Code :

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

1
2
 
void fonction (type arg,...)

merci
@+

[Laurent Gomila]

1- Si tu disposes d'une chaîne de caractère décrivant les paramètres variables, style printf & cie, il faut utiliser les macros de <cstdarg>

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
void MyPrintf(const char* Format, ...)
{
    // Formatage du message dans une chaîne de caractère
    char Buffer[512];
    va_list Params;
    va_start(Params, Format);
    vsprintf(Buffer, Format, Params);
    va_end(Params);
 
    // Ecriture
    cout << Buffer << endl;
}

2- Si tous tes paramètres ont le même type, mais que seul leur nombre varie, tu peux marquer leur fin par une valeur spéciale (NULL, -1, "", ...). Tu déclares un pointeur du type de tes paramètres, que tu balades jusqu'à la fin en l'incrémentant de 1 à chaque fois pour récupérer successivement les paramètres.

Mais en général en C++ on peut avantageusement éviter cela, cf. cout et le chainages d'appels à <<.

[Mat 74]

ben en fait je peu pas du tout faire une fonctions style cout sa servirai pas a grand chose
j'ai fais une classe pour la gestion des nombres complexes et j'ai voulais faire une fonctions translations ds laquelle on pourrait passer autant de parametre que l'on souhaite car avec un parametre sa sert pas a grand chose .

donc si j'ai compris il faut que je fasse un pointeur sur le premier argument et ensuite je l'incremente de la taille des type passer en parametre

[JolyLoic]

Ca ne marchera pas très bien : Dans les fonctions à arguments variables, on est limité à des types de base. Ou alors passer des pointeurs, ce qui alourdi l'écriture. Quel est le problème par rapport au chaînage proposé par Loulou24 (Au fait, Loulou, tu tiens au numéro quand on te cite ?) ?

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
23
24
25
26
27
28
29
 
class Vector
{
  Vector &translate(Vector const &v);
  Vector &translate(double x, double y);
  Vector &rotate(double a);
  // ...
};
 
Vector &Vector::translate(Vector const &v)
{
  // translate
  return *this;
}
 
Vector &Vector::translate(double x, double y)
{
  // translate
  return *this;
}
 
Vector &Vector::rotate(double a);
{
  // rotate
  return *this;
}
 
Vector v;
v.translate(10, 5).rotate(45).translate(3,-1);

[Laurent Gomila]

Au fait, Loulou, tu tiens au numéro quand on te cite ?

Pas vraiment non, je préfère sans

[Mat 74]

j'ai essayer ton truc loulou mais sa marche pas ou alors j'ai fais une connerie je sais pas

voila la fonction

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void Translation (Complexe &vecteur,Complexe &point,...)
{
 
    va_list Params; 
    va_start(Params, point); 
    point+=vecteur; 
    va_end(Params); 
 
}

sa modifie point mais pas les autres argument passer

[Laurent Gomila]

C'est normal que cela ne modifie que point, puisque tu n'appelles += que sur point... Il faudrait te balader sur tous les paramètres et apliquer la translation sur chaque.

Mais...

Ca ne marchera pas très bien : Dans les fonctions à arguments variables, on est limité à des types de base. Ou alors passer des pointeurs, ce qui alourdi l'écriture

Donc tu ne pourras pas faire ce que tu souhaites de cette manière. Les solutions à base de chaînage d'appels te rebutent vraiment ?

[Mat 74]

ouai mais ma fonction est declarer en friend
et puis il faudrait appeler plusieurs fois la fonction

[Laurent Gomila]

De toute façon tu n'y arriveras pas comme ça, tu n'as pas le choix. Après tu peux faire en sorte que le chaînage d'appel soit le plus sympa possible.

Code :

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

MonVecteur.Translate(P1)(P2)(P3)(P4);

Code :

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

MonVecteur.Translate(P1).Translate(P2).Translate(P3);

Code :

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

1
2
for (size_t i = 0; i < VecteurDePoints.size(); ++i)
    VecteurDePoints[i].Translate(MonVecteur);

Ok le dernier n'est pas un chaînage, mais si tu peux te ramener à cette situation alors celui-ci ne sera pas nécessaire. Et puis il me semble plus correct de translater un point avec en paramètre le vecteur translation, plutôt que l'inverse (conceptuellement parlant).

[Mat 74]

en fait j'ai reussi a faire ce que t'avait proposé de faire au debut avec le pointeur
en fait sa marchait pas parce qu'il fallait decrementer le pointeur

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
 
void Translation (Complexe &vecteur,int nombre,Complexe &point,...)
{
 
   Complexe *p = &point;
   int i=0;
 
   do 
   {
 
      (*p)+=vecteur;
      p--;
      i++;	
 
   }
   while (i!=nombre);
 
}

[Laurent Gomila]

Tiens je ne savais pas que les paramètres étaient empilés dans cet ordre là

Par contre ça me paraît très très douteux comme manip... Qu'est-ce qui te dit que tes paramètres optionnels seront passés par référence (d'ailleurs je ne pense pas qu'ils le soient) ? Et dans ce cas la décrémentation de ton pointeur ne te fait pas pointer sur le paramètre suivant. Bref je n'ai jamais essayé ce genre de manip mais ça me paraît très limite.

[Mat 74]

ben je sais pas . les parametres je les passes normalement

j'ai reessayer, sa marche nickel
le seul truc un peu chiant c'est qu'il faut lui dire le nb de parametres

Code :

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

1
2
3
 
Complexe u(1,1),a(0,0),b(1,1),c(2,2),d(3,3),e(4,4);
Translation (u,5,a,b,c,d,e);