C++ C++；在别处访问时，类和对象变量似乎被覆盖

这是一个CS项目，我正在工作。在设计我的类之后，我遇到了一个问题，当再次调用某些变量时，它们会被覆盖。在一个特定的例子中，我试图在构造时将int类型设为=1，但后来当我回忆起函数外部的变量时，它被更改为6422216。我很确定这是因为我不善于使用指针和地址，但我不知道如何找到它

早些时候，时间变量也有类似的问题，但我设法使用Event*newEvent=newEvent（事件构造函数参数）修复了它，尽管我不确定为什么会修复它

主要功能启动点：

GEL EventList = GEL(); // Where GEL is a class type that contains an event list
int main()
{
    //VarInit intializes all of the main variables
    VarInit();
    
    //REMEMBER: 0 = ARRIVAL TYPE, 1 = DEPARTURE TYPE
    //Class functions goes as such
    //EventList.Schedule(float Time, int Type, Packet NewPacket) where Packet is a separate packet class
    EventList.Schedule(GenArrivalTime(), 0, GenPacket());

    for(int i = 0; i < 1; i++)
    {
        //Example Gen Arrival Time
        
        Event CurrentEvent = Event(EventList.Remove());

        cout << "Current Event addr: " << &CurrentEvent << "\n";
        float CurrentTime = CurrentEvent.EventTime;
        cout << "CurrentEvent Time: " << CurrentTime << "\n";
        cout << "CurrentEvent Type: " << CurrentEvent.EventType << "\n";
        //Here the Type gets changed from 0 to 6422216
    }

geleventlist=GEL（）；//其中GEL是包含事件列表的类类型
int main（）
{
//VarInit初始化所有主要变量
VarInit（）；
//记住：0=到达类型，1=离开类型
//类函数是这样的
//计划（浮动时间，int类型，Packet NewPacket），其中Packet是一个单独的包类
计划（GenArrivalTime（），0，GenPacket（））；
对于（int i=0；i<1；i++）
{
//发电机到达时间示例
Event CurrentEvent=Event（EventList.Remove（））；
cout在Insert函数中，NewEvent不是指针而是一个值，这意味着当您调用Insert（*Event）；，它将创建一个副本，在Insert函数返回后，对象NewEvent将被销毁

我认为您应该将Insert签名更改为Insert（Event*NewEvent）
在Insert函数中，NewEvent不是指针而是值，这意味着当您调用Insert（*Event）；，它将创建一个副本，Insert函数返回后，对象NewEvent将被销毁

我认为您应该将Insert签名更改为Insert（Event*NewEvent）
如果要使用指针，则需要保持一致。
计划
使用
新建
创建一个对象，然后通过值将该对象传递给
插入
，插入一个临时副本，然后存储该临时副本的地址，该临时副本在函数结束时被销毁。首先在
删除
事件中nt=*FrontEventPtr；
也会创建一个副本。如果要使用指针，则需要保持一致。
Schedule
使用
new
创建一个对象，然后按值将该对象传递给
Insert
以创建临时副本，然后存储在函数结束时销毁的临时副本的地址。在
删除
事件优先\u Event=*FrontEventPtr；
也制作了一份副本。保佑你的灵魂，我花了这么长时间试图调试它。我唯一能找到解决方法的方法就是随机更改一些东西，直到某些东西起作用。谢谢！保佑你的灵魂，我花了这么长时间试图调试它。我唯一能找到的方法是如果我发现了如何解决这个问题，我会随机改变一些东西，直到某些东西起作用。谢谢！

//I don't believe that there are any issues here
//When printing out the output it seems ok
void GEL::Schedule(float Time, int Type, Packet InsPacket)
{
    //create a new event called event with all of these arguments
    //Event(int _EventTime, Packet _ServicedPacket, int _EventType, Event* _NextEvent, Event * _PrevEvent);
    std::cout << "w/in GEL::Schedule EventTime = " << Time << "\n";
    std::cout << "w/in GEL::Schedule EventType = " << Type << "\n";
    //Type is OK here
    Event * NewEvent = new Event(Time, InsPacket, Type, NULL, NULL);
    //wow finally, all I had to do was insert the NEW keyword prolly because it doesn't change
    // insert that into the Insert function
    Insert(*NewEvent);
};

//I believe there might be an issue here, within the debugging print
//everything seems to be fine however afterwards it does change
Event GEL::Insert(Event NewEvent)
{
    if(FrontEventPtr == NULL)
    {
        //If there is nothing in the FrontEventPtr (head), then have the FrontEventPtr = NewEvent
        //Putting volatile as the packet seems to fix it here, but later breaks again in Remove()

        std::cout << "w/in GEL.Insert(): FrontEventPtr is NULL\n";

        //make the pointer point towards the new event
        FrontEventPtr = &NewEvent;

        std::cout << "w/in GEL::Insert() FrontEventPtr address: " << FrontEventPtr << "\n";
        std::cout << "w/in GEL.Insert(): FrontEventPtr -> EventTime = " << FrontEventPtr->EventTime << "\n";
        std::cout << "w/in GEL::Insert() EventType = " << FrontEventPtr->EventType << "\n";
        //hmmm for some reason EventType get's reassigned at this point

        return *FrontEventPtr;
    }

    //At this point FrontEventPtr contains something
    std::cout << "FrontEventPtr not null, setting a placeholder variable to store FrontEventPtr for further operations\n";
    Event* EventPlaceHolder = FrontEventPtr;

    if(EventPlaceHolder->EventTime > NewEvent.EventTime)
    {
        //If the current FrontEventPlaceholder is greater than the NewEvent Time, then set the new FrontEventPlaceholder equal to the NewEvent and swap items
        std::cout << "Swapping Items because old time is > new time\n";
        FrontEventPtr = &NewEvent;
        NewEvent.NextEvent = EventPlaceHolder;
        EventPlaceHolder->PrevEvent = &NewEvent;
        return NewEvent;
    }

    while((EventPlaceHolder->NextEvent != NULL) && (NewEvent.EventTime > EventPlaceHolder->NextEvent->EventTime))
    {
        //Keep swapping items until we find the right place to put the event
        EventPlaceHolder = EventPlaceHolder->NextEvent;
    }

    NewEvent.PrevEvent = EventPlaceHolder;
    NewEvent.NextEvent = EventPlaceHolder->NextEvent;
    EventPlaceHolder->NextEvent = &NewEvent;

    if(NewEvent.NextEvent != NULL)
    {
        NewEvent.NextEvent->PrevEvent = &NewEvent;
    }

    return NewEvent;
};

//The problem is very apparent here, it seems that the type variable changes here.
Event GEL::Remove()
{
    std::cout << "w/in GEL::Remove() FrontEventPtr address: " << FrontEventPtr << "\n";
    std::cout << "w/in GEL::Remove() FrontEventPtr -> EventTime = " << FrontEventPtr->EventTime << "\n";
    std::cout << "w/in GEL::Remove() EventType = " << FrontEventPtr->EventType << "\n";

    if(FrontEventPtr == NULL)
    {
        std::cout << "w/in GEL::Remove(), FrontEventPtr is null, returning *FrontEventPtr\n";
        return *FrontEventPtr;
    }

    std::cout << "w/in GEL::Remove(), FrontEventPtr != NULl\n";
    
    Event first_event = *FrontEventPtr;

    if(first_event.NextEvent != NULL)
    {
        first_event.NextEvent->PrevEvent = NULL;
    }

    FrontEventPtr = first_event.NextEvent;

    first_event.NextEvent = NULL;

    std::cout << "w/in GEL::Remove first_event.EventTime: " << first_event.EventTime << "\n";

    return first_event;
};