指向 class、C++ 新手问题中的对象的指针

Question

为什么在 C++ 中，对于对象 A，B

//interface, case #1
class A {

B bb;
}

A::A()
{ //constructor
bb = B();
}


//interface, case #2
class A {

B *bb;
}

A::A()
{ //constructor
bb = new B();
}

为什么案例 #2 有效但 #1 无效？

编辑：我现在明白了。 但是对于案例 #1，如果 A 的一个实例被释放，它的 bb 也会被自动释放吗？ 案例 #2 你必须明确调用 bb = NULL 对吗？

Answer 1

两者都有语法错误，因此“不起作用”并不特定于其中一个。 您还没有声明A::A构造函数，因此当您尝试定义它时会出现语义错误。

如果 B 的完整声明在 class A 的声明之前可用，那么它将编译：

class B {};

//interface
class A {
    A();

    B bb;
};

A::A()
{ //constructor
    bb = B();
}

在bb=B()行中，已经构造了 bb，因为它是 A 的成员。然后您正在构造另一个 B，然后将该 B 的值复制到 bb。 这有点浪费。 如果要将 arguments 传递给 bb 的构造函数，请使用初始化程序。

另一方面，如果您不想将 B 的定义放在 A 的定义之前，并且只对其进行前向引用，则编译器无法计算出 B object 有多大。 它需要知道 B 有多大才能确定 A 中允许 bb 有多少空间。所以没有 B 就无法编译 A。

在第二种情况下，您改为使用指向 B 的指针。指针的大小相同，无论它们指向什么。 这样，编译器可以计算出 A 有多大，并且只需要在实际使用 B 之前完整声明 B，例如通过在new B()表达式中调用 B 的构造函数。

Answer 2

在C++中，如果你声明一个object，你不需要初始化它。 声明时调用构造函数。

Answer 3

因为在编译时，创建 B object 所需的 memory 的数量是未知的。 因此，需要使用指向 object 的指针，以便可以动态分配 memory（当您调用 new 时）。

Answer 4

显示的代码太不完整了。 除非你给出 B 的定义，否则恐怕没人能回答。 我的疯狂猜测是 class B 是不可复制的（例如私有运算符 =）。 使用可复制的 B class 您给出的示例应该可以工作。

Answer 5

看起来您的“B”class 隐藏了 operator=。 否则，你写的应该编译。

但是，这不是必需的。 这应该有效：

A::A() : bb()
{ //constructor
}

但是，由于您正在调用默认构造函数，因此无需显式 state 它。 这很容易是：

A::A() // bb is automatically constructed, since it's a member variable and not a pointer.
{ 
}

Answer 6

如果 class B 的定义（不是声明）出现在 class A 的声明之前，那么您的 case#1 应该可以正常编译。

正如Oxley所指出的，其原因是 C++ 需要知道 B 需要多少 memory object，如果没有 B 的定义，它就无法做到这一点。

但是，如果您使用指针（如案例#2），则需要的 memory 的数量是已知的，因为所有指针占用相同数量的 memory（32 位或 64 位，具体取决于系统）。

所以，对于case#2，你只需要在A的定义之前声明B。（注意：声明，而不是定义，当然，有定义也没有坏处。但不一定需要）。

只是为了确保我不会混淆任何人，（嘿，也许我没有 C++ 术语）

声明：声明 class 或 function 的存在，但没有说明它是什么。

例如

class A; //forward declaration

class C
{
   A * a;
   // .....
};

定义：实际上定义了class或function。 虽然对于 class，它不一定完全定义它，但它定义了它的所有成员。

class A
{
   int a;
   int b;
   void some_method(); //not defined here, only declared, but it's ok
};

Answer 7

我认为案例 A 必须有效，因为如果没有定义，编译器会提供一个复制构造函数。

Answer 8

我的问题是如何制作

A::A()
{ //constructor
bb = new B();
}

但没有新的。 而且我认为问题中的代码不是真正的代码。 只是为什么“新”有效，而简单的分配却无效。

我的回答如下。 如果我以错误的方式理解问题或答案本身是错误的 - 请告诉我。

改变

A::A()
{ //constructor
bb = B();
}

至

A::A():
    bb()
{
   // some logic
}

并且要在“新”的情况下保持一致，最好像这样实施

A::A():
    bb( new B() )
{
    // some logic
}

在这两种情况下，当“某些逻辑”将开始执行时，您可以确定 object bb 将被初始化或抛出异常。

为了使您的案例可编译，B 应该已经实现了分配运算符。

对您的编辑：您对案例 1 的猜测是正确的。 在情况 2 中，您必须在 class 析构函数中调用 delete bb。

请留言'-1'原因。 我真的很困惑。