用Visual Studio运行你的代码给了我：

HEAP CORRUPTION DETECTED: after Normal block (#72) at 0x00B065E8.
CRT detected that the application wrote to memory after end of heap buffer.

字符串
在做delete[] ships;的时候。
第一个问题是你试图在ships构造函数中初始化点，但是：

this->end_coords[2] = {};

型
这条语句将一个默认的初始化点赋给ships的end_coords成员中的第三个点。2不幸的是，数组有两个点大。
此外，由于player_t析构函数会销毁船只，所以你将船只的所有权交给了player_t。但是你将同一个动态分配数组的所有权交给了两个玩家：

int main()
{
    ship_t *ships = new ship_t[(5 * 5) / 2];
    
    for(int i = 0; i < 5; i++) {
        ships[i].size = i + 1;
    }
    
    player_t player1 = player_t(5, ships, 5); // <-- ships
    player_t player2 = player_t(5, ships, 5); // <-- ships

型
不是一个好主意。同样的船阵被两个玩家使用，这没有意义，因为每个玩家都应该有自己的船，我想。
最后，你不应该调用player的析构函数，因为它会在返回（作用域退出）时再次被调用。

最小修改固定代码：

在ship_t构造函数中注解掉这一行：

//this->end_coords[2] = {};

型
分配两艘船阵，给予每个玩家所有权：

ship_t *ships = new ship_t[(5 * 5) / 2];
    for (int i = 0; i < 5; i++) {
        ships[i].size = i + 1;
    }
    player_t player1 = player_t(5, ships, 5);
    ship_t *ships2 = new ship_t[(5 * 5) / 2];
    for (int i = 0; i < 5; i++) {
        ships2[i].size = i + 1;
    }
    player_t player2 = player_t(5, ships2, 5);

型

更C++风格的解决方案

让我们用它们的名字来调用结构体。然后在结构体中使用默认的初始化来避免无用的构造函数。删除所有的分配，除非真的真的需要。让我们使用std::vector<>。我不喜欢矢量的矢量用于Map，但在这种情况下，它确实是一个简单的解决方案。使用矢量时不需要存储大小。最后，使用move将ship矢量复制到每个播放器中，以防有什么临时的东西传来传去

#include <vector>
struct point {
    int x = 0;
    int y = 0;
};
struct ship {
    int size = 0;
    point end_coords[2];
};
struct player {
    std::vector<std::vector<int>> map;
    std::vector<ship> ships;
    player(int map_size, std::vector<ship> ships_) :
        map(map_size, std::vector<int>(map_size)),
        ships(std::move(ships_)) {}
};
int main()
{
    std::vector<ship> ships;
    for (int i = 0; i < 5; ++i) {
        ships.push_back({ i + 1 });
    }
    player player1(5, ships);
    player player2(5, ships);
    return 0;
}

型

更C++风格的版本，带内存分配：

这里我没有使用std::vector（但这不是一个好主意）。注意我们如何将一个vector int初始化为0，并且你不需要一个指向指针的指针。通过几个操作符，管理Map会容易得多。作为一个例子，我正在打印你的Map。建议：不要使用i和j。行和列使用r和c，以避免意外交换它们的含义。

#include <iostream>
struct point {
    int x = 0;
    int y = 0;
};
struct ship {
    int size = 0;
    point end_coords[2];
};
// use _ after names, to make clear that these are members
struct player {
    int *map_;           // owned
    int map_size_;
    ship *ships_;        // owned
    int ships_count_;
    // player constructor copies the ships vector
    player(int map_size, const ship *ships, int ships_count) :
        map_size_{ map_size }, ships_count_{ ships_count }
    { 
        map_ = new int[map_size * map_size]{}; // notice the initializer here to default zero
        ships_ = new ship[ships_count];
    }
    // Rule of 4: if you own memory, you need all these 4 methods. Or delete them.
    player(const player&) = delete;
    player& operator=(const player&) = delete;
    ~player() {
        delete[] map_;  // no setting to nullptr: these will never be accessed anymore
        delete[] ships_;
    }
    int size() const { return map_size_; }
    int& operator()(int r, int c) {
        return map_[r * map_size_ + c];
    }
    const int& operator()(int r, int c) const {
        return map_[r * map_size_ + c];
    }
};
std::ostream& operator<<(std::ostream& os, const player& p) {
    auto size = p.size();
    for (int r = 0; r < size; ++r) {
        for (int c = 0; c < size; ++c) {
            if (p(r, c) == 0) {
                std::cout << "~";
            }
            else {
                std::cout << p(r, c);
            }
        }
        std::cout << "\n";
    }
    return os;
}
int main()
{
    ship ships[5];
    for (int i = 0; i < 5; ++i) {
        ships[i].size = i + 1;
    }
    player player1(5, ships, 5);
    player player2(5, ships, 5);
    std::cout << "player1:\n" << player1 << "\n";
    std::cout << "player2:\n" << player2 << "\n";
    return 0;
}

型