C++ 隐式转换和重载函数调用中的歧义

Question

我面临以下问题:我有一个类 V(比如一个 vector )，我可以从中生成两个类:CI 和 I(想想 const_iterator 和迭代器)。如果我有一个 const V，那么我只能生成 CI(再次想到 iterator 和 const_iterator)。

本质上，我想用 (CI ci) 替换 (const V& v)，用 (I i) 替换 (V& v)。此外，我仍然希望能够将 V obj 直接传递给需要 I 或 CI 的函数，从而实现从 V 和 const V 到 CI 和 I 的隐式转换。

我面临的问题是，虽然重载函数可以区分 (const V& v) 和 (V& v)，但当我传递 V obj 时，它们无法“区分”(CI ci) 和 (I i)。

在代码中:

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

请注意，我可以在 V 中定义转换运算符(是否等效？)，而不是在 CI 和 I 中定义构造函数。现在:

V v;
const V cv;

fun2( v );
fun2( cv );

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

有没有办法在不添加任何额外间接寻址的情况下解决这个问题(即不能修改 fun 函数并且 v 必须直接传递给 fun 但您可以自由修改其他所有内容)。

提前感谢您的帮助!

Answer 1

这里需要的是显式构造函数:

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

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

太多的 C++ 程序员忽略了构造函数的 explicit 关键字。默认情况下，所有一元参数化构造函数都应该是显式的。隐式构造函数会引发诸如此类的歧义问题，并导致非常愚蠢、迂回的转换过程，这些过程很容易导致有问题且效率非常低的代码。

现在您已经准备就绪，歧义问题已解决。如果没有显式构造函数，您将无法避免这种歧义问题。

对于客户端代码，您确实需要修改它以明确其转换:

V v;
const V cv;

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

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

现在需要这样的语法来构造 I 或 CI 的对象，但这是一件好事:没有人会再不小心引入歧义问题。