monsieurmoche a écrit 78 commentaires

Moi aussi j'ai eu envie de répondre « Non », car comme tout le monde ici je prends un malin plaisir à taper sur Hadopi à la moindre occasion. Mais il faut pas se leurrer…
Malgré le fait que cette loi soit un fiasco total, la peur du gendarme va faire son petit effet sur la majorité de la population qui ne sait pas (et ne saura jamais) ce qu'est un tunnel VPN.

Tiens, allez, si, je vous montre. C'est tellement cradingue et inexpressif que ça vaut le coup d'être vu :

/*
* Utility types
*/
typedef char yes_type;

struct no_type
{
char padding[8];
};



/*
* list_node type trait
*/
namespace list_node_check
{
template<class T>
static
yes_type
check_sig(typename T::item*);

template<class T>
static
no_type
check_sig(...);
}

template<class T>
struct is_list_node
{
static const bool value = sizeof(list_node_check::check_sig(0)) == sizeof(yes_type);
};



/*
* optional_node type trait
*/
template<class T>
struct is_optional_node
{
static const bool value = false;
};

template<class T>
struct is_optional_node<syntax_nodes::optional_node>
{
static const bool value = true;
};


Un exemple d'intuitivité.

Et encore, je suis sûr qu'on peut trouver des alternatives bien pires à ce qu'auraient proprement permis les concepts.

Oui m'enfin à ce point là autant dire que le C++ n'est que du sucre syntaxique par rapport au C (ex : GTK+ est codé en C, mais sur paradigme objet)…

SFINAE + boost::enable_if, c'est un peu la solution de rafistolage pour arriver à ses fins. On arrive pas à une lisibilité de code exemplaire, rien qu'avec les paramètres fantômes :


//overload for list nodes
template<class SyntaxNodeT>
SyntaxNodeT
convert_node
(
const tree_node_t& node,
typename boost::enable_if<syntax_nodes::utility::is_list_node>::type* = 0
)
{
return convert_list_node(node);
}

//overload for optional nodes
template<class SyntaxNodeT>
SyntaxNodeT
convert_node
(
const tree_node_t& node,
typename boost::enable_if<syntax_nodes::utility::is_optional_node>::type* = 0
)
{
return convert_optional_node(node);
}

//etc...


Je préfèrerais écrire ça :

//overload for list nodes
template<ListNode SyntaxNodeT>
SyntaxNodeT
convert_node(const tree_node_t& node)
{
return convert_list_node(node);
}

//overload for optional nodes
template<OptionalNode SyntaxNodeT>
SyntaxNodeT
convert_node(const tree_node_t& node)
{
return convert_optional_node(node);
}

//etc...


Et encore, je vous montre pas la tronche des type traits qu'on se serait bien épargné de taper.