c++ - C++编译错误-未知类型名称

Question

对于我的CS分配，我们将实现一个二进制堆来替换她工作程序中的STL优先级队列，这是第一部分。对于第二部分，我们必须使用多态来重新实现它。我完成了第一部分，我所做的就是将所有类分为自己的 header 和源文件，并且出现了大量错误。在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;
}

调制解调器SimV2.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

调制解调器SimV2.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.h包括ModemSimV2.h。 ModemSimV2.h包括Event.h。没有一点帮助就行不通。

您应该阅读forward declarations。有关更多信息，请参见this StackOverflow question。