C++ 如何在C+中，在没有动态分配（即新建）的情况下将对象初始化为对象内部的指针+；？

例如：

class A{

int b;
A *a1;
A *a2;

A(int c):b(c), a1(c), a2(c)  {}

}

我以为是这样的，但它没有编译。 有没有办法做到这一点，还是必须始终使用动态分配？

---

谢谢

您可以简单地将指针初始化为null

class A{

   int b;
   A *a1;
   A *a2;

   A(int c):b(c), a1(NULL), a2(NULL)  {}

}

（注意，如果它抱怨没有定义NULL，

#include）

或者根本不初始化它们

class A{

   int b;
   A *a1;
   A *a2;

   A(int c):b(c)  {}

}

您可以简单地将指针初始化为null

class A{

   int b;
   A *a1;
   A *a2;

   A(int c):b(c), a1(NULL), a2(NULL)  {}

}

（注意，如果它抱怨没有定义NULL，
#include）

或者根本不初始化它们

class A{

   int b;
   A *a1;
   A *a2;

   A(int c):b(c)  {}

}

如果您不想像这样初始化指向
NULL ptr
（
NULL
或
0
pre-C++11）的指针：

class A {
    A(int c) : b(c), a1(), b1() { }

    int b;
    A* a1, *a2;
};

A m1(1, NULL, NULL);
A m2(2, NULL, NULL);
if(something())
{
  A m3(3, &m1, &m2);
  // do stuff with m3
}

然后，使指针指向的对象必须存在于某个外部范围内，以便它至少与包含指针的对象一样长，或者必须使用
new

您可以接受
A*
将指针设置为：

class A {
    A(int c, A* aptr) : b(c), a1(aptr), a2(aptr) { }

    ... 
};

（您不能为此使用引用，因为这将使
a
成为
a
的要求，这是一个不可能满足的条件。不过，您可以创建一个接受引用的附加构造函数。）

在您的示例中，您试图使用
int
初始化一个无效的指针。此外，如果您在示例中创建了一个对象（通过
new
或其他方式），您将耗尽内存，因为您分配的每个
A
将再分配两个
A
s，并且该循环将持续到内存耗尽为止。
如果您不想初始化指向
nullptr
（
NULL
或
0
pre-C++11）如下所示：

class A {
    A(int c) : b(c), a1(), b1() { }

    int b;
    A* a1, *a2;
};

A m1(1, NULL, NULL);
A m2(2, NULL, NULL);
if(something())
{
  A m3(3, &m1, &m2);
  // do stuff with m3
}

然后，使指针指向的对象必须存在于某个外部范围内，以便它至少与包含指针的对象一样长，或者必须使用
new

您可以接受
A*
将指针设置为：

class A {
    A(int c, A* aptr) : b(c), a1(aptr), a2(aptr) { }

    ... 
};

（您不能为此使用引用，因为这将使
a
成为
a
的要求，这是一个不可能满足的条件。不过，您可以创建一个接受引用的附加构造函数。）

在您的示例中，您试图使用
int
初始化一个无效的指针。此外，如果您在示例中创建了一个对象（通过
new
或其他方式），您将耗尽内存，因为您分配的每个
A
将再分配两个
A
s，并且该循环将继续，直到您耗尽内存。
不清楚您试图做什么，但您肯定可以做到：

class A{

int b;
A *a1;
A *a2;

A(int c, A* pa1, A* pa2):b(c), a1(pa1), a2(pa2)  {}

}

你可以这样称呼它：

class A {
    A(int c) : b(c), a1(), b1() { }

    int b;
    A* a1, *a2;
};

A m1(1, NULL, NULL);
A m2(2, NULL, NULL);
if(something())
{
  A m3(3, &m1, &m2);
  // do stuff with m3
}

只要小心。如果
m1
或
m2
在
m3
之前超出范围，那么
m3
将留下指向随机垃圾的指针。
不清楚您试图做什么，但您肯定可以做到：

class A{

int b;
A *a1;
A *a2;

A(int c, A* pa1, A* pa2):b(c), a1(pa1), a2(pa2)  {}

}

你可以这样称呼它：

class A {
    A(int c) : b(c), a1(), b1() { }

    int b;
    A* a1, *a2;
};

A m1(1, NULL, NULL);
A m2(2, NULL, NULL);
if(something())
{
  A m3(3, &m1, &m2);
  // do stuff with m3
}

只要小心。如果
m1
或
m2
在
m3
之前超出范围，那么
m3
将留下指向随机垃圾的指针。
不清楚您试图做什么。在这段代码中，
c
是一个整数。您认为将
a*
类型的变量设置为整数是什么意思你不知道你要做什么。在这个代码中，<代码> C <代码>是一个整数。你认为把一个变量<代码> A*<代码>的整数设置为什么？“你不知道你在做什么，但是你肯定能做”，不管是好是坏，这通常是C++标签的问题。“你不知道你想做什么，但你肯定能做到”无论好坏，这通常是在C++标签的问题上…