C ++ conversioni implicite e ambiguità nella chiamata di funzione sovraccaricata
-
29-09-2019 - |
Domanda
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!
Soluzione
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à
Altri suggerimenti
Che dire semplicemente utilizzando typedef
s?
typedef V& I;
typedef const V& CI;
Modifica:
No. Vedere i commenti:)