Zaimplementuj klasę kretowisko:

class Kretowisko{
public:
    vector<Komora> komory;
 
    /*
     * dodaje komorę, ale tylko w przypadku,
     * kiedy nie przecina się z posotałymi
     */
    bool dodaj(const Komora&k);
    /*
     * Buduje kretowisko losując n komór o współrzednych x, y z zakresu [min,max]
     * Wygenerowane komory należy przesunąć o dx=rand()%scatter, dy=rand()%scatter i dz=0
     * Ponieważ komory są pod ziemią - dla współrzednej z losuj z zakresu -abs(depth) do -1
     */
    void buduj(int n, int min, int max, int depth, int scatter);
 
    /*
     * Zapisz w formacie ( komora1,komora2,komora3,....)
     */
    ostream&wypisz(ostream&os)const;
 
    /*
     * Wczytaj w takim formacie, jak zapisałeś
     */
 
    istream&wczytaj(istream&is);
 
    /*
     * Zwróć całkowitą powierzchnię komór
     */
    int powierzchnia()const;
    /*
     * Zwróć  powierzchnię komór na głębokości depth
     */
    int powierzchnia(int depth)const;
 
    /*
     * Zwróć całkowitą objętość komór
     */
    int objetosc()const;
 
    /*
     * Zwróć objętość komór od -inf do głębokości depth
     * Jest to patrząc formalnie całka powierzchnia(d) delta_d
     * Ale powierzchnia(d) to funkcja odcnikami stała...
     */
    int objetosc(int depth)const;
 
    /*
     * Wszystkie komory są połączone ze sobą. Złośliwy ogrodnik wlał do kretowiska wodę,
     * która rozpłynęła się pomiędzy komoram.
     * Załóż że objętość wlanej wody nie przewyższa sumarycznej objętości komór
     * Oblicz do jakiego poziomu zostaną zalane komory?
     */
    double poziom_wody(double v)const;
 
};

bool Kretowisko::dodaj(const Komora&k){
    return true;
}
 
void Kretowisko::buduj(int n, int min, int max, int depth, int scatter){
    int i=0;
    if(depth>0)depth*=-1;
    while(i<n){
        Komora k;
        // ?????
 
        if(dodaj(k))i++;
    }
}
 
ostream&Kretowisko::wypisz(ostream&os)const{
    os<<'(';
    // ...
 
    os<<')';
    return os;
}
 
 
istream&Kretowisko::wczytaj(istream&is){
    komory.????(); nie chcemy poprzednio zdefiniowanych komór
    int c;
    do{
        c=is.get();
    }while(????); // znajdź '(' ale przerwij, gdy !is
 
    for(;;){
        c=is.get(); 
        // jeżeli koniec pliku lub napotkano ')' to przerwij
        if(c=='('){
            // jeżeli napotkano '(', to
            // cofnij znak do strumienia za pomocą unget()
            // wczytaj komorę i dodaj do kretowiska 
         }
     }
     return is;
}

/*
 * Wywołaj metodę buduj i wypisz
 */
void test_kretowisko_buduj(){
}
 
/*
 * Wczytaj ze stringu i wypisz
 */
void test_kretowisko_wczytaj()
{
    string s="(( 8 15 -5 , 11 14 -7 ) ( 14 13 -4 , 17 11 -8 ) ( 13 7 -3 , 16 4 -4 ) "
              "( 1 6 -7 , 4 4 -10 ) ( 16 20 -4 , 18 19 -10 ) ( 5 16 -7 , 8 14 -8 ) "
              "( 13 11 -3 , 17 10 -5 ) ( 11 20 -2 , 13 18 -7 ) ( 17 14 -5 , 18 12 -8 ) "
              "( 17 18 -4 , 20 16 -9 ) )";
    istringstream is(s);
}
 
/*
 * Zbuduj
 * Zapisz do stringu s
 * Wczytaj ze stringu s
 * Wypisz na cout
 * Zapisz do stringu s2
 * Porównaj stringi
 */
 
void test_kretowisko_buduj_zapisz_wczytaj_wypisz(){
    srand(0);
}

Rysunek ilustruje wykresy powierzchni i objętości

Uwage - możesz chcieć umieścić wpółrzędne z komór w kontenerze set<int> punkty a następnie przeiterować: for(int z:punkty) … w z zachodzi zmiana powierzchni

Napisz testy związane z zalewaniem wodą
 
/*
 * Utwórz kretowisko z jedną komorą
 * Przeiteruj od z2 do z1 w pętli i wypisuj powierzchnię i sumaryczną objetość poniżej z
 */
 
void test_jedna_komora(){
 
}
 
/*
 * Analogicznie przetestuj dwie komory
 */
 
void test_dwie_komory(){
 
}
 
/*
 * Znajdź z_min i z_max
 * W pętli z od z_min do z_max dla 100 punktów
 * Wypisz powierzchnię(z), przybliżoną objętość (całkowanie metodą trapezów) 
 */
 
void test_objetosc_odd(){
 
}
 
/*
 * Oblicz całkowitą objętość komór
 * W pętli od 0 do V oblicz głębokość dla v
 * Wypisz v, d, i powierzchnię(d)
 */
void test_poziom_wody_odv(){
 
}