Discussion :

[guillaume07]

C'est possible un array de lambda ? (ça devrait, mais impossible de compiler chez moi, ni sur VS2012, ni sur gcc 4.8.0)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array<T, sizeof...(Args)+1> {
	return std::array<T, sizeof...(Args)+1>({{t, args...}});
}
 
int main() {
	auto f = [](int i)->int { return i; };
	auto f2 = [](int i)->int { return i*2; };
 
	std::array<decltype(f), 2> arr = {{ f, f2 }};
	auto arr2 = make_array(f, f2);
 
	return 0;
}

Mais au moins l'erreur est originale

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
 
#include<array>
#include<functional>
 
 
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array< std::function<int(int)>, sizeof...(Args)+1> {
   return {{t, args...}};
}
 
int main() {
	auto f = [](int i)->int { return i; };
	auto f2 = [](int i)->int { return i*2; };
 
	auto arr2 = make_array(f, f2);
 
	return 0;
}

bon certes valable uniquement pour ce type précis de lambda....

[Emmanuel Deloget]

C'est possible un array de lambda ? (ça devrait, mais impossible de compiler chez moi, ni sur VS2012, ni sur gcc 4.8.0)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array<T, sizeof...(Args)+1> {
	return std::array<T, sizeof...(Args)+1>({{t, args...}});
}
 
int main() {
	auto f = [](int i)->int { return i; };
	auto f2 = [](int i)->int { return i*2; };
 
	std::array<decltype(f), 2> arr = {{ f, f2 }};
	auto arr2 = make_array(f, f2);
 
	return 0;
}

Mais au moins l'erreur est originale

Mince.

Ca vient peut-être du fait que chaque lambda pourrait bien avoir un type unique. Du coup, decltype(f2) != decltype(f) ; mais la norme C++ dit que les messages d'erreur doivent être le plus simple possible - du coup, le compilateur transforme le type réel en un nom de type lisible (et il apparait identique, vu que la signature des lambda est identique).

[guillaume07]

Mince.

Ca vient peut-être du fait que chaque lambda pourrait bien avoir un type unique. Du coup, decltype(f2) != decltype(f) ; mais la norme C++ dit que les messages d'erreur doivent être le plus simple possible - du coup, le compilateur transforme le type réel en un nom de type lisible (et il apparait identique, vu que la signature des lambda est identique).

http://liveworkspace.org/code/2jJoBz$33

Code :

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

source.cpp: In instantiation of 'std::array<T, (sizeof (Args ...) + 1)> make_array(T, Args ...) [with T = main()::__lambda0; Args = {main()::__lambda1}]':

T = main()::__lambda0
Args = {main()::__lambda1}


===> type unique


make_array générique:

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
#include<array>
#include<functional>
 
 
template<typename U, typename T, typename ... Args>
auto make_array(U u, T t, Args ... args) -> std::array< decltype(u), sizeof...(Args)+1> {
   return {{t, args...}};
}
 
int main() {
   auto f = [](int i)->int { return i; };
	auto f2 = [](int i)->int { return i*2; };
 
	auto arr2 = make_array(std::function<int(int)>(), f,  f2);
 
	return 0;
}

[Emmanuel Deloget]

http://liveworkspace.org/code/2jJoBz$33

Code :

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

source.cpp: In instantiation of 'std::array<T, (sizeof (Args ...) + 1)> make_array(T, Args ...) [with T = main()::__lambda0; Args = {main()::__lambda1}]':

T = main()::__lambda0
Args = {main()::__lambda1}


===> type unique

Plus exactement, le standard dit (parce que, restons honnètes, même si ça temps à s'améliorer les compilateurs font souvent un peu ce qu'ils veulent au niveau du respect du standard)

