Résolution de surcharge avec deux énumérations

Question

Nous avons un code qui ressemble à peu près comme ceci:

// Two enums that differ entirely. 
enum A { a1, a2 }; 
enum B { b1, b2 }; 

// Functions to convert in some meaningful way between them 
A convert(B); 
B convert(A); 

Maintenant, notre compilateur va et fait exactement ce que nous nous attendons à. convert(a1) appellera B convert(A), et ainsi de suite. Cependant, quand nous utilisons Lint pour regarder notre code, il se plaint de l'erreur 31. Nous suspectons que c'est parce que le type intégral sous-jacent des énumérations est le même, et donc Lint pourrait les traiter comme tel.

La question que j'ai est: est le code standard, ou est-ce une utilisation accidentelle d'une fonctionnalité de compilateur?

Answer 1

Ce code est standard et correct. Le bug est dans LINT

Answer 2

Je ne suis pas sûr qu'il serait considéré comme standard de renvoyer un enum plutôt qu'un typedef'd enum de cette façon, mais je pourrais me tromper. Aussi, en tant que programmeur C, j'éviterais d'utiliser le même nom pour les deux fonctions (car la surcharge est impossible), mais j'ai tendance à l'éviter en C++ de toute façon car il est facile de faire une erreur.

Si je devais écrire ce code, j'aurais quelque chose comme:

typedef enum { a1, a2 } A; 
typedef enum { b1, b2 } B; 
A convertBToA(B BInstance); 
B convertAToB(A AInstance); 

Cependant, je me attends à Lint pour être heureux (en C++) avec:

typedef enum { a1, a2 } A; 
typedef enum { b1, b2 } B; 
A convert(B BInstance); 
B convert(A AInstance);