传递指针等

Question

一般来说，我总是通过我创建的任何对象的函数传递指针；如果我需要对一个对象做些什么，我会通过指针而不是引用来传递它。这只是一种编程习惯，有些人可能将其描述为微不足道的；但这是我必须举例说明的地方：

class someObject
{
   public:
      someObject();
      ~someObject();

      void do(const char* smth)
      {
          cout << smth << endl;
      }

   private:
};

class doObject
{
    public:
       doObject();
       ~doObject();

       void takeObject(someObject *so)
       {
           pObject = so;
           so->do("Hi");
       }

    private:
       someObject *pObject;
}

在main.cpp中：

int main()
{
    someObject *so = new someObject();
    so->do();

    doObject *do = new doObject();
    do->takeObject(so);

    delete so;
    delete do;
}

在分配 someObject 类型的指针参数 so 之前，是否应该将内存分配给 doObject::pObject？
如果pObject被赋予上述参数，是否应该删除；例如删除 pObject?
在 main.cpp 中，someObject 在 doObject 之前被删除。理解这一点很重要，因为 doObject 有一个名为 pObject 的 someObject 的赋值。在 doObject 之前删除 someObject 意味着有一个悬空指针，这意味着对它的任何操作都会产生分段错误。
如果我先在 main.cpp 中删除 doObject，是否也会删除 pObject 以及 'so' 类型的 someObject？毕竟是连在一起的
如果我创建一个新的 class，它也是一个需要 someObject 参数的函数，这是否意味着 pObject 不再指向 'so'？我是否应该改用共享指针，以便两个 class 都能指向 'so' 并根据需要更改对象？
如何改进代码？我是否应该考虑使用智能指针来确保我不会在程序的各个部分多次删除一个对象？

是的，这个问题比较复杂；但这就是你用指针得到的！

Answer 1

Should memory be allocated to doObject::pObject BEFORE it is assigned the pointer parameter so of type someObject?

内存分配在 main 中，指向该内存的指针分配给 so。成员变量 pObject 将指向与 so 相同的对象。因此内存是在您分配成员指针变量之前分配的。

If pObject is assigned the foresaid parameter, should it be deleted; e.g. delete pObject?

必须有人删除指向的对象才能避免内存泄漏。有人做，或者所有权是共享。当您将指针传递给另一个函数时，您决定是否转移所有权。保持一致是关键，使用智能指针是一个帮助。

In main.cpp someObject is deleted BEFORE doObject is. This is vital to understand because doObject has an assignment of someObject called pObject. Deleting someObject before doObject means there's a dangling pointer which implies any actions on it would produce a segmentation fault.

如果您分配动态内存，请始终以相反的分配顺序解除分配以防止悬空指针。

If I delete doObject first in main.cpp, does that also delete pObject AS WELL AS 'so' of type someObject? After all, they are linked.

没有。如果 doObject 析构函数完成了 delete pObject;，那么它会。

If I create a new class that also a function which also requires a parameter of someObject, does that mean pObject no longer points to 'so'? Should I instead use a shared pointer so that it's possible for both classes to be able to point to 'so' and change the object as necessary?

pObject不指向so，它指向与so相同的动态分配对象。任意数量的类中都可以存在任意数量的指向该对象的指针，但您有责任确保在对象被删除后，没有指向它的指针的持有者使用该指针。这就是为什么以正确的顺序删除对象很重要。

How can the code be improved? Should I consider the use of smart pointers to ensure that I do not delete an object more than once in various parts of a program?

是的，智能指针，如果你想共享所有权（shared_ptr）或确保只有一个所有者（unique_ptr），或者指针参数是仅引用一个实例，从不拥有。

尽可能使用自动实例而不是动态实例。

Answer 2

How can the code be improved? Should I consider the use of smart pointers to ensure that I do not delete an object more than once in various parts of a program?

我建议先学习手动内存管理，掌握之后再开始使用智能指针。但是，如果您认为不需要了解手动内存管理，当然可以直接跳到智能指针。

传递指针等

Passing pointers and more

c++

memory

pointers

memory-management

function