[C++]compileerfouten die ik niet snap

[ocf81]

Ik krijg bij het compileren van deze code een fout in de trant van GCC ... C++ forbids declaration 'stack' with no type. (in dit geval in regel 18 PowerOfTwo.h)

Normaal betekent dit geloof ik dat men iets vergeten is te includen, maar ik heb stack wel bij de includes staan, dus ik snap niet waarom gcc zeurt.
Verder krijg ik als ik dit omzeil via het includen van <stack.h> (was eigenlijk niet hoort) een heel lange lijst van onleesbare fouten over de <cmath> functies log10 en pow die ik prober te gebruiken voor het vaststellen van bepaalde 2-machten.

Mijn probleem: deadlines en een gebrek aan kennis van gcc gecombineerd met het weekeinde waarin het schoolgebouw dicht is. Tevens heb ik momenteel geen compiler ter beschikking omdat mijn windows install moeilijk doet, en daarom opnieuw geïnstalleerd moet worden. dit post ik met behulp van een ubuntu livedisk, maar die heeft geen gcc met cpp erop.
kan iemand mij vertellen wat ik fout doe? Ik ben een beetje radeloos, en ik heb maandag 2 uur om de oplossing te compileren en de testen uit te voeren voordat ik het in moet leveren.

Een kleine omschrijving van wat de code moet doen:

Het moet en geheugenallocatie systeem nabootsen. Ik heb voor power of two gekozen, en dit geïmplementeerd d.m.v. een array van stacks waarin ovjecten van de class Block worden gestopt waar het nummer van de arraycel de dichtsbijzijnde 2 macht waarin het gevraagde stuk geheugen past aangeeft. De stack heeft dan de blokjes. Als de stack leeg is gaat ie eerst ff een stukje van een hogere 2 macht ophalen en dat in 2-en knippen. Tester doet in de main() een paar allocaties om het eea te testen.

code:

#include "Block.h"

    Block::Block(int base, int size){
    this->size = size;
    this->base = base;
}

code:

#ifndef BLOCK_H
#define BLOCK_H

class Block{
public:
    int     base;
    int     allocSize;
    Block (int, int);
};

#endif

GlobalDefs.h

code:

#define MEMSIZE 10240
#define PAGESIZE    1024

PowerOfTwo.cpp

code:

#include "PowerOfTwo.h"

    PowerOfTwo::PowerOfTwo(){
//  for(int i = 0, i < 11, i++){
    int i = 0;
    while(i<11){
        Block * b = new Block(0, 1024);
        freeLists[10]->push(b);
    }
    memoryInUse = 0.0;
}

    PowerOfTwo::~PowerOfTwo(){
//  for(int i = 0, i < 11, i++){
    int i = 0;
    while(i<11){
        while(freeLists[i]->empty()){
            Block * p = freeLists[i]->top();
            delete p;
            freeLists[i]->pop();
        }
        i++;
    }
}

int PowerOfTwo::alloc(int theSize){
    steps = 1.0;
    int base = -1;
    int exp = nearestTwoPowerExponent(theSize);
    if(freeLists[exp]->empty()){
        steps++;
        bool found = false;
        int x = exp;
        while(!found){
            steps++;
            x++;
            if(!freeLists[x]->empty()){
                found = true;
            }
        }
        while(x > exp){
            steps++;
            Block * old = freeLists[x]->top();
            int baseNew = old->base;
            int sizeNew = old->allocSize / 2;
            delete old;
            freeLists[x]->pop();
            x--;
            Block * new1 = new Block(baseNew, sizeNew);
            Block * new2 = new Block(baseNew + sizeNew, sizeNew);
            freeLists[x+1]->pop();
            freeLists[x]->push(new1);
            freeLists[x]->push(new2);
        }
        Block * p = freeLists[exp]->top();
        base = p->base;
        delete p;
        freeLists[exp]->pop();
    }else{
        Block * p = freeLists[nearestTwoPowerExponent(theSize)]->top();
        base = p->base;
        delete p;
        freeLists[nearestTwoPowerExponent(theSize)]->pop();
    }
    if(base > -1){
        memoryInUse += nearestPowerOfTwo(theSize);
    }
    return base;    
}

