Bonjour tout le monde !

Je voudrais créer une fonction avec un nombre variable de paramètres qui créer un QMenu et lui insère toutes les QAction données en paramètres.

Voiçi la base de la fonction :

void Programme::InitMenu (QMenu*& menu, const char* txt, QAction*& act)
{
    menu = new QMenu (tr (txt), this);
    menu -> addAction (act);
}
// qui s'utilise ainsi dans la classe Programme :
InitAction (m_action, "action", "icone.png", Qt::CTRL); // voir lien ci-dessous
InitMenu (m_menu, "menu", m_action);
// sachant qu'il y a dans les attributs :
QMenu *m_menu;
QAction *m_action;

Mais je vourdrais passer autant de QAction à la fonction InitMenu, donc cette fonction devra pouvoir recevoir un nombre variable d'arguments.

Le problème c'est que je ne sais pas du tout comment faire, donc si vous pouviez m'éclairer, ce serait super sympa !

Merci d'avance !

Lien => ici

Bah tu fait des boucles pour appeler autant de fois que nécéssaire la fonction InitMenu.
Pour donner les bon paramètres, comme ils sont codés en dur tu n'a qua les regrouper dans une struture genre InfoQAction, puis faire un tableau de InfoQAction pour passer chaque élémenet à InitMenu.

Hm je ne sais pas si c'est applicable en C++, mais il y a les ellipses.

Tu peux spécifier des arguments par défauts ou utiliser plusieurs fonctions ayant le même nom mais un nombre différents d'arguments.

Faire des fonctions "à la printf" est une très mauvaise solution. (ellipses)

je plussois Nanoc sur les ellipses.
Ne jamais utiliser les ... dans le C++.
Il ya toujours des moyens d'éviter ca (chainage d'appels, ou boucle d'appel pour ce cas ci).

Par contre, utiliser plusieurs fonctions avec un nombre d'arguments différents, il ya plus évolutif comme méthode

Dans les cas déspérés on peux toujours passer un vector (ou équivalent) en parametre

entre l'ellipse et le vector de void*, je sais pas lequel est le pire...

J'ai jamais dit de void*
Dans son cas ca serait des QAction*, par exemple

Logiquement ça se tien je trouve on raisonne en disant :
- Tu vas me créer un menu avec cette liste d'action
Plutôt que de penser :
- Tu vas me créer un menu vide
- Tu vas ajouter cette action
- Puis celle là
- Et celle là

Et ça serait dans les cas les plus despérés, je pensais notemment lorsque qu'on à énormément d'appels de fonctions répetitif car.... un appel de fonction ça a un coût mine de rien

Ne soit pas paresseux... une suite de AddAction ce n'est pas la fin du monde dans ce type d'implémentation.

Personnellement j'utilise l'Ellipse régulièrement quand je veux gérer un cas d'exception locale mais que peu importe l'exception je veux la relancer.

void f()
{
    int * p = new int( 0 );
    
    try
    {
        // ...

        g( p ); // fonction pouvant lancer une exception
        
        // ...
    }
    catch( ... )
    {
        delete p;
        throw; // relance l'exception pour qu'elle soit traitée plus loin.
    }
}

@ Inki : Que ce soit AddAction() ou push_back() cela revient au même.

Oui en effet, si on veux optimiser le nombre d'appels (note: je sort completement du contexte de la génération du menu) on devrait passer par des tableaux C style ?

Je me pose cette question du nombre d'appels dans les cas critiques suite à la decouverte des VBO en openGl (cf. chapitre 1.1)

Bonjour tout le monde ! Merci pour vos réponses !

Je trouve que faire plusieurs fonctions avec un nombre différent d'arguments ou avec des paramètres optionnels, c'est un peu barbare et pas très optimisé ! De plus ce n'est pas super pour la réutilisation !

Les solutions à base de tableaux (par une boucle ou en passant le tableau directement en paramètre) me paraissent déjà plus avantageuses. C'est d'ailleurs la solution pour laquelle j'ai opté.

