Discussion :

[Kaamui]

Bonjour tout le monde,

voilà je me remet au C++ après des années de sommeil

J'étais en train de faire des tests sur des variadic templates et je me suis demandé s'il y avait possibilité d'itérer plus "modernement" sur la liste des arguments d'une variadic function qu'avec les fonctions de la SL :

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
 
#include <vector>
 
template <class T>
class A
{
    private :
        std::vector<T> v;
 
    public :
        A(T& ts...);       
};
 
template <class T>
A<T>::A(T& ts...)
{
    std::vector<T> temp = { ts... };
    for (auto t : temp)
        v.push_back(t);
}

Le compilateur me répond que je fais une mauvaise utilisation de "ts..." car, je cite :

||=== Build: Debug in POO (compiler: GNU GCC Compiler) ===|
POO\main.cpp||In constructor 'A<T>::A(T&, ...)': |
POO\main.cpp|32|error: expansion pattern 'ts' contains no argument packs|
POO\main.cpp||In instantiation of 'A<T>::A(T&, ...) [with T = int]': |
POO\main.cpp|40|required from here|
main.cpp|32|error: could not convert '{<expression error>}' from '<brace-enclosed initializer list>' to 'std::vector<int, std::allocator<int> >'|
||=== Build failed: 2 error(s), 2 warning(s) (0 minute(s), 0 second(s)) ===|

N'y a-t'il pas une manière plus ou moins aussi élégante de parcourir ce type de liste ?

Merci d'avance

[Pyramidev]

Bonjour,

Un code équivalent qui compile et fonctionne :

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
#include <vector>
 
template<class T>
class A
{
    private :
        std::vector<T> v;
 
    public :
        template<class... Args>
        A(Args&&... args);       
};
 
template<class T>
template<class... Args>
A<T>::A(Args&&... args)
{
    std::vector<T> temp = { std::forward<Args>(args)... };
    for(auto& t : temp)
        v.push_back(t);
}

Cela dit, il est inutile de créer un vecteur temporaire. Il vaut mieux écrire directement :

Code :

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

1
2
3
4
5
6
template<class T>
template<class... Args>
A<T>::A(Args&&... args) :
    v({ std::forward<Args>(args)... })
{
}

Concernant les parameter packs, tu trouveras tous les détails ici : http://en.cppreference.com/w/cpp/lan...parameter_pack

[Kaamui]

oui pour le temp c'était à force de tenter des écritures pour voir d'où venait le problème.

Merci pour les infos.

[Bktero]

A quoi sert le std::forward dans ce code ?

Code :

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

1
2
3
4
5
6
template<class T>
template<class... Args>
A<T>::A(Args&&... args) :
    v({ std::forward<Args>(args)... })
{
}

J'ai l'impression que ça fonctionne très bien sans. Merci

[Pyramidev]

A quoi sert le std::forward dans ce code ?

C'est pour éviter des copies inutiles dans le cas où des arguments sont des rvalues. Si tu essaies le code suivant :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
struct Test
{
    Test() = default;
    Test(const Test&) {std::cout << "copie ";}
    Test(Test&&)      {std::cout << "deplacement ";}
};
 
int main()
{
	A<Test> monTest(Test{});
	return 0;
}

Sans le std::forward, ça devrait t'afficher "copie copie". Avec le std::forward, ça devrait t'afficher "deplacement copie".

De manière générale, voici un lien qui explique bien le fonctionnement et l'intérêt de std::forward :
http://stackoverflow.com/questions/3...582313#3582313

[Bktero]

Bon... Je ne vois déjà pas où est appelé la première fois le constructeur par copie. cppreference m'a fait comprendre que Test {} provoque un appel au constructeur par copie, std::forward provoque l'appel au constructeur par déplacement. Quand je lis A(Args&&... args); et notamment le &&, dois-je comprendre que c'est un constructeur par déplacement ou pas du tout ?

Pourquoi est-ce que le code suivant ne fait pas appel au constructeur par déplacement ?

Code :

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

1
2
3
4
5
6
int main()
{
    Test test = Test { };
    A<Test> monTest(test);
    return 0;
}

Je m'en vais potasser ton lien