C++ 在c+中使用大型数组+；班

这就是我的班级的样子。我的代码编译成功，但当我运行它时，它崩溃并停止

class Explore{

    public:

        Explore(ros::NodeHandle &nh, tf2_ros::Buffer &buffer);

    private: 

        
        bool is_frontier(size_t mx, size_t my);
        void explore_level_three();
        void go_to_cell(size_t mx, size_t my);
        void publish_markers_array();
        void publish_markers();
        
        
        costmap_2d::Costmap2DROS* global_costmap, *local_costmap;
        costmap_2d::Costmap2D* global_costmap_, *local_costmap_;
        
        ros::NodeHandle nh_;
        ros::Publisher frontier_array_pub, frontier_pub; 

        vector<pair<size_t, size_t> >frontiers;
        
        string global_frame, robot_base_frame;
        unsigned char *global_og;

        size_t size_x, size_y;  
        double init_wx, init_wy; 
        
        int vis[4001][4001], frontier_vis[4001][4001] ; 

};

我如何解决这个问题

我如何解决这个问题

自动对象的可用内存通常非常有限。因此，必须动态分配所有大型对象。否则，您的变量可能会消耗为自动对象保留的所有内存，从而导致。。。堆栈溢出

如果类的所有实例都是动态分配的，那么拥有巨大的成员变量就不是问题了，但是由于这种限制很难实施，所以通常最好不要拥有巨大的成员变量

你的数组

vis

和

frontier\u-vis

很大。简单的解决方案：使用

std:：vector

我如何解决这个问题

自动对象的可用内存通常非常有限。因此，必须动态分配所有大型对象。否则，您的变量可能会消耗为自动对象保留的所有内存，从而导致。。。堆栈溢出

如果类的所有实例都是动态分配的，那么拥有巨大的成员变量就不是问题了，但是由于这种限制很难实施，所以通常最好不要拥有巨大的成员变量

---

你的数组

vis

和

frontier\u-vis

很大。简单的解决方案：使用

std:：vector

很可能您正在堆栈上创建一个

Explore

对象，这将导致

分段错误。您应该在堆上动态声明对象

int main() {
    Explore * obj = new Explore(...);
    delete obj; //since obj is on the heap, 
                //you have to take care of delete. using smart pointers 
                //like std::unique_ptr can efficiently handle the lifetime
    return 0;
}

而不是

int main() {
    Explore obj(...);
    return 0;
}

不过，您最好使用
std:：vector
。
很可能您正在堆栈上创建一个
Explore
对象，这将导致
分段错误。您应该在堆上动态声明对象

int main() {
    Explore * obj = new Explore(...);
    delete obj; //since obj is on the heap, 
                //you have to take care of delete. using smart pointers 
                //like std::unique_ptr can efficiently handle the lifetime
    return 0;
}

而不是

int main() {
    Explore obj(...);
    return 0;
}

您最好使用
std:：vector
。
如何实例化该类？你能分享一个-fsplit stack@eerorika吗？好的。你如何实例化这个类？你能分享一个-fsplit堆栈@eerorika好的，你在泄漏内存。如果你用的是独一无二的_ptr@skpro19当您使用
new
分配一些内存时，需要使用
delete
解除分配。但是如果您使用
std:：unique\u ptr
，这会自动发生。@skpro19当您从堆中分配存储时，通常会出现性能损失。系统必须找到足够大小的空闲存储空间。要从堆栈中获取内存，通常只需移动指针。在使用动态分配的对象时，您可能还会受到性能方面的影响，因为它们可能分散在内存中，从而更难缓存它们。由于类太大，这应该不是问题。@skpro19 2个主要原因是：您将泄漏内存（可能会耗尽内存），并且泄漏对象的析构函数不会运行。@user4581301程序运行时可能会耗尽内存。特别是考虑到OP分配了大量内存，你正在泄漏内存。如果你用的是独一无二的_ptr@skpro19当您使用
new
分配一些内存时，需要使用
delete
解除分配。但是如果您使用
std:：unique\u ptr
，这会自动发生。@skpro19当您从堆中分配存储时，通常会出现性能损失。系统必须找到足够大小的空闲存储空间。要从堆栈中获取内存，通常只需移动指针。在使用动态分配的对象时，您可能还会受到性能方面的影响，因为它们可能分散在内存中，从而更难缓存它们。由于类太大，这应该不是问题。@skpro19 2个主要原因是：您将泄漏内存（可能会耗尽内存），并且泄漏对象的析构函数不会运行。@user4581301程序运行时可能会耗尽内存。特别是考虑到OP分配了大量的块。@eerokia
，因为这个限制很难实施
-为什么这么说？@skpro19因为没有语言机制只允许在动态内存中创建对象。当然，您可以将构造函数设置为私有的，并提供返回唯一指针的自定义函数，但是编写所有这些函数可能是一大堆样板文件，如果您只是不将类设置为如此庞大的话，那么这些样板文件将是不必要的。@skpro19避免庞大成员的一种方法是动态分配成员，最好使用一个处理器来处理内存管理。这提供了一个动态分配的、自我管理的结构，在外界看来就像一个2D数组。@user4581301这里还有另一个@eerokia
，因为这个限制很难实施
-为什么这么说？@skpro19因为没有语言机制只允许在动态内存中创建对象。当然，您可以将构造函数设置为私有的，并提供返回唯一指针的自定义函数，但是编写所有这些函数可能是一大堆样板文件，如果您只是不将类设置为如此庞大的话，那么这些样板文件将是不必要的。@skpro19避免庞大成员的一种方法是动态分配成员，最好使用一个处理器来处理内存管理。这提供了一个动态分配的、自我管理的结构，在外部世界看起来就像一个2D数组。@user4581301这是另一个