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;