主页 / 问题 / 642257
Accepted
Alerr
Asked:2020-03-21 15:54:15 +0000 UTC2020-03-21 15:54:15 +0000 UTC

程序如何复制不同类的实例？

  • 772

有两个班级：A和B。

如果复制同一类的对象，则调用复制构造函数并复制相应的字段。但是如果你这样做：

A a;
B b;

a = (A)b;

在这种情况下复制如何工作？

c++

1 个回答

  1. Best Answer

    如果一个类B具有从类B 类型到类类型的可用类型转换运算符，则在生成临时类型对象的强制转换A表达式中调用它。使用子句中的复制或移动赋值运算符将此临时对象分配给对象(A)bAa

    a = (A)b;

    这是演示程序

    #include <iostream>

struct A
{
    A & operator =( const A & )
    {
        std::cout << "A::operator =" << std::endl;
        return *this;
    }
};

struct B
{
    operator A() const
    {
        std::cout << "operator B::A()" << std::endl;
        return A();
    }
};

int main() 
{
    A a;
    B b;

    a = ( A )b;

    return 0;
}

    其输出到控制台

    operator B::A()
A::operator =

    也可以使用函数说明符声明转换运算符explicit。例如，

    explicit operator A() const;

    或者更“扭曲”的转换示例，其中转换运算符为lvalueand重载rvalue。

    #include <iostream>

struct A
{
    A() 
    { 
        std::cout << "A::A()" << std::endl;
    }

    A( const A & )
    {
        std::cout << "A::A( const A & )" << std::endl;
    }

    A & operator =( const A & )
    {
        std::cout << "A::operator =( const A & )" << std::endl;
        return *this;
    }

    A & operator =( A && )
    {
        std::cout << "A::operator =( A && )" << std::endl;
        return *this;
    }
};

struct B
{
    explicit operator A() const &
    {
        std::cout << "operator A() &" << std::endl;
        return A();
    }

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

int main() 
{
    A a;
    B b;

    a = ( A )b;

    std::cout << std::endl;

    a = ( A )B();

    return 0;
}

    这个程序输出到控制台

    A::A()
operator A() &
A::A()
A::operator =( A && )

operator A() &&
A::A()
A::operator =( A && )

    例如，对于一个提案

    a = ( A )B();

    转换运算符在调用rvalue创建的临时对象上调用B()，

    operator A() &&

    然后在这个语句中创建一个类型的临时对象A

    A::A()

    使用移动赋值运算符将此临时对象分配给对象a

    A::operator =( A && )

    最简单的选择是类A具有转换构造函数。例如，

    #include <iostream>

struct A
{
    A() {}

    explicit A( const struct B & );

    A & operator =( const A & )
    {
        std::cout << "A::operator =( const A & )" << std::endl;
        return *this;
    }

};

struct B
{
};

A::A( const B & )
{
    std::cout << "A::A( const B & )" << std::endl;
}

int main() 
{
    A a;
    B b;

    a = ( A )b;

    return 0;
}

    将程序输出到控制台

    A::A( const B & )
A::operator =( const A & )

    在类定义A中声明了一个转换构造函数

    explicit A( const struct B & );

    在表达式中转换类型时调用( A )b

    最后，如果该类B是从该类派生的，A那么您可以只写

    a = b;

    在这种情况下，类对象被B隐式转换为类对象A，并调用类复制赋值运算符A。

    • 5

相关问题