构造函数的 C++ 语法“'Object1 a (1, Object1(2))''

Question

我在程序中有这样的语法

/* The Object1 is allowed to be changed */
class Object1 : BaseClass {
    BaseClass *link;
    int i;
    public: 
    Object1(int a){i=a;}
    Object1(int a, Object1 /*place1*/ o) {i=a; link= &o;}
};

int main(){
/* The initialization syntax must be preserved. No any new(), no other local objects b,c */
    Object1 a(1, /*place2*/ Object1(2));
    ...
}

我需要什么？我想在第一个对象中保存指向第二个对象的链接（指针）。我应该在原地使用引用“&”吗？

什么类型的地方会有“Object1(2)”？它是匿名对象的构造函数吗？它会有“自动”存储类型吗？

谢谢

更新：

在place2中，语法是固定的，我真的必须支持创建“链”，比如

    Object1 a(1, Object1(2, Object1(6, Object1(999753))));

我无法在 a 的定义中添加任何符号。

更新2： 对于 place1：Object1(int a, Object1 &o) {i=a; link= &o;} 和 Object1 a(1, Object1(2)); 在 place2 我有一个编译错误（g++）：

main.cpp||In function `int main()':|
main.cpp|19|error: no matching function for call to `Object1::Object1(int, Object1)'|
main.cpp|9|note: candidates are: Object1::Object1(const Object1&)|
main.cpp|14|note:                 Object1::Object1(int, Object1&)|
main.cpp|13|note:                 Object1::Object1(int)|

Answer 1

在“place1”中，您需要一个参考。 Object1 没有完全定义，所以你不能按价值接受。也就是说，您不想按值传递；当您获取它的地址时，您将获得副本的地址，而不是实际对象。

由于您只想要一个指向 BaseClass 的指针，因此只对参数设置该限制可能更有意义。 （当然，如果您真的需要Object1，请在link 的类型中反映：Object1* link;）。

还可以考虑使用初始化列表：

Object1(int a) : i(a), link(0) /* <- important! */ { }
Object1(int a, BaseClass& o) : i(a), link(&o) { }

始终使用初始化列表。

"place2" 使用构造函数创建Object1 的未命名实例。它有 no storage(?) auto storage 和 dies at the end of the expression。

也就是说，一旦你点击了Object1 a(1, /*place2*/ Object1(2)); 中的分号，它就不再存在，并且你有一个指向不存在对象的指针！这会导致未定义的行为。

给它一个超越表达式的生命：

Object1 x(2);    
Object1 a(1, x);

始终确保当您引用一个对象时，它会在您引用它的整个过程中一直存在。

---

您的新编译错误是因为您无法引用临时变量。不过，您可以拥有一个带有 const 引用的。问题是，你的指针现在需要指向 const BaseClass，这可能会影响你想要的。

再次遗憾的是，您的设计需要重新设计。

Answer 2

位置 1：在此处使用指针 (*) 而不是引用 (&)。指针语法更明确地指示链接。

地点 2：这里将创建所谓的“临时”对象。是的，它将涉及对 Object1 的构造函数的调用。另外，是的，存储将是“自动”的，因为它将在堆栈上创建。

不过要小心。在您可以在构造函数中引用它之前，临时对象将消失。这肯定会使您的程序崩溃。

如果你必须传递一个临时的，你可以通过在堆上创建一个副本来成功。像这样的：

class Object1
{
    BaseClass* link;
    int i;
    Object1(int a) : i(a), link(NULL) {}
    Object1(int a, const Object1& o) : i(a), link(new new Object1(o)) {} 
    Object1(const Object1& other) i(other.i) link(other.link) {} //Copy constructor
    virtual ~Object1() { delete link; } //Don't forget the 'delete' in destructor.
};

然后在你的 main 你可以（）这样做：

int main() 
{
    Object1 a(3, Object1(2));
    ....
}

请注意 Object1 类中的析构函数。确保在其中的链接上调用删除运算符。然而，这样的调用会导致删除链中的所有子节点。如果这不是您想要的，请相应地更改您的删除机制。无论如何，不​​要忘记删除。

另外，确保析构函数是虚拟的。那是因为您将在指向派生类对象的基类指针上调用 delete。

Answer 3

您不能在声明中使用Object1 的实例（它尚未声明）。您可以在类声明之前添加称为前向声明的内容，如下所示：

// Forward declaration
class Object1;

// Now the class body
class Object1 {
    // some reference to Object1 here
};

但是，我仍然不完全清楚您要使用此代码做什么。了解更多关于您希望此构造函数做什么的信息可能会有所帮助？我怀疑您可能希望使用指针或按引用传递，而不是按值传递。

Answer 4

你想做什么是不可能的，因为你已经写好了。 /*place2*/ 处的 Object1 的生命周期在构造函数完成后结束，因此您将拥有一个悬空指针。

一般来说，您希望/*place2*/ 处的Object1 成为引用，或直接作为指针[在这种情况下，您不会获取地址，直接复制它]。

但是，您必须非常小心您存储的指针的生命周期，正如初始点所证明的那样。

Answer 5

构造函数参数o 是您传入的Object1 实例的副本（因为它是按值传递的值。在您的构造函数中，当您设置你的成员指针指向它的地址，那个地址就是栈帧，在你的构造函数返回后，这个地址就失效了。

这是另一种方法（当然还有其他方法）：

class Object1 : BaseClass
{
    BaseClass *link;
    int i;

public: 
    // - Prefer initialization to assignment
    // - Initialize ALL of your members
    Object1(int a) : link(NULL), i(a) {}

    // This instance assumes ownership of p
    Object1(int a, Object1 *p) : link(p), i(a) {}

    ~Object1() { delete link; }
};

int main()
{
    Object1 a(1, new Object1(2));
    ...
}

编辑：嗯，我能看到你使用你拥有的链接设计的唯一方法是这样丑陋的：

class Object1 : BaseClass
{
    BaseClass *link;
    int i;

public:
    Object1(int a) : link(NULL), i(a) {}

    Object1(int a, const Object1& o) : link(new Object1(o)), i(a) {}

    // Copy constructor
    Object1(const Object1& other) : link(NULL), i(other.a)
    {
        // Deep copy linked object
        if (other.link != NULL)
        {
            link = new Object1(*other.link);
        }
    }

    // Assignment operator that does deep copy
    const Object1& operator=(const Object1& that)
    {
        // Check for assignment to self
        if (this != &that)
        {
            delete this.link; 
            this.link = NULL;

            // Deep copy linked object
            if (that.link != NULL)
            {
                this.link = new Object1(*that.link);
            }

            this.i = that.i;
        }
    }

    ~Object1() { delete link; }
};

int main()
{
    Object1 a(1, new Object1(2));
    ...
}

Answer 6

您要实现的是堆栈上的动态数组。您想创建一个对象列表并且不将它们保留在堆中。 C++ 不支持这一点，至少不在一个函数的范围内。

你可以用递归重构你的代码，并保持一个链表在堆栈上，但这不会是非常 C++ 的。

否则，唯一的解决方案是使用堆（std::list、std::auto_ptr 或 std::unique_ptr 应该可以解决问题），正如其他人所建议的那样。