c++ - 如何争论多个显式转换函数？

Question

请问有没有人可以给我解释一下？

我有一个 A 类，它有一个 std::vector 作为成员变量。我希望能够使用显式转换函数 get ...

要么 ... 对该 vector 的引用，以便我可以更改其内容

或者...对该 vector 的 const 引用，这样我可以检查它但不能更改它

理想情况下... vector 的拷贝也很好

#include <vector>
#include <iostream>

using BoolColumn = std::vector<bool>;
using BoolColumnReference = BoolColumn&;
using BoolColumnConstReference = BoolColumn const &;

class A
{
public:
  A(BoolColumn&& bVec) : m_bools(std::move(bVec)) {}

  explicit operator BoolColumn () {
    std::cout << "  Inside BoolColumn converter" << std::endl;
    return m_bools;
  }

  explicit operator BoolColumnReference () {
    std::cout << "  Inside BoolColumnReference converter" << std::endl;
    return m_bools;
  }

  explicit operator BoolColumnConstReference () const {
    std::cout << "  Inside BoolColumnConstReference converter" << std::endl;
    return m_bools;
  }

private:
  BoolColumn m_bools;
};

int main()
{
  BoolColumn bVec({true, false, true, false, true, false});

  A a(std::move(bVec));

  BoolColumn bc(a);
  BoolColumn bc2 = (BoolColumn)a;
  BoolColumn bc3 = BoolColumn(a);
  BoolColumn bc4 = static_cast<BoolColumn>(a);

  BoolColumn & bcr(a);
  BoolColumn & bcr2 = (BoolColumnReference)a;
  BoolColumn & bcr3 = BoolColumnReference(a);
  BoolColumn & bcr4 = static_cast<BoolColumnReference>(a);
  bcr[0] = false;

  BoolColumn const & bccr(a);
  BoolColumn const & bccr2 = (BoolColumnConstReference)a;
  BoolColumn const & bccr3 = BoolColumnConstReference(a);
  BoolColumn const & bccr4 = static_cast<BoolColumnConstReference>(a);
  // bccr[0] = false; // ... error C2106: '=': left operand must be l-value (good!)
}

我所有进入不同转换器的努力都失败了......我总是以“BoolColumnReference”转换器结束

请问我哪里错了？

Answer 1

#include <iostream>

class A {
};

class B {
public:
  explicit operator A () {
    std::cout << "COPY" << std::endl;
    return a;
  }

  explicit operator A& () {
    std::cout << "REF" << std::endl;
    return a;
  }

  explicit operator const A& () const {
    std::cout << "CONST REF" << std::endl;
    return a;
  }

 private:
   A a;
 };

int main() {
  B b;
  A a(b);
}

我创建了上面代码的简化版本来说明这里发生的事情。当我们调用 A 构造函数以从 B 的实例创建 A 的实例时，我们实际上是在使用从用户定义的转换运算符返回的参数调用 A 的复制构造函数。

所以操作顺序:

1. 检查 A 中采用类型 B 的构造函数
2. 将复制构造函数与转换运算符返回的值一起使用。

类型A中没有定义采用类型B的复制构造函数。因此使用了隐式复制构造函数

A(A& a) {
}

这意味着我们将始终使用运算符 A&，因为这是隐式转换运算符的正确类型。

但是，如果我们将 B::a 声明为 const，那么将调用 A 中的 const 复制构造函数，这意味着程序将打印“CONST REF”。