est-il possible de construire des arguments variadiques pour fonctionner par la surcharge opérateur de la virgule de l'argument? Je veux voir un exemple comment le faire .., peut-être quelque chose comme ceci:
template <typename T> class ArgList {
public:
ArgList(const T& a);
ArgList<T>& operator,(const T& a,const T& b);
}
//declaration
void myFunction(ArgList<int> list);
//in use:
myFunction(1,2,3,4);
//or maybe:
myFunction(ArgList<int>(1),2,3,4);
4 Réponses :
Les opérateurs ont un nombre fixe de paramètres. Vous ne pouvez pas changer cela. L'opérateur des virgules prend deux arguments. Donc non. Vous pouvez faire rouler une version personnalisée et cascade cependant, avec certains efforts.
L'opérateur des virgules prend un argument.
@Stilescrisis L'opérateur des virgules peut réellement prendre un ou deux arguments. En utilisant deux arguments, vous spécifiez que la virgule peut apparaître avant l'opérande et après un autre type. C'est encore moins commun que la surcharge régulière des virgules One-Ag, qui est déjà assez rare, mais elle existe.
Non, ce n'est pas le cas. La liste des valeurs séparées par l'opérateur des virgules sera évaluée comme une valeur unique. Par exemple:
1,2,3
C'est ce que je veux, la fonction reçoit toujours une valeur unique, mais cette valeur a été construite par virgule opérateur, je vois qu'il était possible de faire de MyObject Object = (1,2,3), j'ai pensé qu'il était possible de le modifier comme étant Travailler avec MyObject comme argument de la fonction
@uray Désolé, c'est complètement flou. Moyens Modifiez votre question pour illustrer ce que vous voulez faire. Par exemple, quels sont les types d'A, B, C et D dans votre code d'exemple? N'oubliez pas que vous ne pouvez pas surcharger des opérateurs pour les types «intégrés».
@uray, le problème est que vous devez mettre entre la parenthèse autour de votre liste d'arguments, car le compilateur se plaint autrement d'une quantité supérieure d'arguments à la fonction, c'est-à-dire qu'il ne comprendra pas que ce sont pas d'arguments multiples.
Peut-être quelque chose comme ceci: Utilisation serait:
C'est une sorte de possible, mais l'utilisation ne sera pas très belle. Pour exxample: Cette lacune sera corrigée en C ++ 0x où vous pouvez faire: ou même avec des types mixtes:
initialiszer_list? Je ne suis pas sûr car il a besoin d'un soutien intégré de la langue au travail. Mais les deux extraits compilent déjà avec GCC 4.4.1 avec STD = C ++ 0x
Pouvons-nous avoir une virgule d'opérateur surchargée surchargée statique mondiale comme: Modèle
Comme Neil déjà mentionné, pas pour les types "intégrés" , vous devez donc démarrer les expressions avec quelque chose comme list_of () .
Une autre chose qui éliminerait la nécessité d'une parenthèse supplémentaire serait d'utiliser un autre opérateur: impression (list_of list_of Imprimer (make_list_of (1)% 2% 3); mais il est moche à tous égards. S'il était possible de la simuler bien, C ++ 0x n'ajoute pas les modifications apportées à la langue.
Pourquoi avez-vous besoin de le faire en utilisant l'opérateur des virgules? Par exemple. Boost.Assign vous donne déjà une syntaxe soignée, mais elle utilise
opérateur () .Parce que je veux que l'utilisation soit aussi simple que la mycée (1,2,3) et non mycée (boost :: list_of (1) (2) (3))