不调用C 破坏者

C++ Destructor is not called

本文关键字：破坏者 调用      更新时间：2023-10-16

我有三个类：房间，门和世界

#include <set>;
using namespace std;
class Door; // Forward declaration
class Room {
public:
    Door* door1;
    Door* door2;
    Room(){}
    ~Room() {
        delete door1;
        door1 = 0;
        delete door2;
        door2 = 0;
    }
};
class Door {
public:
    Room* roomA;
    Room* roomB;
    Door(Room* roomA, Room* roomB) {
        this->roomA = roomA;
        this->roomB = roomB;
        linkRooms(); // This sets up the Door-Pointers in the Rooms
                     // so they know about the new door.
    }    
    ~Door() {
        // Returns the room-owned pointer pointing at this door
        getMyRoomPointer(roomA) = 0;
        getMyRoomPointer(roomB) = 0;
    }    
    Door * & getMyRoomPointer(Room * const & room) {
        if (room->door1 == this) return room->door1;
        else return room->door2;
    }
    void linkRooms() {
        roomA->door1 = this;
        roomB->door2 = this;
    }
};
class World {
public:
    std::set<Room*> rooms;
    World() {
        // Set up two rooms and link them using a door
        Room* newRoom = new Room();
        rooms.insert(newRoom);
        Room* anotherNewRoom = new Room();
        rooms.insert(anotherNewRoom);
        new Door(newRoom, anotherNewRoom);
    }
    ~World() {
        // Iterate over the rooms and call delete on all of them
        for (std::set<Room*>::iterator it = rooms.begin(); it != rooms.end(); ++it) {
            delete *it;
        }
    }
};
int main() {
    World world;
    return 0;
}

运行主机时，构造函数只用两个房间和一扇门作为它们之间的链接充满了世界。主要回报后，应删除世界，所有房间和门也应得到照顾。

是，我的门破坏者从未被召唤。因此，房间内的门指针没有设置为无效，当房间"在另一侧"试图删除同一门时，我会遇到错误。

当我只创建一个门实例，而不是立即将其删除，我不会遇到任何问题：

int main(){
    Room oneRoom;
    Room anotherRoom;
    Door* door = new Door(&oneRoom, &anotherRoom);
    delete door; // works just fine
    return 0;
}

问题：为什么不调用门构造器？在允许的第一个示例中设置门吗？

我知道，我要删除房间的门指针，并且我可以（并且应该）使用SmartPointers。现在，我只是想知道为什么我要面对这种行为。毕竟，我还是C 的新手。

我现在确实设置了一个可运行的示例，该示例重现了错误。

您在定义Door之前调用delete。因此，该程序的行为是不确定的，并且不能保证击曲线被称为。

标准（草稿）[expr.delete]的报价：

  1. 如果被删除的对象在删除点上具有不完整的类类型，并且完整类具有非平凡的驱动器或DealLacort函数，则行为是未定义的。

解决方案：如果该类型的破坏者是非平凡的（即用户定义的，例如~Door，则切勿删除此类对象，直到类型完成为止）。在这种情况下，在调用DELETE的函数之前定义Door。

作为一般规则，除非班级类型完成，否则您永远无法调用成员功能。不幸的是，在驱动器的情况下，编译器可能并非总是有可能捕获错误的。PS。G 确实警告您的程序：warning: possible problem detected in invocation of delete operator: [-Wdelete-incomplete]

您应该注意编译器警告消息：

g++ -std=c++17 -fPIC -g -Wall -Wextra -Wwrite-strings -Wno-parentheses -Wpedantic -Warray-bounds -Weffc++      41120443.cpp    -o 41120443
41120443.cpp:1:15: warning: extra tokens at end of #include directive
 #include <set>;
               ^