bool    PowerOfTwo::dealloc(int position, int theSize){
    steps = 1.0;
    bool succes = false;
    Block * p = new Block(position, nearestPowerOfTwo(theSize));
    int size = nearestTwoPowerExponent(theSize);
    freeLists[size]->push(p);
    if(freeLists[size]->top()->base == position){
        succes = true;
        memoryInUse -= nearestPowerOfTwo(theSize);
    }
    return succes;
}

/*
int * PowerOfTwo::getMemory(){
    return memory;
}
*/

int PowerOfTwo::roundCeiling(double exp){
    steps++;
    double param, fractpart, intpart;
    param = exp;
    fractpart = modf (param , &intpart);
    if(fractpart < 0){
        intpart+=1.0;
    }
    return (int)intpart;
}

int PowerOfTwo::nearestPowerOfTwo(int input){
    steps++;
    double exp = log10((double)input)/log10(2.0); //berekent de 2 macht van het aangeleverde getal;
    return(int)pow(2, roundCeiling(exp)); //2 tot de macht ceiling rounded exp = dichtst bijzijnde 2machht waar het getal in past.
}

int PowerOfTwo::nearestTwoPowerExponent(int input){
    steps++;
    double exp = log10((double)input)/log10(2.0);
    double fractpart, intpart;
    fractpart = modf (exp , &intpart);
    if(fractpart < 0){
        intpart+=1.0;
    }
    return (int)intpart;
}

double  PowerOfTwo::getStappen(){
    return steps;
}

double  PowerOfTwo::memoryGebruik(){
    return memoryInUse;
}

PowerOfTwo.h

code:

#ifndef PowerOfTwo_H_
#define PowerOfTwo_H_
#include <cstdio>
#include <cmath>
#include <stack>
#include "Block.h"
#include "GlobalDefs.h"

class PowerOfTwo{
public:
                PowerOfTwo();
    virtual         ~PowerOfTwo();
                int     alloc(int);
                bool        dealloc(int, int);
                double      getStappen();
                double      memoryGebruik();
private:
    stack<Block *>  *   freeLists[10];
    int                 nearestPowerOfTwo(int);
    int                 roundCeiling(double);
    int                 nearestTwoPowerExponent(int);
    double              steps;
    double              memoryInUse;
};

#endif /*PowerOfTwo_H_*/

code:

#include "Tester.h"
#include "PowerOfTwo.h"

#include <time.h>

#include <stdlib.h>

#include <map>



Tester::main(){

double  score = 0;
       BestFit * PoT = new PowerofTwo();
       PoT->alloc(20); //programmaA vraag 20
       PoT->drukaf();
       score = score + PoT->getStappen();

       PoT->alloc(5);           //programmaB vraag 5
       PoT->drukaf();
       score = score + PoT->getStappen();

       PoT->alloc(15);          //programmaC vraagt 15
       PoT->drukaf();
       score = score + PoT->getStappen();

       PoT->dealloc(20,5); // programmaB wordt afgesloten
       PoT->drukaf();
       score = score + PoT->getStappen();

       PoT->alloc(3); //programmaD vraagt 5
       PoT->drukaf();
       score = score + PoT->getStappen();


       score = (score/(38/PoT->memoryGebruik())) * 100;
       cout <<"score is :"<< score << endl;

}

code:

#ifndef TESTER_H_
#define TESTER_H_

class Tester
{
public:
    main();
};
[s][/s]
#endif /*TESTER_H_*/

[ Voor 7% gewijzigd door ocf81 op 11-03-2006 16:40 ]

[whoami]

Sorry hoor, maar dat jij deadlines hebt en een gebrekkige kennis van c++, wil daarom nog niet zeggen dat je hier zomaar je code mag copy/pasten, en dan verwachten dat iemand anders jouw taak gaat maken.

We willen je best helpen,maar niet op deze manier. Nu verwacht je gewoon dat iemand hier die code voor jou gaat fixen, en dat doen we niet.