Discussion :

[cedrix57]

Bonjour,
Je suis développeur C++/Qt et je me demandais quelles sont les manières de gérer le noms de class template qui deviennent long. Par exemple:

Code :

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

1
2
3
4
QList<QSharedPointer<AbstractParamsModel>>
ParamsListSelectionModel::selectedParamsMerged(
        const QString &lang)
{

Code :

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

1
2
3
4
QMultiMap<QString, SortedMap<QString, double>>
OrderManager::earningConvertedByArticles(
        const QDate &begin, const QDate &end) const
{

Trouvez-vous cela normal? Peut-on faire mieux? Que faites-vous dans ces situations?
Merci d'avance,
Cédric

[Bousk]

Salut,

tu peux faire un typedef ou using afin de donner un nom plus clair et concis.

[ternel]

C'est ce que je recommande tout le temps.

Il faut distinguer la forme (QMultiMap<QString, SortedMap<QString, double>>) du fond (earningConvertedByArticles_type).

La forme dit comment lire la chose, c'est uniquement intéressant pour la technique (la compilabilité), tandis que la forme explique ce que c'est.
Ce ne sont pas n'importe quelles clés ou valeurs. Cela dit, il manque un niveau d'explication, parce qu'il y a deux niveaux de clés.

La forme en elle même est inintéressante à la compréhension générale.
Personnellement, je vais même plus loin, en faisant de tels alias même pour des types simples (id_type, name_type, price_type, etc).

[Pyramidev]

Encore plus fort que les alias : le typage fort.
Par exemple, pour représenter un code d'utilisateur et un code de configuration, au lieu d'utiliser le type int, on crée deux types distincts, UserCode et ConfigCode. Aucun n'est implicitement convertible en l'autre.

Avantages :

• On récupère les avantages des alias. Par exemple, std::map<UserCode, ConfigCode> évoque plus précisément ce qu'il représente que std::map<int, int>.
• On a un autre avantage en bonus : le compilateur fait plus de contrôles. Par exemple, avec une fonction void link(int userCode, int configCode), on peut se tromper et appeler par mégarde link(configCode, userCode). Par contre, avec une fonction void link(UserCode userCode, ConfigCode configCode), ce genre d'erreur d'étourderie provoque une erreur de compilation.

Mais comme les types forts comme UserCode et ConfigCode risquent d'avoir un peu tous le même code (à moins qu'ils aient des invariants distincts), il convient de factoriser leur code grâce aux templates :

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
27
28
29
30
31
32
33
34
35
36
#include <functional>
#include <unordered_map>
 
template<class T, class FlagForDisambiguation>
class StrongType
{
public:
	using value_type = T;
	constexpr explicit StrongType() : m_value() {}
	template<class U = T>
	constexpr explicit StrongType(U&& value) : m_value(std::forward<U>(value)) {}
	constexpr const T& value() const {return m_value;}
	constexpr bool operator==(const StrongType& other) const {return m_value == other.m_value;}
	constexpr bool operator< (const StrongType& other) const {return m_value <  other.m_value;}
	constexpr bool operator> (const StrongType& other) const {return other   <  *this;}
	constexpr bool operator<=(const StrongType& other) const {return !(other <  *this);}
	constexpr bool operator>=(const StrongType& other) const {return !(*this <  other);}
private:
	T m_value;
};
 
template<class StrongTypeT>
struct StrongTypeHash
{
	size_t operator()(const StrongTypeT& param) const
	{
		return std::hash<typename StrongTypeT::value_type>()(param.value());
	}
};
 
template<class StrongTypeKey, class Value>
using StrongHashMap = std::unordered_map<StrongTypeKey, Value, StrongTypeHash<StrongTypeKey>>;
 
// Exemple d'utilisation :
using UserCode   = StrongType<int, struct FlagUserCode>;
using ConfigCode = StrongType<int, struct FlagConfigCode>;

[ternel]

J'approuve totalement.
Même si j'ai tendance à préférer les alias pour les structures un peu complexes, membres privés d'une classe.

Petite question:

Code :

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

using UserCode  = StrongType<int, struct FlagUserCode>;

C'est légal, de déclarer une struct dans un paramètre template?

[Bktero]

Hé mais c'est vachement cool ce StrongType ! Je me posais ces derniers temps la question pour faire ça justement : des typages forts sur des entiers

J'ai plusieurs questions sur ce code en revanche....

1) A quoi sert le 2e paramètre class FlagForDisambiguation ?

2) A quoi sert using value_type = T; ?

