Question

我将首先解释我的问题，然后提供很好的代码部分。我用一个名为process的自定义类填充队列。使用这一行：

ProcessQueue.push(new Process(inputs[0], inputs[1], inputs[2], inputs[3], inputs[4]));

这一切似乎都很好，当循环完成时，进程队列中充满了指针。但经过进一步检查，我发现他们都指向SAME对象？

发现这个好奇，我在循环的每次迭代中都进入了构造函数。

第一次迭代：当输入构造函数时，所有实例变量都为null（如预期的那样）

第二次迭代：进入构造函数后，所有实例变量都包含第一次迭代中给予对象的值（即：同一个对象）

此后，当我使用队列时，我确认队列中的每个指针都指向同一个进程对象。（我可以告诉这个，因为进程包含一个状态，如果循环通过队列改变状态，我会发现状态已经改变为第二个指针）

我怀疑我一定是在创建课堂上做错了。所以这就是完整的。

Process.h

    #pragma once
    class Process
    {
    public:
        Process(int _processId, int _arrivalTime, int _CPUTime,
            int _IOFrequency, int _IODuration);
        ~Process();

        bool HasArrived(int time);
        bool HasCompleted();
        bool HasFinishedBurst();
        bool HasFinishedIO();
        int GetQueueNum();
        int GetID();
        void SetQueueNum(int i);
        void SetToReady();
        void Run();
        void PerformIO();
    };

Process.cpp

    #include "stdafx.h"
    #include "Process.h"
    #include <string>

    using namespace std;

    int processId;
    int arrivalTime;
    int CPUTime;
    int IOFrequency;
    int IODuration;

    int Ticks;
    int CPUConsumption;
    int CPUBurstSize;
    int queueNumber;
    int IOBurstCount;
    string state;


    Process::Process(int _processId, int _arrivalTime, int _CPUTime,
        int _IOFrequency, int _IODuration)
    {
        processId = _processId;
        arrivalTime = _arrivalTime;
        CPUTime = _CPUTime;
        IOFrequency = _IOFrequency;
        IODuration = _IODuration;
        IOBurstCount = 0;
        CPUConsumption = 0;
        Ticks = 0;
        queueNumber = 0;

        state = "None";
        printf("%d: %s\n", processId,state.c_str());

        int excess = CPUTime % IOFrequency;
        if (excess == 0)
        {
            CPUBurstSize = CPUTime / IOFrequency;
        }
        else
        {
            CPUBurstSize = (CPUTime - excess) / (IOFrequency - 1);
        }
    }

    Process::~Process()
    {
    }

    bool Process::HasArrived(int time)
    {
        if (arrivalTime <= time)
        {
            if (state.compare("Newly Arrived") == 0)
            {
                printf("Already arrived!\n");
            }
            state = "Newly Arrived";
            printf("%d: %s\n", processId, state.c_str());
            return true;
        }
        else
        {
            return false;
        }

    }

    bool Process::HasCompleted()
    {
        if (CPUConsumption == CPUTime && IOBurstCount == IOFrequency)
        {
            state = "Finished";
            printf("%d: %s\n", processId, state.c_str());
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Process::HasFinishedBurst()
    {
        if (Ticks == CPUBurstSize)
        {
            Ticks = 0;
            state = "Blocked";
            printf("%d: %s\n", processId, state.c_str());
            return true;
        }
        else
        {
            return false;
        }
    }

    bool Process::HasFinishedIO()
    {
        if (Ticks >= IODuration)
        {
            IOBurstCount++;
            Ticks = 0;
            return true;
        }
        else
        {
            return false;
        }
    }

    void Process::SetToReady()
    {
        state = "Ready";
        printf("%d: %s\n", processId, state.c_str());
    }

    void Process::Run()
    {
        state = "Running";
        printf("%d: %s\n", processId, state.c_str());
        Ticks++;
        CPUConsumption++;
    }

    void Process::PerformIO()
    {
        Ticks++;
    }

    int Process::GetQueueNum()
    {
        return queueNumber;
    }

    void Process::SetQueueNum(int i)
    {
        queueNumber = i;
    }

    int Process::GetID()
    {
        return processId;
    }

我怀疑我以某种方式创建了这个静态类而没有意义......

Answer 1

您似乎已将所有成员变量放在课堂外了！

int processId;
int arrivalTime;
int CPUTime;
int IOFrequency;
int IODuration;

int Ticks;
int CPUConsumption;
int CPUBurstSize;
int queueNumber;
int IOBurstCount;
string state;

应该在这里：

class Process
{
public:
    Process(int _processId, int _arrivalTime, int _CPUTime,
        int _IOFrequency, int _IODuration);
    ~Process();

    bool HasArrived(int time);
    bool HasCompleted();
    bool HasFinishedBurst();
    bool HasFinishedIO();
    int GetQueueNum();
    int GetID();
    void SetQueueNum(int i);
    void SetToReady();
    void Run();
    void PerformIO();

private:
   int processId;
   int arrivalTime;
   int CPUTime;
   int IOFrequency;
   int IODuration;

   int Ticks;
   int CPUConsumption;
   int CPUBurstSize;
   int queueNumber;
   int IOBurstCount;
   string state;
};

Answer 2

您定义了全局变量

int processId;
int arrivalTime;
int CPUTime;
int IOFrequency;
int IODuration;

每次调用它时，

和类Process的构造函数都会覆盖它们的值。

Process::Process(int _processId, int _arrivalTime, int _CPUTime,
    int _IOFrequency, int _IODuration)
{
    processId = _processId;
    arrivalTime = _arrivalTime;
    CPUTime = _CPUTime;
    IOFrequency = _IOFrequency;
    IODuration = _IODuration;
    IOBurstCount = 0;
    CPUConsumption = 0;
    Ticks = 0;
    queueNumber = 0;
    //...

虽然类本身没有数据成员。

因此，这些全局变量保留在构造函数的最后一次调用中分配给它们的值。

新命令没有创建新对象C ++

2 个答案: