C++ C++；使用vector作为类实例的静态容器

我使用向量作为类的静态成员来计算类本身及其派生类的所有实例。然而，当试图调整容器的大小时，向量本身会引发堆栈溢出

 // initialize static values:
    auto_ptr<HandleManager> ID3OBJ::HM = auto_ptr<HandleManager>(new HandleManager());
    auto_ptr<vector<shared_ptr<ID3OBJ>>> ID3OBJ::ObjectList = auto_ptr<vector<shared_ptr<ID3OBJ>>>(new vector<shared_ptr<ID3OBJ>>{});

//初始化静态值：
auto_ptr ID3OBJ:：HM=auto_ptr（新的HandleManager（））；
auto_ptr ID3OBJ:：ObjectList=auto_ptr（新向量{}）；

我将静态成员初始化为空，如上所示

// constructors:
        ID3OBJ::ID3OBJ(double x, double y, double z) : X(x), Y(y), Z(z), Handle(this->HM->addHandle()) { ObjectList->push_back(auto_ptr<ID3OBJ>(this));}
        ID3OBJ::ID3OBJ() : X(0), Y(0), Z(0), Handle(this->HM->addHandle()) { ObjectList->push_back(shared_ptr<ID3OBJ>(this));}

        Vector::Vector(double x, double y, double z) { X = x; Y = y; Z = z;
        ObjectList->push_back(auto_ptr<Vector>(this));}
        Vector::Vector() {
            X = 0; Y = 0; Z = 0;
            ObjectList->push_back(shared_ptr<Vector>(this));}

//构造函数：
ID3OBJ:：ID3OBJ（双x，双y，双z）：x（x），y（y），z（z），句柄（this->HM->addHandle（））{ObjectList->push_back（auto_ptr（this））；}
ID3OBJ:：ID3OBJ（）：X（0），Y（0），Z（0），句柄（this->HM->addHandle（））{ObjectList->push_back（shared_ptr（this））；}
向量：向量（双x，双y，双z）{x=x；y=y；z=z；
ObjectList->push_back（自动_ptr（this））；}
向量：：向量（）{
X=0；Y=0；Z=0；
ObjectList->push_back（共享_ptr（this））；}

构造函数将任何新实例添加到instancelist，称为ObjectList。这是工作的预期

// deconstructors:
    ID3OBJ::~ID3OBJ()
    {
        string tempH = this->Handle;
        auto iter = ObjectList->end();
        if (ObjectList->size() == HM->assignedHandles())
        {
            iter = remove_if(ObjectList->begin(), ObjectList->end(), [&](shared_ptr<ID3OBJ> ptr) {return ptr->getHandle() == tempH; });
        }
        ObjectList->erase(iter, ObjectList->end());
        this->HM->removeHandle(this->Handle);
    }

    Vector::~Vector()
    {
        string tempH = this->Handle;
        auto iter = ObjectList->end();
        if (ObjectList->size() == HM->assignedHandles())
        {
            iter=remove_if(ObjectList->begin(), ObjectList->end(), [&](shared_ptr<ID3OBJ> ptr) {return ptr->getHandle() == tempH; });
        }
        ObjectList->erase(iter, ObjectList->end());
    }

//解构器：
ID3OBJ:：~ID3OBJ（）
{
字符串tempH=this->Handle；
auto iter=ObjectList->end（）；
如果（ObjectList->size（）==HM->assignedHandles（））
{
iter=remove_if（ObjectList->begin（），ObjectList->end（），[&]（shared_ptr ptr）{return ptr->getHandle（）==tempH；}）；
}
ObjectList->erase（iter，ObjectList->end（））；
此->HM->移除句柄（此->句柄）；
}
向量：：~Vector（）
{
字符串tempH=this->Handle；
auto iter=ObjectList->end（）；
如果（ObjectList->size（）==HM->assignedHandles（））
{
iter=remove_if（ObjectList->begin（），ObjectList->end（），[&]（shared_ptr ptr）{return ptr->getHandle（）==tempH；}）；
}
ObjectList->erase（iter，ObjectList->end（））；
}

据我所知，remove_if用事件发生后的元素替换pred返回true的任何事件。表示如果以vec[3]作为参数的pred返回true，则vec[2]指向vec[4]，而不是vec[3]。 因此，需要使用擦除函数来缩短容器长度，但是一旦我实现了这种缩短，就会出现错误

头文件：

// class-name:      ID3OBJ
    // Date:            30.01.2017
    // Version:         1.0
    // Description:     The class works as base class for all used 3D-Objects, and defines the operations all 3D-Objects have, namely the Direction in case of a vector, or origion in all other cases
    //

    class ID3OBJ
    {
    public:
        double X;
        double Y;
        double Z;
        static auto_ptr<vector<shared_ptr<ID3OBJ>>> ObjectList;

        ID3OBJ(double x, double y, double z);
        ID3OBJ();
        ~ID3OBJ();
        const string getHandle();

    protected:
        string Handle;
        static auto_ptr<HandleManager> HM;
    };

    // class-name:      I3DM
    // Date:            23.03.2017
    // Version:         1.0
    // Description:     The class works as Interface for classes which can do Vector-operations 
    //
    template <class T> class I3DM : public virtual ID3OBJ
    {
    public:
        using ID3OBJ::X;
        using ID3OBJ::Y;
        using ID3OBJ::Z;

        static auto_ptr<vector<shared_ptr<T>>> ObjectList;
    protected:
        using ID3OBJ::Handle;
        using ID3OBJ::HM;
    };
    // class-name:      Vector
    // Date:            30.01.2017
    // Version:         1.0
    // Description:     The class works as vector, it provides an interface to acces and modify vectors, aswell as most of the vector operations
    //
    class Vector : public virtual I3DM<Vector>
    { 
    public:
        using I3DM<Vector>::X;
        using I3DM<Vector>::Y;
        using I3DM<Vector>::Z;
        using I3DM<Vector>::ObjectList;
        Vector(double x, double y, double z);
        Vector();
        ~Vector();
    //I'm not sure if the protected members have to be provided aswell in the header file
    protected:
        using ID3OBJ::Handle;
        using ID3OBJ::HM;
    };

