Четврта вежба¶

#include <cstring>
#include <fstream>
#include <iostream>
#include <random>

#include "Paket.h"
#include "Silos.h"
#include "Skladiste.h"

int main() {
    std::ifstream file("podaci.txt");

    auto skladiste = new Skladiste(9999999999, 2018);

    for (int i = 0; i < 1009; i++) {
        auto tip = new char[100];

        file >> tip;

        if (!strcmp(tip, "Silos")) {
            auto silos = new Silos();
            file >> silos;
            skladiste->Dodaj(silos);
        } else {
            auto paket = new Paket();
            file >> paket;
            skladiste->Dodaj(paket);
        }
    }

    file.close();

    std::cout << "Uk. kolicina: " << skladiste->UkupnaKolicina() << std::endl;

    std::ofstream upis("sifre.txt");

    skladiste->ListaSifara(upis);

    skladiste->Sort();

    skladiste->ListaSifara(std::cout);

    delete skladiste;

    return 0;
}

#ifndef SKLADISTE_H
#define SKLADISTE_H
#include "Element.h"


class Skladiste {
private:
    double maxCapacity;
    int count;
    int maxSize;
    Element **elements;

public:
    Skladiste(double maxCapacity, int count);

    ~Skladiste();

    bool Dodaj(Element *element);

    double UkupnaKolicina();

    void ListaSifara(std::ostream &output);

    void Sort();

    friend std::ostream &operator<<(std::ostream &output, const Skladiste &skladiste);
};



#endif

#include "Skladiste.h"

#include <cstring>

Skladiste::Skladiste(double maxCapacity, int maxSize) {
    this->maxCapacity = maxCapacity;
    this->maxSize = maxSize;
    this->elements = new Element*[maxSize];
    this->count = 0;
}

Skladiste::~Skladiste() {
    delete[] this->elements;
}

bool Skladiste::Dodaj(Element *element) {
    if (UkupnaKolicina() + element->Kolicina() > maxCapacity) {
        return false;
    }

    elements[count++] = element;

    return true;
}

double Skladiste::UkupnaKolicina() {
    double ukupnaKolicina = 0;

    for (int i = 0; i < count; i++) {
        ukupnaKolicina += elements[i]->Kolicina();
    }

    return ukupnaKolicina;
}

void Skladiste::ListaSifara(std::ostream &output) {
    for (int i = 0; i < count; i++) {
        bool found = false;

        for (int j = 0; j < count && !found; j++) {
            if (i == j) {
                continue;
            }

            if (elements[i]->SifraMaterijala() == elements[j]->SifraMaterijala()) {
                found = true;
            }
        }

        if (!found) {
            output << elements[i]->SifraMaterijala() << " ";
        }
    }

    output << std::endl;
}

std::ostream &operator<<(std::ostream &output, const Skladiste &skladiste) {
    auto sorted = new Element*[skladiste.count];
    for (int i = 0; i < skladiste.count; i++) {
        for (int j = i + 1; j < skladiste.count; j++) {
            if (skladiste.elements[i]->SifraMaterijala() > skladiste.elements[j]->SifraMaterijala()) {
                sorted[i] = skladiste.elements[j];
            }
        }
    }

    for (int i = 0; i < skladiste.count; i++) {
        sorted[i]->Prikaz(output);
    }

    delete[] sorted;

    output << std::endl;

    return output;
}

void Skladiste::Sort() {
    for (int i = 0; i < count - 1; i++) {
        for (int j = i + 1; j < count; j++) {
            if (elements[i] > elements[j]) {
                auto tmp = elements[i];
                elements[i] = elements[j];
                elements[j] = tmp;
            }
        }
    }
}

#ifndef ELEMENT_H
#define ELEMENT_H
#include <ostream>


class Element {
protected:
    int sifra;
    int sifraMaterijal;
    float kolicina;

public:

    int SifraMaterijala() const;

    float Kolicina() const;

    virtual void Prikaz(std::ostream &output) = 0;

    bool operator>(const Element *element) const;

    bool operator<(const Element *element) const;

    bool operator==(const Element *element) const;
};



#endif

#include "Element.h"

int Element::SifraMaterijala() const {
    return sifra;
}

