Question

我有一个简单的句柄类，用于控制继承类的对象。这是一个简单的实现：

#include <iostream>

class ParametersInner
{

  public:
    ParametersInner() {}
    virtual ~ParametersInner() {}

    virtual ParametersInner *clone() const = 0;
};

class ParametersConstant : public ParametersInner
{
  public:
    ParametersConstant(){};

    virtual ParametersInner *clone() const { return new ParametersConstant(*this); }
};

class Parameters
{
  public:
    Parameters(const ParametersInner &innerObject)
    {
        std::cout << "CC (and implicit conversion)\n";
        InnerObjectPtr = innerObject.clone();
    }
    Parameters(const Parameters &original)
    {
        std::cout << "CC\n";
        InnerObjectPtr = original.InnerObjectPtr->clone();
    }
    Parameters &operator=(const Parameters &original)
    {
        std::cout << "AO\n";
        if (this != &original)
        {
            delete InnerObjectPtr;
            InnerObjectPtr = original.InnerObjectPtr->clone();
        }
        return *this;
    }

    virtual ~Parameters() { delete InnerObjectPtr; }

  private:
    ParametersInner *InnerObjectPtr;
};

int main()
{
    ParametersConstant VolParam;

    ///this is identical to (Parameters)VolParam so it calls the copy constructor. But why does it not call the assignment operator = afterwards?
    Parameters Vol = VolParam;

    ///calls copy constructor - OK
    Parameters Vol_0(Vol);

    ///calls assignment operator - OK
    Vol_0 = Vol;

    return 0;
}

代码相当简单，但有一个方面我无法弄清楚，这与行Parameters Vol = VolParam;有关。据我了解，这条线转换的基本上是Parameters Vol = (Parameters)VolParam;，即有一种类型转换。

但是，转换后为什么不调用赋值运算符？如何创建Vol？

Answer 1

你可以写

Parameters Vol = VolParam;

因为这是我们在C（int i = 0;）中的方式，但除非你在类声明（使用explicit构造函数）中付出额外的努力，否则效果与

相同

Parameters Vol(VolParam);

尽管使用了=令牌，但这不是一项任务。

Vol = VolParam;，没有类型名称，是一项任务。

Answer 2

参数Vol = VolParam;。据我了解，这条线的基本内容是参数Vol = (Parameters)VolParam;，即有一种类型转换。

但是，转换后为什么不调用赋值运算符？ Vol怎么创造了？

它不是赋值或类型转换，而是隐式构造这是构造函数声明，允许：

Parameters(const ParametersInner &innerObject)
{
    std::cout << "CC (and implicit conversion)\n";
    InnerObjectPtr = innerObject.clone();
}

为了防止这种情况，请使用带有构造函数声明的explicit关键字。

处理类和赋值运算符

2 个答案: