C++コンパイルエラー - 不明なタイプ名

Question

私のCS割り当てでは、作業プログラムの最初の部分であるSTL優先順位キューを置き換えるバイナリヒープを実装しました。 2番目の部分については、多態性を使用して再実装する必要があります。私は最初の部分を終えました。私がしたのは、すべてのクラスを独自のヘッダーとソースファイルに分割していたため、膨大な量のエラーが発生しました。 xcodeでは、不明なタイプ名 'Event'と表示されます。

私は#ifndefのものを変更しようとしました（申し訳ありませんが、私はそれが呼び出されているか分からない）が、運がない。

ご協力いただきありがとうございます、ありがとうございます。

デビッド

---

私はXcodeのを使用していますが、ここではターミナルからのエラーメッセージがあります：

In file included from ModemSimV2.h:5, 
       from Event.h:4, 
       from Event.cpp:1: 
EventHeap.h:18: error: expected ‘,’ or ‘...’ before ‘&’ token 
EventHeap.h:18: error: ISO C++ forbids declaration of ‘Event’ with no type 
EventHeap.h:19: error: ISO C++ forbids declaration of ‘Event’ with no type 
EventHeap.h:19: error: expected ‘;’ before ‘*’ token 
EventHeap.h:23: error: ISO C++ forbids declaration of ‘Event’ with no type 
EventHeap.h:23: error: expected ‘;’ before ‘*’ token 
In file included from Event.h:4, 
       from EventHeap.h:8, 
       from EventHeap.cpp:1: 
ModemSimV2.h:11: error: ‘EventHeap’ has not been declared 
ModemSimV2.h:23: error: ISO C++ forbids declaration of ‘EventHeap’ with no type 
ModemSimV2.h:23: error: expected ‘;’ before ‘*’ token 
EventHeap.cpp: In constructor ‘EventHeap::EventHeap()’: 
EventHeap.cpp:6: error: call of overloaded ‘Event()’ is ambiguous 
Event.h:10: note: candidates are: Event::Event(int, int) 
Event.h:9: note:     Event::Event() 
EventHeap.cpp: In constructor ‘EventHeap::EventHeap(int)’: 
EventHeap.cpp:12: error: call of overloaded ‘Event()’ is ambiguous 
Event.h:10: note: candidates are: Event::Event(int, int) 
Event.h:9: note:     Event::Event() 
EventHeap.cpp: In member function ‘void EventHeap::buildHeap(int)’: 
EventHeap.cpp:40: error: call of overloaded ‘Event()’ is ambiguous 
Event.h:10: note: candidates are: Event::Event(int, int) 
Event.h:9: note:     Event::Event() 

---

main.cppに：

#include <queue> 
#include <vector> 
#include <functional> // for greater() 
#include <climits>  // for INT_MAX 
#include <iostream> 
#include "random.h" 
#include "ModemSimV2.h" 
#include "Event.h" 
#include "EventHeap.h" 


using namespace std; 

// Simple main to test ModemSim class. 
int main() 
{ 
    int numModems; 
    int totalTime; 
    double avgConnectTime; 
    int dialInFrequency; 

    cout << "Enter number of modems, length of simulation,\n" 
    << " average connect time, how often calls occur: "; 

    cin >> numModems >> totalTime >> 
    avgConnectTime >> dialInFrequency; 

    EventHeap eHeap(numModems); 
    ModemSimV2 s(numModems, avgConnectTime, dialInFrequency, eHeap); 
    s.runSim(totalTime); 

    return 0; 
} 

Event.h：

#ifndef EVENT_P2_H 
#define EVENT_P2_H 

#include "ModemSimV2.h" 

class Event{ 
    //enum { DIAL_IN = 1, HANGUP = 2 }; 
public: 
    Event(); 
    Event(int name = 0, int tm = 0); 

    bool operator > (const Event & rhs) const; 
    bool operator < (const Event & rhs) const; 
    bool operator <= (const Event & rhs) const; 
    bool operator != (const Event & rhs) const; 

    //void process(ModemSimV2 m); 

    friend class ModemSimV2; 

private: 
    int who;  // the number of the user 
    int time;  // when the event will occur 
    int what;  // DIAL_IN or HANGUP 
}; 

/* 
class Dialin : public Event{ 

public: 
    Dialin(); 
    void process(ModemSimV2 m); 
};*/ 
#endif 

---

Event.cpp：

#include "Event.h" 

Event::Event() { 

} 

Event::Event(int name, int tm) 
: time(tm), who(name) { 
    return; 
} 

bool Event::operator > (const Event & rhs) const { 
    return time > rhs.time; 
} 

bool Event::operator < (const Event & rhs) const { 
    return time < rhs.time; 
} 

bool Event::operator <= (const Event & rhs) const { 
    return time < rhs.time; 
} 

bool Event::operator != (const Event & rhs) const { 
    return time != rhs.time; 
} 

---

EventHeap.h：

#ifndef BINARY_HEAP_P2_H 
#define BINARY_HEAP_P2_H 

