c++ 指针参数：创建指向值的副本是否有意义，然后再次将副本存储为指针？

Question

我正在将一个项目迁移到 c++，因为我在用 c# 开发它时遇到了性能上限。然而，这是我第一次使用 c++，我发现自己做了很多看起来不太正确的事情......

考虑以下抽象示例：

class ClassC
{
    ClassC::ClassC(int option)
    {
        //do something
    }
}

class ClassB
{
    ClassC* objC

    ClassB::ClassB(ClassC* objC)
    {
        this->objC = new ClassC(*objC);
    }
}

class ClassA
{
    void functionA(void)
    {
        ClassB objB (&ClassC(2));
    }
}

ClassA 有一个创建 ClassB 的函数。 ClassB 的构造函数接受一个 ClassC，objC。 objC 通过引用传递，因为 ClassC 不是原始类型，而是通过引用存储，因为 ClassC 没有默认构造函数。但是，由于objC是在静态内存中创建的，并且会在functionA完成时被销毁，所以ClassB需要将objC指向的值复制到动态内存中，然后存储一个指向该副本的指针。

这对我来说似乎很绕，让我觉得我在错误地接近某些东西。这是 c++ 中的标准操作吗？

编辑：每个人似乎都在说 ClassB objB (&ClassC(2)); 行不正确，因为 ClassC 对象的值将在 ClassB 复制它之前丢失。但是我已经编译了我的示例，但事实并非如此。这是修改后的工作代码：

class ClassC
{
    int option;

public:
    ClassC::ClassC(int option)
    {
        this->option = option;
    }

    int ClassC::getOption(void)
    {
        return option;
    }
};

class ClassB
{
    ClassC* objC;

public:
    ClassB::ClassB(ClassC* objC)
    {
        this->objC = new ClassC(*objC);
    }

    int ClassB::getOption(void)
    {
        return objC->getOption();
    }
};

class ClassA
{
public:
    static ClassB functionA(void)
    {
        return ClassB (&ClassC(2));
    }
};

int main(void)
{
    ClassB objB = ClassA::functionA();

    int test = objB.getOption(); //test = 2, therefore objC was copied successfully.

    return 0;
}

Answer 1

不确定您的真正问题是什么，但您的代码似乎很脆弱。我想重写你的代码，就像你展示的那样：

class ClassC
{
    explicit ClassC(int option)
//  ^^^^^^^^ stop implicit conversion, if constructor takes one parameter
    {
        //do something
    }
};

class ClassB
{
    ClassC objC;                         // store by value instead of pointer. 
                                         // Even smart pointer will be better option than raw pointer

    explicit ClassB(const ClassC& objC)  // pass by const reference instead
    : objC(objC)                         // use member initializer list to initialize members
    {
    }
};

class ClassA
{
    void functionA(void)
    {
        ClassB objB(ClassC(2));
    }
};

Answer 2

获取临时地址并将其保存以备后用是一个很大的禁忌。

ClassB objB (&ClassC(2));  // taking address of temporary

此外，即使在函数参数列表中传递临时的 const-reference 也不会比函数调用进一步延长生命周期。 IE。一旦构造函数完成触发，引用就是 toast，所以：

class ClassB
{
    const ClassC& objC;

public:
    ClassB(const ClassC& objC) : objC(objC)
    {
    }
};

也不行。 More info can be read here about the details for why。

如果你这样做，它会工作：

ClassC objC;
ClassB objB(objC);

但话又说回来，您的原始样本也是如此。

保证外部对象的生命周期的一种方法是通过智能指针所有权动态分配对象。考虑一下：

class ClassB
{
    std::shared_ptr<ClassC> ptrC;

public:

    ClassB(std::shared_ptr<ClassC> ptrC)
        : ptrC(ptrC)
    {
        // access the instance with ptrC->member()
    }
};

现在你可以这样做了：

ClassB objB(std::make_shared<ClassC>(2));

即使objB 是值复制的（例如在容器上的排序操作等），共享实例仍然完好无损。最后一个出门的人关了灯（在这种情况下，删除了共享的ClassC 对象）。

显然，对于仅由单个父级持有的单个实例而言，这是毫无意义的。在这种情况下，我完全同意其他强烈建议您使用移动语义的答案。但是，如果您确实需要共享资源，这是考虑这样做的一种方法。

---

EDIT将传递构造函数添加到 ClassB 作为一个简单的示例。

我刚刚意识到每个人都非常热衷于帮助您构建 ClassC 对象，以至于您可能只需要一种向objC 提供参数以进行构建的方法。 IE。也许您完全打算在 objB 上完全拥有自己的 objC 私有实例，而您所需要的只是一种获取参数以进行初始化的方法。

这就是构造构造器初始化列表的用途。请参阅下面的代码，它（基于您的 cmets，可能会为您工作，并且非常更易于理解。

class ClassB
{
    ClassC objC;

public:
    // default constructor. initializes objC with default value
    ClassB() : objC(0)
    {
    }

    // explicit pass-through of params to `objC` construction
    explicit ClassB(int option) : objC(option)
    {
    }
};

这使您在ClassA 中的代码变得简单：

ClassB objB(2);

这将调用ClassB::ClassB(int)，将提供的参数传递给ClassC类型的内部objC对象实例的构造。

Answer 3

ClassC 的构造函数无关紧要，因为将调用的是复制构造函数

class ClassC
{
    ClassC(int option) // defines a constructor that takes an int
    {
        //do something
    }
}

class ClassB
{
    ClassC* objC

    ClassB(ClassC* objC)
    {
        this->objC = new ClassC(*objC); // dereferences objC calling ClassC::ClassC(const Class& obj) - the default copy constructor.
    }
}

class ClassA
{
    void functionA(void)
    {
        ClassB objB (&ClassC(2)); // passing a reference to a temporary ... bad idea, but since it is copied in ClassB (the object, not the pointer), it will appear okay - if your compiler lets this compile (newer ones should/will likely throw an error "cannot take address of rvalue temporary")
    }
}

总而言之，如果上面提到了许多建议，这段代码会更好，但值得注意的是，ClassC 的复制构造函数是在 ClassB 中调用的。

Answer 4

ClassB objB (&ClassC(2));

这是一件坏事。您正在获取一个临时对象的地址，该地址将在此行之后消失。如前所述，尝试使用引用而不是指针。大多数时候，您可以用引用替换指针，这是一种非常安全的方法（它永远不会是“NULL”）。

你可以写

class ClassB
{
    ClassC& objC;

    ClassB::ClassB(const ClassC& objC) :
        objC(objC)
    {
    }
}