4

我面临以下问题：我有一个 V 类（比如一个向量），我可以从中生成两个类：CI 和 I（想想 const_iterator 和迭代器）。如果我有一个 const V，那么我只能产生 CI（再次考虑迭代器和 const_iterator）。

基本上我想用（CI ci）和（V＆v）用（I i）代替（const 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，但您可以自由修改其他所有内容）。

预先感谢您的任何帮助！

4

2 回答 2

4

您需要的是显式构造函数：

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

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

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

现在你已经设置好了，歧义问题解决了。如果没有显式构造函数，您将无法防止这种歧义问题。

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

V v;
const V cv;

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

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

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

于 2010-06-25T01:51:11.930 回答
0

只使用typedefs 怎么样？

typedef V& I;
typedef const V& CI;

编辑：

不。见评论:)

于 2010-06-24T18:03:47.730 回答