#include <iostream> 
#include <cmath> 
#include <vector> 

#include "Event.h" 

class EventHeap{ 
public: 
    EventHeap(); 
    EventHeap(int numIndex); 

    bool empty() const; 
    const int & findMin() const; 

    void push(const Event & x); 
    Event * pop(); 

private: 
    int size;   // Number of elements in heap 
    Event *array;   // The heap array 

    void buildHeap(int index); 
    void reIndex(int hole); 
    int getLeft(int index) const; 
    int getRight(int index)const; 
    int getParent(int index)const; 
}; 


#endif 

---

EventHeap.cpp：

#include "EventHeap.h" 

//Constructor 
EventHeap::EventHeap() { 

    array = new Event[1]; 
    size = 0; 
} 

EventHeap::EventHeap(int numVals) { 

    array = new Event[numVals]; 
    size = 0; 
} 

//insert 
void EventHeap::push(const Event &e) { 

    array[size] = e; 
    reIndex(size); 
    size++; 
} 

//removes the min val 
Event* EventHeap::pop() { 

    Event *e = &array[0]; 
    array[0] = array[size - 1]; 
    size--; 
    if(!empty()) 
     buildHeap(0); 

    return e; 
} 

//re do 
void EventHeap::buildHeap(int nodeIndex) { 

    int leftChildIndex, rightChildIndex, minIndex; 
    Event tmp; 

    leftChildIndex = getLeft(nodeIndex); 

    rightChildIndex = getRight(nodeIndex); 

    if (rightChildIndex >= size) { 

     if (leftChildIndex >= size) 

      return; 

     else 

      minIndex = leftChildIndex; 

    } else { 

     if (array[leftChildIndex] <= array[rightChildIndex]) 

      minIndex = leftChildIndex; 

     else 

      minIndex = rightChildIndex; 

    } 

    if (array[nodeIndex] > array[minIndex]) { 

     tmp = array[minIndex]; 

     array[minIndex] = array[nodeIndex]; 

     array[nodeIndex] = tmp; 

     buildHeap(minIndex); 

    } 
} 


//re index 
void EventHeap::reIndex(int hole) { 

    while(array[hole] != NULL && array[hole] < array[getParent(hole)]) { 
     int pIndex = getParent(hole); 
     Event temp(array[hole]); 
     array[hole] = array[pIndex]; 
     array[pIndex] = temp; 
     hole = pIndex; 
    } 
} 

//is Empty 
bool EventHeap::empty() const { 
    return (size == 0); 
} 

int EventHeap::getLeft(int index) const { 
    return (index * 2) + 1; 
} 

int EventHeap::getRight(int index) const { 
    return (index * 2) + 2; 
} 

int EventHeap::getParent(int index) const { 
    return (index - 1)/2; 
} 

---

ModemSimV2.h

#ifndef MODEM_SIM_V2_H 
#define MODEM_SIM_V2_H 

#include "Event.h" 
#include "EventHeap.h" 
#include "random.h" 


class ModemSimV2{ 
public: 
    ModemSimV2(int modems, double avgLen, int callIntrvl, EventHeap e); 
    // Add a call to eventSet at the current time, 
    // and schedule one for delta in the future. 
    void nextCall(int delta); 

    // Run the simulation 
    void runSim(int stoppingTime);// = INT_MAX); 

    // friend class Event; 

private: 
    Random r;      // A random source 
    EventHeap *eventSet;     // Pending events 

    // Basic parameters of the simulation 
    int freeModems;     // Number of modems unused 
    const double avgCallLen;  // Length of a call 
    const int freqOfCalls;   // Interval between calls 
}; 

#endif 

---

ModemSimV2.cpp

#include "ModemSimV2.h" 

// Constructor for ModemSim. 
ModemSimV2::ModemSimV2(int modems, double avgLen, int callIntrvl, EventHeap e) 
: freeModems(modems), avgCallLen(avgLen), 
freqOfCalls(callIntrvl), r((int) time(0)) 
{ 
    eventSet = &e; 
    nextCall(freqOfCalls); // Schedule first call 
} 

// Place a new DIAL_IN event into the event queue. 
// Then advance the time when next DIAL_IN event will occur. 
// In practice, we would use a random number to set the time. 
void ModemSimV2::nextCall(int delta){ 
    static int nextCallTime = 0; 
    static int userNum = 0; 

    eventSet->push(Event(userNum++, nextCallTime)); 
    nextCallTime += delta; 
} 

// Run the simulation until stopping time occurs. 
void ModemSimV2::runSim(int stoppingTime){ 
    Event *e; 

    while(!eventSet->empty()){ 
     e = eventSet->pop(); 
     if (e->time > stoppingTime) 
      break; 
     //e->process(this); 
     nextCall(freqOfCalls); 
    } 
} 

Answer 1

Event.hModemSimV2.hを含みます。 ModemSimV2.hには、Event.hが含まれます。それは少しの助けなしにはうまくいかないでしょう。

forward declarationsにお読みください。詳細については、this StackOverflow questionを参照してください。