Performance :
Ça dépend.
Dans votre cas particulier, il n'y aura pas de différence de performances car les deux seront également disposés en mémoire.
Dans un cas très spécifique (si vous utilisiez une structure vide comme l'un des membres de données), alors le std::pair<>
pourrait potentiellement utiliser l'optimisation de base vide (EBO) et avoir une taille inférieure à l'équivalent de la structure. Et une taille plus petite signifie généralement des performances plus élevées:
struct Empty {};
struct Thing { std::string name; Empty e; };
int main() {
std::cout << sizeof(std::string) << "\n";
std::cout << sizeof(std::tuple<std::string, Empty>) << "\n";
std::cout << sizeof(std::pair<std::string, Empty>) << "\n";
std::cout << sizeof(Thing) << "\n";
}
Impressions: 32, 32, 40, 40 sur idéone .
Remarque: Je ne connais aucune implémentation qui utilise réellement l'astuce EBO pour les paires régulières, mais elle est généralement utilisée pour les tuples.
Lisibilité :
Hormis les micro-optimisations, cependant, une structure nommée est plus ergonomique.
Je veux dire, map[k].first
n'est pas si mal alors qu'il get<0>(map[k])
est à peine intelligible. Contraste avec map[k].name
lequel indique immédiatement ce que nous lisons.
C'est d'autant plus important lorsque les types sont convertibles entre eux, car les échanger par inadvertance devient une réelle préoccupation.
Vous voudrez peut-être également en savoir plus sur le typage structurel vs nominal. Ente
est un type spécifique qui ne peut être opéré que par des choses qui s’attendent Ente
, tout ce qui peut opérer std::pair<std::string, bool>
peut les opérer ... même lorsque le std::string
ou bool
ne contient pas ce qu’il attend, car il std::pair
n’a pas de sémantique associée.
Entretien :
En termes de maintenance, pair
c'est le pire. Vous ne pouvez pas ajouter de champ.
tuple
convient mieux à cet égard, tant que vous ajoutez le nouveau champ, tous les champs existants sont toujours accessibles par le même index. Ce qui est aussi impénétrable qu'auparavant, mais au moins vous n'avez pas besoin d'aller les mettre à jour.
struct
est clairement le gagnant. Vous pouvez ajouter des champs où vous en avez envie.
En conclusion:
pair
est le pire des deux mondes,
tuple
peut avoir un léger avantage dans un cas très spécifique (type vide),
- utiliser
struct
.
Remarque: si vous utilisez des getters, vous pouvez utiliser vous-même l'astuce de base vide sans que les clients n'aient à le savoir comme dans struct Thing: Empty { std::string name; }
; c'est pourquoi l' encapsulation est le prochain sujet que vous devriez vous préoccuper.
std::pair
est une structure.