float Element::Kolicina() const {
    return kolicina;
}

bool Element::operator>(const Element *element) const {
    return this->sifra > element->sifra;
}

bool Element::operator<(const Element *element) const {
    return this->sifra < element->sifra;
}

bool Element::operator==(const Element *element) const {
    return this->sifra == element->sifra;
}

#ifndef PAKET_H
#define PAKET_H
#include "Element.h"


class Paket : public Element {
private:
    char *lot;
    char *tip;

public:
    Paket();

    Paket(int sifra, int sifraMaterijal, float kolicina, char *lot, char *tip);

    friend std::istream &operator>>(std::istream &input, Paket *paket);

    void Prikaz(std::ostream& output) override;
};



#endif

#include "Paket.h"

#include <cstring>
#include <stdexcept>
#include <istream>

Paket::Paket() {
    this->sifra = 0;
    this->sifraMaterijal = 0;
    this->kolicina = 0;
    this->lot = nullptr;
    this->tip = nullptr;
}

Paket::Paket(int sifra, int sifraMaterijal, float kolicina, char* lot, char* tip) {
    if (tip == nullptr || strlen(tip) < 1 || !(tip[0] >= 'A' && tip[0] <= 'Z' || tip[0] >= 'a' && tip[0] <= 'z')) {
        throw std::runtime_error("Tip paketa nije validan");
    }

    this->sifra = sifra;
    this->sifraMaterijal = sifraMaterijal;
    this->kolicina = kolicina;
    this->lot = new char[100];
    strcpy(this->lot, lot);
    this->tip = new char[100];
    strcpy(this->tip, tip);
}

std::istream &operator>>(std::istream &input, Paket *paket) {
    paket->lot = new char[100];
    paket->tip = new char[100];

    input >> paket->sifra >> paket->sifraMaterijal >> paket->kolicina >> paket->lot >> paket->tip;

    if (strlen(paket->tip) < 1 || !(paket->tip[0] >= 'A' && paket->tip[0] <= 'Z' || paket->tip[0] >= 'a' && paket->tip[0] <= 'z')) {
        throw std::runtime_error("Tip paketa nije validan");
    }

    return input;
}

void Paket::Prikaz(std::ostream &output) {
    output << this->sifra << " " << this->sifraMaterijal << " " << this->kolicina << " " << this->lot << " " << this->tip << std::endl;
}

#ifndef SILOS_H
#define SILOS_H
#include "Element.h"


class Silos : public Element {
private:
    char *lot;
    double maxCapacity;

public:
    Silos();

    Silos(int sifra, int sifraMaterijal, float kolicina, char *lot, double maxCapacity);

    friend std::istream &operator>>(std::istream &input, Silos *silos);

    void Prikaz(std::ostream& output) override;
};



#endif

#include "Silos.h"

#include <cstring>
#include <stdexcept>
#include <istream>

Silos::Silos() {
    this->sifra = 0;
    this->sifraMaterijal = 0;
    this->kolicina = 0;
    this->lot = nullptr;
    this->maxCapacity = 0;
}

Silos::Silos(int sifra, int sifraMaterijal, float kolicina, char* lot, double maxCapacity) {
    if (kolicina > maxCapacity) {
        throw std::runtime_error("Kolicina ne moze biti veca od maxCapacity");
    }

    this->sifra = sifra;
    this->sifraMaterijal = sifraMaterijal;
    this->kolicina = kolicina;
    this->lot = new char[100];
    strcpy(this->lot, lot);
    this->maxCapacity = maxCapacity;
}

std::istream &operator>>(std::istream &input, Silos *silos) {
    silos->lot = new char[100];

    input >> silos->sifra >> silos->sifraMaterijal >> silos->kolicina >> silos->lot >> silos->maxCapacity;

    if (silos->kolicina > silos->maxCapacity) {
        throw std::runtime_error("Kolicina ne moze biti veca od maxCapacity");
    }

    return input;
}

void Silos::Prikaz(std::ostream &output) {
    output << this->sifra << " " << this->sifraMaterijal << " " << this->kolicina << " " << this->lot << " " << this->maxCapacity << std::endl;
}