所以我有一个提供字符串类型的现有库。

它像这样隐式地转换成 C 风格的字符串:

struct TypeIDoNotOwn {
  TypeIDoNotOwn() {}
  TypeIDoNotOwn(TypeIDoNotOwn const&) {}
  TypeIDoNotOwn(char const*) {}

  TypeIDoNotOwn& operator=(TypeIDoNotOwn const&) {return *this;}
  TypeIDoNotOwn& operator=(char const*) {return *this;}

  operator char const*() const {return nullptr;}
};

它还有其他方法，但我认为它们不重要。这些方法有主体，但我的问题不涉及它们，所以我把它们 stub 了。

我想做的是创建一个可以与上述类型以及“原始字符串常量” 相对互换使用的新类型。我希望能够获取 TypeIDoNotOwn 的实例，并将其替换为 TypeIDoOwn，然后编译代码。

例如，这组操作:

void test( TypeIDoNotOwn const& x ) {}

int main() {
  TypeIOwn a = TypeIDoNotOwn();
  TypeIDoNotOwn b;
  a = b;
  b = a;
  TypeIOwn c = "hello";
  TypeIDoNotOwn d = c;
  a = "world";
  d = "world";
  char const* e = a;
  std::pair<TypeIDoNotOwn, TypeIDoNotOwn> f = std::make_pair( TypeIOwn(), TypeIOwn() );
  std::pair<TypeIOwn, TypeIOwn> g = std::make_pair( TypeIDoNotOwn(), TypeIDoNotOwn() );
  test(a);
}

如果我将上面的 TypeIOwn 替换为 TypeIDoNotOwn，它会编译。如何在不修改 TypeIDoNotOwn 的情况下使用 TypeIOwn 进行编译？而且无需在声明时引入任何类型转换或类型更改以外的任何更改？

我的第一次尝试看起来有点像这样:

struct TypeIOwn {
  TypeIOwn() {}
  operator char const*() const {return nullptr;}
  operator TypeIDoNotOwn() const {return {};}
  TypeIOwn( TypeIOwn const& ) {}
  TypeIOwn( char const* ) {}
  TypeIOwn( TypeIDoNotOwn const& ) {}
  TypeIOwn& operator=( char const* ) {return *this;}
  TypeIOwn& operator=( TypeIOwn const& ) {return *this;}
  TypeIOwn& operator=( TypeIDoNotOwn const& ) {return *this;}
};

但我得到了一系列模棱两可的重载:

 main.cpp:31:4: error: use of overloaded operator '=' is ambiguous (with operand types 'TypeIDoNotOwn' and 'TypeIOwn')
         b = a;
         ~ ^ ~
 main.cpp:9:17: note: candidate function
         TypeIDoNotOwn& operator=(TypeIDoNotOwn const&) {return *this;}
                        ^
 main.cpp:10:17: note: candidate function
         TypeIDoNotOwn& operator=(char const*) {return *this;}

和

 /usr/include/c++/v1/utility:315:15: error: call to constructor of 'TypeIDoNotOwn' is ambiguous
             : first(_VSTD::forward<_U1>(__p.first)),
               ^     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 main.cpp:40:51: note: in instantiation of function template specialization 'std::__1::pair<TypeIDoNotOwn, TypeIDoNotOwn>::pair<TypeIOwn, TypeIOwn>' requested here
       std::pair<TypeIDoNotOwn, TypeIDoNotOwn> f = std::make_pair( TypeIOwn(), TypeIOwn() );
                                                   ^
 main.cpp:7:7: note: candidate constructor
       TypeIDoNotOwn(TypeIDoNotOwn const&) {}
       ^
 main.cpp:8:7: note: candidate constructor
       TypeIDoNotOwn(char const*) {}
       ^

在我的“真实”代码中，我还有其他运算符，例如 += 和 ==，它们也有类似的问题。

真正问题的范围很大；数百万行代码，我想在数千个位置将 TypeIDoNotOwn 换成 TypeIOwn，而不是在其他数百个位置。在数千个位置，它们以导致转换不明确的方式进行交互。

我已经解决了一个函数在 100 多个位置采用 TypeIDoNotOwn& 的问题，方法是用一个宏来创建一个临时对象，该对象创建一个 TypeIDoNotOwn从 TypeIOwn 返回一个引用，然后当临时对象被销毁时将其复制回 TypeIOwn。我想避免必须执行类似的扫描来处理 ==、+=、=、复制构造和类似情况。

Live example .

如果我尝试删除 operator TypeIDoNotOwn 以消除歧义，则需要进行转换的其他情况将无法正常工作(因为它需要 2 个用户定义的结构才能从 TypeIOwn 到 TypeIDoNotOwn)，然后需要进行显式转换(在许多 100 或 1000 个位置)

如果我能让一个转换看起来比另一个更糟糕，那它就可以了。如果做不到这一点，我可以尝试通过重载具有完全匹配的免费 TypeIDoNotOwn == TypeIOwn 运算符来修复非 operator= 和复制构造的情况(其他情况类似) ，但这并没有让我了解构造、函数调用和赋值。

最佳答案

通常需要注意的是，这是 C++，肯定会有一些聪明的解决方法……不。

让我们来看看您的用例。您希望复制初始化和复制分配都起作用:

TypeIOwn a = ...;
TypeIDoNotOwn b = a;  // (*)
TypeIDoNotOwn c;
c = a;                // (*)

这需要:

operator TypeIDoNotOwn();

如果您只提供operator const char*()，那么赋值会起作用，但复制初始化会失败。如果你同时提供了两者，那么它是模棱两可的，因为没有办法强制一个转换优先于另一个(强制转换排序的唯一真正方法是创建类型层次结构，但你不能继承 const char* 所以你不能真正强制它工作)。

一旦我们开始只使用一个转换函数，示例列表中唯一不起作用的代码是:

const char* e = a; // error: no viable conversion

此时，您必须添加一个成员函数:

const char* e = a.c_str();

两个 pair 结构都可以很好地与一个转换函数一起工作。但仅仅通过淘汰的过程，我们不能同时拥有。

关于c++ - 创建兼容的 String 对象，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/43522188/