Mais si je vous ai parlé des ellipses, ce n'était pas juste pour réussir ma fonction ; c'était aussi pour découvrir un nouveau concept du C++ ! Je suis encore débutant (ca fait qu'un an et demi que je programme) donc j'aimerais bien en apprendre encore davantage !

Je me souviens avoir vu dans un exercice (que je n'ai malheureusement pas retrouvé ) une classe qui avait une méthode permettant d'additionner des nombres dans un autre ainsi (ce n'était qu'un exercice, la fonction n'a aucune utilité ) :

double resultat = 0, nombre = -10.6;
resultat << 16 << 32 << 0.5 << nombre;

Comment est-ce possible ? (cela peut etre une solution, mais ca rejoint les ellipse je pense ...)

Merci d'avance !

C'est le chainage des appels.
Cf FAQ de developpez.com

Edit: bon je ne trouve plus l'entré mais l'idée c'est que ta fonction renvoit une référence pour enchaine les appels.

OK j'ai compris le principe.

Voilà ce que j'ai fait pour l'instant :

class MyQMenu
{
    public : 
        MyQMenu (const char* nom, QWidget* parent)
        {
            m_menu = new QMenu (tr (nom), parent);
        }

        template <typename T> MyQMenu& operator << (const T& t)
        {
            m_menu -> addAction (t);
            return *this;
        }

        QMenu* ToQMenu (void)
        {
            return m_menu;
        }
        
    private :   
        QMenu *m_menu;
};

// et ...

MyQMenu *menu;
menu = new MyQMenu ("menu", this);
menu << action1 << action2;
menuBar -> addMenu (menu -> ToQMenu ());

Mais il y a un problème : la surcharge de l'opérateur << ne fonctionne pas !

D'où vient le problème ? Merci d'avance !

- l'erreur stp

ps: pourquoi "templatisé" ?

Ben l'erreur, je l'ai dit, se situe au niveau de l'utilisation de l'opérateur <<, donc il est mal surchargé !
Le compilo me dit :

invalid operands of types `Programme::MyQMenu*' and `QAction*' to binary `operator<<'

Citation : Chlab_lak

ps: pourquoi "templatisé" ?

Car dans un QMenu on peut insérer 3 choses : des QActions, d'autres QMenus et des separator (que je ferai avec des int).

template <typename T> MyQMenu& operator << (MyQMenu& menu,const T& t)

compilera sans doute mieux car operator << est binaire.

Edit: il faut que operator << soit libre. Le code suivant devrais marcher.

template <typename T> MyQMenu& operator << (MyQMenu& menu,const T& t)
        {
            menu->ToQMenu()->addAction (t);
            return menu;
        }

Ben cela ne marche toujours pas, il y a la même erreur que tout à l'heure, sauf qu'en plus il dit que la surcharge de l'opérateur << ne doit prendre qu'un paramètre !

tu nous dit qu'un QMenu peux ajouter un menu, une action ou des separateur; hors, lors de cet ligne-ci :

menu->ToQMenu()->addAction (t);

tu ne fait aucune distinction entre une action, un menu ou un séparateur, sachant que les méthodes differ celon le cas.

Ben ce n'est pas un extrait d'un de mes codes et avant de pouvoir traiter QAction, QMenu et separator, j'attend d'avoir déjà une fonction qui marche qu'avec des QAction !

En fait j'ai trouvé d'où vient le problème avec ma classe : je surcharge << comme si je devais "écrire" dans une variable mais en fait j'écrit dans un pointeur (bon ce ne sont peut etre pas les bon termes, mais c'est comprehensible).

Mais je ne voit pas comment règler ce problème !

Déférence ton menu !

(*menu) << action1 << action2;

le mieux ne serait-il pas de faire 3 surcharges de operator<< ? :

MyQMenu& operator<<(QAction* ptr) {...}
MyQMenu& operator<<(QMenu* ptr) {...}
MyQMenu& operator<<(int n) {...} // separateur

Si on veut éviter de se prendre la tête oui.
Mais si un jour(ce qu je doute) le nombre de type devrais évoluer, avec les templates on est tranquille.

Merci beaucoup à vous tous piur votre participation à cette discussion !

La classe fonctionne parfaitement (j'utilise le défèrencement : (*menu) << action1 << ...), c'est exactement ce que j'attendais !

Encore merci beaucoup et à bientot !