3) Pourquoi le constructeur par référence est-il template ? L'affectation à T donne t-elle une valeur par défaut au paramètre template (comme pour un paramètre formel de fonction) ?

[Bousk]

1) A quoi sert le 2e paramètre class FlagForDisambiguation ?

Comme le code l'indique c'est pour enlever l'ambiguité.
Sans ça, tous les StrongTypes<int> sont le même type et l'intérêt devient nul.

2) A quoi sert using value_type = T; ?

C'est un alias sur T. Alias non utilisé ici.

3) Pourquoi le constructeur par référence est-il template ? L'affectation à T donne t-elle une valeur par défaut au paramètre template (comme pour un paramètre formel de fonction) ?

C'est un constructeur qui prend une valeur pour l'assigner directement à ta classe.
Je suis pas sûr que le template soit utile ici, il suffirait d'avoir un constructeur StrongType(T&& value) à priori.
Peut-être que ça aide le compilo pour qqs conversions implicites ?

[ternel]

En fait, ca ne couvre que les conversions implicites. Les constructeurs par copie et par déplacement sont quand même générés.

C'est un peu traitre.

[Astraya]

Pour les entiers pas besoin de chercher compliqué...

Code :

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

1
2
3
4
5
6
7
 
enum class UserCode;
enum class ConfigCode;
UserCode u = (UserCode)0;
ConfigCode c = (ConfigCode)0;
ConfigCode a = u; // Erreur ici
UserCode b = c; //Erreur ici

Sinon un typedef typename ou usingsuffirais pour raccourcir ton nom.

Sinon si tu as des contraintes de typage forte... bas fait une class ou une struct. Ça doit se justifier par le simple fait que le typage soit fort...

[Pyramidev]

Code :

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

using UserCode  = StrongType<int, struct FlagUserCode>;

C'est légal, de déclarer une struct dans un paramètre template?

Ça compile avec GCC 7.1.0, mais j'avoue ne pas avoir vérifié dans la norme.

A quoi sert le 2e paramètre class FlagForDisambiguation ?

Les constructeurs et affectations de copie et mouvement générés par le compilateur ont un paramètre StrongType qui doit avoir à la fois le même T et le même FlagForDisambiguation. C'est ce qui empêche, par exemple, de convertir implicitement UserCode (alias de StrongType<int, struct FlagUserCode>) en ConfigCode (alias de StrongType<int, struct FlagConfigCode>).

A quoi sert using value_type = T; ?

Dans le code de mon précédent message, je l'ai utilisé ici :

Code :

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

return std::hash<typename StrongTypeT::value_type>()(param.value());

De manière générale, cela facilite le code de l'utilisateur quand ce dernier fait de la programmation par templates.

Pourquoi le constructeur par référence est-il template ?

• D'une part, je définis d'un coup le constructeur qui copie le paramètre et le constructeur qui déplace le paramètre, sans que cela ne provoque d'erreur de compilation dans le cas où T est une référence.
  Edit 18h45 : ajout d'une explication : si j'avais écrit :
  

  Code :

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

  1
  2
  	constexpr explicit StrongType(const T& value) : m_value(value)            {}
  	constexpr explicit StrongType(T&& value)      : m_value(std::move(value)) {}

  cela aurait provoqué une erreur de compilation dans le cas où T serait une référence. Par exemple, si T = int&, alors const T& et T&& désignent tous les deux int&, en vertu des reference collapsing rules. Les deux constructeurs ayant la même signature, cela provoque une erreur de compilation.
• D'autre part, j'accepte tout type U implicitement convertible en T. Par exemple, c'est pratique pour convertir char* en std::string.

L'affectation à T donne t-elle une valeur par défaut au paramètre template (comme pour un paramètre formel de fonction) ?

Oui. Dans template<class U = T>, T est l'argument par défaut du paramètre U.

Edit 19h04 : réponse à Astraya :

Pour les entiers pas besoin de chercher compliqué...

Code :

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

1
2
3
4
5
6
7
 
enum class UserCode;
enum class ConfigCode;
UserCode u = (UserCode)0;
ConfigCode c = (ConfigCode)0;
ConfigCode a = u; // Erreur ici
UserCode b = c; //Erreur ici

Bien vu.
Avec les enum class, lors de l'initialisation, pour éviter de répéter le type, on peut écrire :

Code :

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

1
2
auto userCode   = UserCode(1);
auto configCode = ConfigCode(5);

Par contre, si on veut convertir en int, à la place de value(), on doit passer par un cast :

Code :

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

int userCodeInt = static_cast<int>(userCode);