41120443.cpp:7:7: warning: ‘class Room’ has pointer data members [-Weffc++]
 class Room {
       ^~~~
41120443.cpp:7:7: warning:   but does not override ‘Room(const Room&)’ [-Weffc++]
41120443.cpp:7:7: warning:   or ‘operator=(const Room&)’ [-Weffc++]
41120443.cpp: In constructor ‘Room::Room()’:
41120443.cpp:12:5: warning: ‘Room::door1’ should be initialized in the member initialization list [-Weffc++]
     Room(){}
     ^~~~
41120443.cpp:12:5: warning: ‘Room::door2’ should be initialized in the member initialization list [-Weffc++]
41120443.cpp: In destructor ‘Room::~Room()’:
41120443.cpp:15:16: warning: possible problem detected in invocation of delete operator: [-Wdelete-incomplete]
         delete door1;
                ^~~~~
41120443.cpp:15:16: warning: invalid use of incomplete type ‘class Door’
41120443.cpp:5:7: note: forward declaration of ‘class Door’
 class Door; // Forward declaration
       ^~~~
41120443.cpp:15:16: note: neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined
         delete door1;
                ^~~~~
41120443.cpp:17:16: warning: possible problem detected in invocation of delete operator: [-Wdelete-incomplete]
         delete door2;
                ^~~~~
41120443.cpp:17:16: warning: invalid use of incomplete type ‘class Door’
41120443.cpp:5:7: note: forward declaration of ‘class Door’
 class Door; // Forward declaration
       ^~~~
41120443.cpp:17:16: note: neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined
         delete door2;
                ^~~~~
41120443.cpp: At global scope:
41120443.cpp:22:7: warning: ‘class Door’ has pointer data members [-Weffc++]
 class Door {
       ^~~~
41120443.cpp:22:7: warning:   but does not override ‘Door(const Door&)’ [-Weffc++]
41120443.cpp:22:7: warning:   or ‘operator=(const Door&)’ [-Weffc++]
41120443.cpp: In constructor ‘Door::Door(Room*, Room*)’:
41120443.cpp:27:5: warning: ‘Door::roomA’ should be initialized in the member initialization list [-Weffc++]
     Door(Room* roomA, Room* roomB) {
     ^~~~
41120443.cpp:27:5: warning: ‘Door::roomB’ should be initialized in the member initialization list [-Weffc++]
41120443.cpp: In constructor ‘World::World()’:
41120443.cpp:56:5: warning: ‘World::rooms’ should be initialized in the member initialization list [-Weffc++]
     World() {
     ^~~~~

和valgrind输出：

valgrind  ./41120443 
==2864== Memcheck, a memory error detector
==2864== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==2864== Using Valgrind-3.12.0.SVN and LibVEX; rerun with -h for copyright info
==2864== Command: ./41120443
==2864== 
==2864== Conditional jump or move depends on uninitialised value(s)
==2864==    at 0x4C2C291: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2864==    by 0x108BC3: Room::~Room() (41120443.cpp:17)
==2864==    by 0x108D67: World::~World() (41120443.cpp:68)
==2864==    by 0x108B65: main (41120443.cpp:75)
==2864== 
==2864== Conditional jump or move depends on uninitialised value(s)
==2864==    at 0x4C2C291: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2864==    by 0x108BA8: Room::~Room() (41120443.cpp:15)
==2864==    by 0x108D67: World::~World() (41120443.cpp:68)
==2864==    by 0x108B65: main (41120443.cpp:75)
==2864== 
==2864== Invalid free() / delete / delete[] / realloc()
==2864==    at 0x4C2C2DB: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2864==    by 0x108BC3: Room::~Room() (41120443.cpp:17)
==2864==    by 0x108D67: World::~World() (41120443.cpp:68)
==2864==    by 0x108B65: main (41120443.cpp:75)
==2864==  Address 0x5a82e00 is 0 bytes inside a block of size 16 free'd
==2864==    at 0x4C2C2DB: operator delete(void*) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2864==    by 0x108BA8: Room::~Room() (41120443.cpp:15)
==2864==    by 0x108D67: World::~World() (41120443.cpp:68)
==2864==    by 0x108B65: main (41120443.cpp:75)
==2864==  Block was alloc'd at
==2864==    at 0x4C2B21F: operator new(unsigned long) (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==2864==    by 0x108CCE: World::World() (41120443.cpp:63)
==2864==    by 0x108B54: main (41120443.cpp:75)

您可以通过明智地使用智能指针来使自己变得更加轻松：

#include <memory>
#include <set>
class Door; // Forward declaration
struct Room {
    std::shared_ptr<Door> door1 = {};
    std::shared_ptr<Door> door2 = {};
    ~Room();
};
struct Door {
    const std::weak_ptr<Room> roomA;
    const std::weak_ptr<Room> roomB;
    Door(std::shared_ptr<Room> roomA, std::shared_ptr<Room> roomB)
        : roomA(roomA),
          roomB(roomB)
    {
        roomA->door1 = roomB->door1 = std::shared_ptr<Door>{this};
    }
    ~Door() = default;
};
// Now that Door is complete, we can define ~Room
Room::~Room() = default;
struct World {
    std::set<std::shared_ptr<Room>> rooms = {};
    World() {
        // Set up two rooms and link them using a door
        auto newRoom = std::make_shared<Room>();
        rooms.insert(newRoom);
        auto anotherNewRoom = std::make_shared<Room>();
        rooms.insert(anotherNewRoom);
        new Door(newRoom, anotherNewRoom);
    }
    ~World() = default;
};
int main() {
    World world;
    return 0;
}

这构建并干净地运行：

g++ -std=c++17 -fPIC -g -Wall -Wextra -Wwrite-strings -Wno-parentheses -Wpedantic -Warray-bounds -Weffc++      41120443.cpp    -o 41120443
valgrind  ./41120443 
==3254== Memcheck, a memory error detector
==3254== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al.
==3254== Using Valgrind-3.12.0.SVN and LibVEX; rerun with -h for copyright info
==3254== Command: ./41120443
==3254== 
==3254== 
==3254== HEAP SUMMARY:
==3254==     in use at exit: 0 bytes in 0 blocks
==3254==   total heap usage: 7 allocs, 7 frees, 72,952 bytes allocated
==3254== 
==3254== All heap blocks were freed -- no leaks are possible
==3254== 
==3254== For counts of detected and suppressed errors, rerun with: -v
==3254== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)

您永远不会删除门

new Door(newRoom, anotherNewRoom);

您应该在世界中添加Door *door 

public:
  Door *door;
...
  door = new Door(newRoom, anotherNewRoom);

并在世界的破坏者中调用删除：

delete door;

请注意，您的代码具有很多未定义的行为。

std::set<Room *> rooms;

std::set是一个关联容器，包含类型键的一组唯一对象。

您应该使用列表：

std::list<Room *> rooms;
相关文章：