The type of the lambda-expression (which is also the type of the closure object) is a unique, unnamed non-union class type — called the closure type — whose properties are described below. This class type is not an aggregate (8.5.1). The closure type is declared in the smallest block scope, class scope, or namespace scope that contains the corresponding lambda-expression. [ Note: This determines the set of namespaces and classes associated with the closure type (3.4.2). The parameter types of a lambda-declarator do not affect these associated namespaces and classes. — end note ] An implementation may define the closure type differently from what is described below provided this does not alter the observable behavior of the program other than by changing:

• the size and/or alignment of the closure type,
• whether the closure type is trivially copyable (Clause 9),
• whether the closure type is a standard-layout class (Clause 9), or
• whether the closure type is a POD class (Clause 9).

An implementation shall not add members of rvalue reference type to the closure type.

Donc, effectivement, un array de lambda, c'est impossible a créer.

Par contre, sans ce cas particulier, une implémentation de make_array() pourrait renvoyer un array d'objets fonctions polymorphiques - quelque chose qui, selon moi, devrait figurer dans un proposal digne de ce nom.

[JolyLoic]

Donc, effectivement, un array de lambda, c'est impossible a créer.

<Mode chipotage="On">
C'est possible, à condition que toutes les lambdas soient du même type, et que l'array reste vide

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <array>
 
using namespace std;
 
int main()
{
	auto l = [](int i){return 2*i;};
	typedef decltype(l) Lambda;
	array<Lambda, 42> myArray;
}

</Mode>

[guillaume07]

un array de std::function ça marche donc si on peut infiné

[Kalith]

make_array générique:

Tu peux aussi utiliser le code que j'ai posté sur la page précédente pour faire la même chose, en spécifiant explicitement le type T lors de l'appel à la fonction :

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
#include <array>
#include <functional>
 
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array<T, sizeof...(Args)+1> {
    return std::array<T, sizeof...(Args)+1>({{t, args...}});
}
 
int main() {
    auto f = [](int i)->int { return i; };
    auto f2 = [](int i)->int { return i*2; };
 
    auto arr2 = make_array<std::function<int(int)>>(f, f2);
 
    return 0;
}

[guillaume07]

Tu peux aussi utiliser le code que j'ai posté sur la page précédente pour faire la même chose, en spécifiant explicitement le type T lors de l'appel à la fonction :

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
#include <array>
#include <functional>
 
template<typename T, typename ... Args>
auto make_array(T t, Args ... args) -> std::array<T, sizeof...(Args)+1> {
    return std::array<T, sizeof...(Args)+1>({{t, args...}});
}
 
int main() {
    auto f = [](int i)->int { return i; };
    auto f2 = [](int i)->int { return i*2; };
 
    auto arr2 = make_array<std::function<int(int)>>(f, f2);
 
    return 0;
}

je pensais pas qu'on pouvait que partiellement spécifier le type des paramètres templates au moment de l'appel

solution sans préciser le paramètre template:

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
 
#include <array>
#include <functional>
 
template<typename T> struct remove_class { };
template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const>{using type = R(A...);};
 
template<typename F> using make_function_type = 
std::function<typename remove_class<decltype(&std::remove_reference<F>::type::operator())>::type>;
 
template<typename T, typename ... Args>
auto make_array(T&& t, Args&& ... args) -> std::array<make_function_type<T>, sizeof...(Args)+1>
{
    return {{std::forward<T>(t), std::forward<Args>(args)...}};
}
 
int main()
{ 
   auto f = [](int i)->int { return i; };
   auto f1 = [](int i)->int { return i; };
 
    make_array (f,f1);
 
   return 1;
}

[Flob90]

je pensais pas qu'on pouvait que partiellement spécifier le type des paramètres templates au moment de l'appel

Tant que le compilateur est capable de déduite ceux que tu ne précices pas (dans l'ordre donc) il n'y a pas de problème. Pour faire simple : il est en général inutile de préciser l'ensemble des paramètres template qui sont utilisés dans les types des paramètres de la fonction.

[camboui]

Boost Assignment ?

Code :

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

1
2
vector<int> v;
v += 1,2,3,4,5,6,7,8,9;