//类名：ID3OBJ
//日期：2017年1月30日
//版本：1.0
//描述：该类用作所有使用的三维对象的基类，并定义所有三维对象的操作，即向量的方向，或所有其他情况下的原点
//
类ID3OBJ
{
公众：
双X；
双Y；
双Z；
静态自动ptr对象列表；
ID3OBJ（双x、双y、双z）；
ID3OBJ（）；
~ID3OBJ（）；
常量字符串getHandle（）；
受保护的：
弦柄；
静态自动测试HM；
};
//类名：I3DM
//日期：2017年3月23日
//版本：1.0
//描述：该类用作可以执行向量操作的类的接口
//
模板类I3DM：公共虚拟ID3OBJ
{
公众：
使用ID3OBJ:：X；
使用ID3OBJ：：Y；
使用ID3OBJ:：Z；
静态自动ptr对象列表；
受保护的：
使用ID3OBJ:：Handle；
使用ID3OBJ:：HM；
};
//类名：Vector
//日期：2017年1月30日
//版本：1.0
//描述：该类用作向量，它提供访问和修改向量的接口，以及大多数向量操作
//
类向量：公共虚拟I3DM
{ 
公众：
使用I3DM：：X；
使用I3DM：：Y；
使用I3DM：：Z；
使用I3DM:：ObjectList；
向量（双x，双y，双z）；
向量（）；
~Vector（）；
//我不确定是否也必须在头文件中提供受保护的成员
受保护的：
使用ID3OBJ:：Handle；
使用ID3OBJ:：HM；
};

HM标题：

class HandleManager
    {
    public:
        HandleManager();
        const int assignedHandles();
        const string addHandle();
        void removeHandle(string hexstring);
    protected:
        int AssignedHandles;
        forward_list<int> FreeHandles;
        bool FreeHandlesAvailable;
    };

类句柄管理器
{
公众：
HandleManager（）；
const int assignedHandles（）；
常量字符串addHandle（）；
void removehold（字符串hextstring）；
受保护的：
int赋值句柄；
前向列表自由句柄；
bool Freehandles可用；
};

CPP：

const int string_到_hex（字符串s）
{
返回值；
溪流；
流返回值；
返回值；
}
HandleManager:：HandleManager（）
{
此->FreeHandlesAvailable=false；
此->AssignedHandles=0；
}
const int HandleManager:：assignedHandles（）
{
返回此->AssignedHandles；
}
常量字符串句柄管理器：：addHandle（）
{
字符串返回值；
如果（此->FreeHandlesAvailable）
{
returnValue=int_to_hex（this->freeholds.front（））；
这->freeholds.pop_front（）；
此->AssignedHandles++；
如果（this->FreeHandles.empty（））{this->freehandlesavable=false；}
}
其他的
{
returnValue=int_to_hex（此->赋值句柄）；
此->AssignedHandles++；
如果（this->AssignedHandles==1）{returnValue=int_to_hex（（int）0）；}
}
返回值；
}
void HandleManager:：removeHandle（字符串hextString）
{
此->FreeHandlesAvailable=true；
这->自由手柄。向前推（字符串到十六进制（十六进制字符串））；
此->分配句柄--；
}

错误消息：

RVE.exe中0x00C01899处未处理的异常：0xC00000FD:堆栈溢出（参数：0x00000001、0x01002F48）。发生

---

参数0x00000001很可能是一个句柄，是否有任何方法可以搜索具有给定内存地址的对象？（0x01002F48）

考虑从向量中删除

ID3OBJ

时会发生什么：

该向量将破坏

自动\u ptr

它将试图破坏

ID3OBJ

<

const int string_to_hex(string s)
{
    int returnvalue;
    stringstream stream;
    stream << hex << s;
    stream >> returnvalue;
    return returnvalue;
}
HandleManager::HandleManager()
{
    this->FreeHandlesAvailable = false;
    this->AssignedHandles = 0;
}
const int HandleManager::assignedHandles()
{
    return this->AssignedHandles;
}
const string HandleManager::addHandle()
{
    string returnValue;
    if (this->FreeHandlesAvailable)
    {
        returnValue = int_to_hex(this->FreeHandles.front());
        this->FreeHandles.pop_front();
        this->AssignedHandles++;
        if (this->FreeHandles.empty()) { this->FreeHandlesAvailable = false; }
    }
    else
    {
        returnValue = int_to_hex(this->AssignedHandles);
        this->AssignedHandles++;
        if (this->AssignedHandles == 1) { returnValue = int_to_hex((int)0); }
        }
    return returnValue;
}
void HandleManager::removeHandle(string hexstring)
{
    this->FreeHandlesAvailable = true;
    this->FreeHandles.push_front(string_to_hex(hexstring));
    this->AssignedHandles--;
}

int a;
auto_ptr< int > ap0( &a );   // certain death.
shared_ptr< int > ap1( &a ); // also certain death.

auto_ptr< int > ap( new int );
auto_ptr< int > ap0( ap.get() );   // certain death.
shared_ptr< int > ap1( ap.get() ); // also certain death.