C de conversions implicites et l'ambiguïté dans l'appel de fonction surchargée

Question

Je suis face au problème suivant: J'ai une classe V (dire un vecteur) dont je peux produire deux classes: CI et je (pense const_iterator et iterator). Si j'ai un const V alors je ne peux produire CI (détrompez de iterator et const_iterator).

Essentiellement, je voudrais subsitute (const V & V) avec (CI ci) et (V & V) avec (I i). De plus, je voudrais pouvoir passer encore un V obj directement aux fonctions qui attendent un I ou d'un CI d'où les conversions implicites de V et const V à CI et moi.

Le problème que je suis confronté est que si les fonctions surchargées peuvent établir une distinction entre (const V & V) et (V & V), ils ne peuvent pas "distinguer" entre (CI ci) et (I i) quand je passe un V obj.

Dans le code:

struct V {};

struct I 
{
    I( V& v ){}
};

struct CI
{
    CI( const V& v ){} //I would like to say const only 
};

void fun( I i )
{
    double x = 1.0;
}
void fun( CI ci )
{
    double x = 2.0;
}

void fun2( V& v )
{
    double x = 1.0;
}
void fun2( const V& v )
{
    double x = 2.0;
}

Avis que je aurais pu défini par l'opérateur de conversions en V (est-il équivalent?) Au lieu de définir les constructeurs en CI et moi maintenant:

V v;
const V cv;

fun2( v );
fun2( cv );

fun( v ); //AMBIGUOUS!
fun( cv );

Y at-il un moyen de résoudre ce problème sans ajouter de indirection supplémentaire (à savoir les fonctions ludiques ne peuvent pas être modifiés et v DOIVENT être transmis directement à l'amusement, mais vous êtes libre de tout modifier d'autre).

Merci d'avance pour toute aide!

Answer 1

Qu'est-ce que vous avez besoin ici est les constructeurs explicites:

struct I 
{
    explicit I( V& v ){}
};

struct CI
{
    explicit CI( const V& v ){} //I would like to say const only 
};

Trop de programmeurs C ++ donnent sur le mot-clé explicite pour les constructeurs. Tous les constructeurs unaire, paramétrées doivent être explicites par défaut. Les constructeurs implicites invitent les problèmes d'ambiguïté comme ceux-ci ainsi que conduisant à très Goofy, les processus de conversion rond-point qui peut facilement conduire à un code problématique et très inefficace.

Maintenant, vous êtes ensemble, problème d'ambiguïté résolu. Sans constructeurs explicites, vous ne pouvez pas éviter ce problème d'ambiguïté.

Pour le code client, vous avez besoin de modifier pour être explicite sur ses conversions:

V v;
const V cv;

fun2( I(v) );
fun2( CI(cv) );

fun( I(v) );
fun( CI(cv) );

Cette syntaxe sera nécessaire maintenant aux objets de construct I ou CI, mais qui est une bonne chose. Personne ne peut accidentellement introduire des problèmes d'ambiguïté plus

Answer 2

Qu'en est-il juste en utilisant typedefs?

typedef V& I;
typedef const V& CI;

Edit:

Non

. Voir les commentaires:)