Question

我有以下代码：

class B {
public:
    B(const std::string& str):m_str(str) { }
    B(const B& b):m_str(b.m_str) { }
    B& operator=(const B& b) { m_str = b.m_str; return *this; }
private:
    std::string m_str;
};

main()
{
    std::string a = "abc";
    B b(a);
}

B类属于客户端。我无法改变它，我甚至可能不知道它的具体名称（“B”只是一个例子）;我所知道的是有一个客户端类，它的构造函数接受一个std :: string。现在我想将main（）中的“a”类型从std :: string更改为A，如下所示：

class A {
public:
      A(const std::string& str):m_str(str) { }
      A(const char *str):m_str(str) { }
      A(const A& a):m_str(a.m_str) { }
      A& operator=(const A& a) { m_str = a.m_str; return *this; }

private:
      std::string m_str;
};

所以现在我有了一个新的main（）：

main()
{
    A a = "abc";
    B b(a);
}

这不能正确编译。如果不改变新的main（），我能做些什么吗？我不能改变B类，A类不应该以任何方式引用B类。谢谢！

Answer 1

添加演员

class A {
public:
   ....
  operator const std::string()
    {
        return m_str;
    }

Answer 2

将用户定义的转换函数添加为：

class A
{
 public:
    //other code
    operator std::string()
    {
        return m_str;
    }
    //...
};

这允许你写下这些：

B b(a); //which is what you want
std::string s = a; //this is also okay;

void f(std::string s) {}

f(a); //a converts into std::string, by calling user-defined conversion function

但你不能这样写：

 const A ca("hi");
 std::string s = ca; //error

因为ca是一个const对象，它不能调用非const用户定义的转换函数。

请注意，用户定义的转换函数按值返回字符串，这意味着它返回原始字符串的副本。因此，您可能希望通过将其定义为：

来避免这种情况

operator const std::string &() const
{
     return m_str;
}

现在，你可以写下这个：

const A ca("hi");
std::string s = ca; //ok

A a("hi");
std::string s = a; //ok

Answer 3

怎么样

int main() //note the correct declaration of main
{
    A a = "abc";
    B b(a.GetString()); //GetString returns m_str;
}

顺便说一句，所有复制构造函数和复制赋值运算符的定义都与编译器为您自动生成的定义一致。

修改
我刚刚注意到main()不应该改变的约束。在这种情况下，您可以定义从A到字符串的conversion function（但它可能很危险，请注意）。

class A { ... operator std::string() const {return m_str; } };

Answer 4

将其添加到A类：

operator std::string () { return m_str; }

C ++类转换可能吗？

4 个答案: