C ++ conversioni implicite e ambiguità nella chiamata di funzione sovraccaricata

Question

Sono di fronte il seguente problema: Ho una classe V (dire un vettore) dal quale posso produrre due classi: CI ed io (penso a const_iterator e iterator). Se ho un const V allora posso solo produrre CI (ancora una volta pensare a iterator e const_iterator).

Essenzialmente desidero subsitute (const V & v) con (CI CI) e (V & v) con (I i). Inoltre Vorrei poter passare ancora un V obj direttamente alle funzioni che prevedono un I o un CI quindi impliciti conversioni da V e V const CI e io.

Il problema che sono rivestimento è che mentre le funzioni eccessivamente possono distinguere (const V & v) e (V & v), non possono "distinguere" tra (CI CI) e (i) quando passo un obj V.

Nel codice:

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;
}

Avviso avrei definito conversioni operatore in V (è equivalente?) Invece di definire costruttori di CI e I. Ora:

V v;
const V cv;

fun2( v );
fun2( cv );

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

C'è un modo per risolvere questo problema senza l'aggiunta di indirezione extra (vale a dire le funzioni di divertimento non possono essere modificati e V devono essere passato direttamente al divertimento, ma si è liberi di modificare tutto il resto).

Grazie in anticipo per qualsiasi aiuto!

Answer 1

Quello che vi serve è qui costruttori espliciti:

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

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

Troppi programmatori C ++ si affacciano la parola esplicita per i costruttori. Tutti, costruttori parametrizzati unarie dovrebbero essere espliciti per impostazione predefinita. costruttori impliciti invitano problemi di ambiguità come questi, così come porta a molto Pippo, processi di conversione rotonda che può facilmente portare a codice problematico e molto inefficiente.

Ora sei problema insieme, l'ambiguità risolto. Senza costruttori espliciti, non è possibile evitare questo problema ambiguità.

Per il codice del client, si ha bisogno di modificarlo per essere espliciti sulle sue conversioni:

V v;
const V cv;

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

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

Questa sintassi sarà richiesto subito a oggetti costrutto I o CI, ma che è una buona cosa:. Nessuno può accidentalmente introdurre più problemi di ambiguità

Answer 2

Che dire semplicemente utilizzando typedefs?

typedef V& I;
typedef const V& CI;

Modifica:

No. Vedere i commenti:)