» »

[C++] Iskalno drevo implementacija

[C++] Iskalno drevo implementacija

Matic1911 ::

Pozdravljeni!

Za nalogo morem implementirat iskalno drevo ter njegove funkcije.

Težavo mi delajo naslednje metode:

- size
- postfix
- prefix

Stvar je v tem, da nevem kako naj zadevo sprogramiram.

POMEMBNO: spreminjam lahko samo funkcije, pri katerih piše //TODO: implementation

/*
Besedilo naloge:

1 Iskalno drevo števil

Iskalno drevo je drevesna podatkovna struktura, katere glavna prednost, v primerjavi s tabelo ali seznamom,
je v splošnem hitrejše iskanje nekega elementa.
Ob tem pa njegova notranja urejenost omogoča enostavno tvorbo urejenega zaporedja hranjenih elementov.
Vaša naloga je implementacija metod, ki omogočijo omenjeno funkcionalnost.

V predlogah je tokrat samo zametek podatkovne strukture, ki pa zadošča imeplemetaciji teh metod.
To pomeni, da skelet razreda, ki predstavlja podatkovno strukturo iskalno drevo števil, ne vsebuje vseh metod,
ki jih poznamo iz definicije. Posledično tudi ne ponuja popolne funkcionalnosti omenjene podatkovne strukture,
pač pa vsebuje samo izbrane vsebine, ki so potrebne za implementacijo rešitve naloge.

Predlogi vsebujeta razred, ki predstavlja zametek podatkovne strukture iskalno drevo,
kjer manjkajo implementacije nekaterih metod. Znotraj tega razreda se uporablja še drug (notranji, vgnezden) razred,
ki predstavlja posamezno vozlišče takšnega drevesa. Tudi v njem manjkajo implementacije nekaterih metod.

Vaša naloga je implementirati vse omenjene metode (tj. vse metode, ki v telesu nosijo komentar z začetkom „TODO”).
 */

//privzete vkljucitve
#include <iostream>
#include <queue>// vrsta
#include <limits>

//definicija imenskega prostora(/podrocja)
namespace vaja6
{
//uporabljeni imenski prostori
using namespace std;

//razredi

/*
 * Povzetek(/Summary):
 * Razred IskalnoDrevo
 * definira zametek podatkovne strukture IskalnoDrevo.
 * Razred smo okrnili za metode, ki jih za rešitev vaje ne
 * potrebujete.
 *
 * Skelet vsebuje ob privzetem konstruktorju, kopirnem
 * konstruktorju in destruktorju, še metode:
 * - osnovne funkcionalnosti
 *   - vstavi()
 * - razsirjene fukcionalnosti
 *   - empty()
 *   - size()
 * - dodatne fukcionalnosti
 *   - najvecjiElement()
 *   - najmanjsiElement()
 *   - narascajocaVrsta()
 *   - padajocaVrsta()
 *   - prefixQueue()
 *   - infixQueue()
 *   - postfixQueue()
 */
class IskalnoDrevo
{
	/*
	 * Povzetek(/Summary):
	 * Vgnezden razred Vozlisce
	 * definira zametek razreda Vozlisce, namenjenega interni
	 * rabi (tj. samo znotraj razreda IskalnoDrevo).
	 *
	 * Razred Vozlisce predstavlja tip, ki pomaga notranje
	 * urediti drevesno podatkovno strukturo.
	 *
	 * Skelet vsebuje ob konstruktorju, ki prejme podatek,
	 * kopirnem konstruktorju in destruktorju, še metode:
	 * - osnovne funkcionalnosti
	 *   - vstavi()
	 * - razsirjene funkcionalnosti
	 *   - size()
	 * - dodatne funkcionalnosti
	 *   - najvecji()
	 *   - najmanjsi()
	 *   - narascajocaVrsta()
	 *   - padajocaVrsta()
	 *   - prefixQueue()
	 *   - infixQueue()
	 *   - postfixQueue()
	 */
	class Vozlisce// gnezden razred
	{
    private:
        //lastnosti
		double podatek;
		Vozlisce* levo;
		Vozlisce* desno;

	public:	//vmesnik
		//konstruktorji

		/*
		 * Povzetek(/Summary):
		 * Konstuktor, ki prejme podatek, ki ga nato hrani
		 * ustvarjeno Vozlisce.
		 * Opombe(/Remarks):
		 * Leva in desna veja kažeta v prazno (NULL).
		 * Parametri(/Parameters):
		 *     ime(/name): podatek (double)
		 *     Podatek (decimalno stevilo), ki ga hrani vozliš&#232;e.
		 */
		Vozlisce(double podatek)
		: podatek(podatek), levo(NULL), desno(NULL)
		{

		}
		//kopirni konstruktor
		Vozlisce(const Vozlisce &original)
		: podatek(original.podatek), levo(NULL), desno(NULL)
		{
			if (original.levo!=NULL)
				levo=new Vozlisce(*(original.levo));
			if (original.desno!=NULL)
				desno=new Vozlisce(*(original.desno));
		}
		//destruktor
		virtual ~Vozlisce()
		{
			if (levo!=NULL)
				delete levo;
			if (desno!=NULL)
				delete desno;
		}

		/*
		 * Povzetek(/Summary):
		 * Metoda vstavi podan podatek v Vozlisce na naslednjem nivoju,
		 * ali na katerem od visjih nivojev v drevesu vozlisc.
		 * Opombe(/Remarks):
		 * Ce je ustrezna veja, kamor po pravilih dvojiskega (stopnja_drevesa==2)
		 * iskalnega drevesa spada podan podatek, že "polna", metoda "rekurzivno" klice
		 * vstavljanje podatka nad najvisjim vozliscem te veje drevesa.
		 * Parametri(/Parameters):
		 *     ime(/name): podatek (double)
		 *     Podatek (decimalno stevilo), ki se hrani v novo Vozlisce na naslednjem
		 *     nivoju ali na katerem od visjih nivojev v drevesu vozlisc.
		 */
		void vstavi(double podatek)
		{
			if(podatek<this->podatek)
            {
				if(levo==NULL)
					levo=new Vozlisce(podatek);
				else
					levo->vstavi(podatek);
			} else
                {
				if(desno==NULL)
					desno=new Vozlisce(podatek);
				else
					desno->vstavi(podatek);
                }
		}

		int size() const
		//TODO: implementation
		{

		}

		double najvecji() const
		//TODO: implementation
        {
		    if(desno == NULL)
            {
                return podatek;
            }
            else
            {
                Vozlisce *tmp = desno;
                double p;

                while(tmp != NULL)
                {
                    p = tmp->podatek;
                    tmp = tmp->desno;
                }
                return p;
            }
		}

		double najmanjsi() const
		//TODO: implementation
		{
            if(levo == NULL)
            {
                return podatek;
            }
            else
            {
                Vozlisce *tmp = levo;
                double p;

                while(tmp != NULL)
                {
                    p = tmp->podatek;
                    tmp = tmp->levo;
                }
                return p;
            }
		}

		void narascajocaVrsta(queue<double> &vrsta) const
		//TODO: implementation
		{
			if (levo!=NULL)
				levo->narascajocaVrsta(vrsta);
			vrsta.push(podatek);
			if (desno!=NULL)
				desno->narascajocaVrsta(vrsta);
        }

		void padajocaVrsta(queue<double> &vrsta) const
		//TODO: implementation
		{

			if (desno!=NULL)
				desno->padajocaVrsta(vrsta);
				vrsta.push(podatek);
			if (levo!=NULL)
				levo->padajocaVrsta(vrsta);
        }

		void prefixQueue(queue<double> &vrsta) const
		//TODO: implementation
		{
		    vrsta.push(podatek);
			if (levo!=NULL)
				levo->prefixQueue(vrsta);
			if (desno!=NULL)
				desno->prefixQueue(vrsta);
        }

		/*
		 * Povzetek(/Summary):
		 * Metoda, ki vrne (vse) hranjene elemente urejene po
		 * vrstnem redu, kot ga ustvari infiksni pregled
		 * dvojiskega (stopnja_drevesa==2) drevesa.
		 * Parametri(/Parameters):
		 *     ime(/name): vrsta (queue<double>&)
		 *     Po izvedbi metode: Vrsta hranjenih stevil v vrstnem redu, kot ga dobimo
		 *     po infiksnem prehodu dvojiskega (stopnja_drevesa==2) drevesa.
		 */

		void infixQueue(queue<double> &vrsta) const
		{
			if (levo!=NULL)
				levo->infixQueue(vrsta);
			vrsta.push(podatek);
			if (desno!=NULL)
				desno->infixQueue(vrsta);
		}

		void postfixQueue(queue<double> &vrsta) const
		//TODO: implementation
		{
			if (levo!=NULL)
				levo->postfixQueue(vrsta);
			if (desno!=NULL)
				desno->postfixQueue(vrsta);
				vrsta.push(podatek);
		}
	};
private:
	//lastnosti
	Vozlisce* koren;

public:	//vmesnik
	//konstruktorji

	//privzeti konstruktor
	IskalnoDrevo()
	: koren(NULL)
	{

	}
	//kopirni konstruktor
	IskalnoDrevo(const IskalnoDrevo& original)
	: koren(original.koren)
	{

	}
	//destruktor
	virtual ~IskalnoDrevo()
	{
		if (koren!=NULL)
			delete koren;
	}

	/*
	 * Povzetek(/Summary):
	 * Metoda vstavi podan podatek v koren oz.
	 * na katerega od visjih nivojev drevesa.
	 * Opombe(/Remarks):
	 * &#200;e drevo ni prazno, klice (rekurzivno) vstavljanje nad
	 * korenskim vozliscem.
	 * Parametri(/Parameters):
	 *     ime(/name): podatek (double)
	 *     Podatek (decimalno stevilo), ki se hrani v korensko
	 *     Vozlisce ali katerega od vozlisc na visjem nivoju v
	 *     drevesu.
	 */
	void vstavi(double podatek)
	{
		if (empty())
			koren=new Vozlisce(podatek);
		else
			koren->vstavi(podatek);
	}

	/*
	 * Povzetek(/Summary):
	 * Metoda javi ali je drevo prazno (vrne "true") ali ne
	 * (vrne "false").
	 * Opombe(/Remarks):
	 * Preveri samo ali je kazalec na korensko Vozlisce NULL ali
	 * ne.
	 * Vracilo(/Return): (bool)
	 * Vrne "true", ce drevo "nima korenskega vozlisca" oz.
	 * "false", ce ga ima.
	 */
	bool empty() const
	{
		return (koren==NULL);
	}

	/*
	 * Povzetek(/Summary):
	 * Presteje in vrne stevilo hranjenih elementov v iskalnem
	 * drevesu.
	 * Opombe(/Remarks):
	 * Kadar drevo ima korensko Vozlisce, se dejanski
	 * izracun(/stetje) stevila hranjenih elementov zgodi v
	 * metodi IskalnoDrevo::Vozlisce::size() zacensi nad
	 * korenskim vozliscem drevesa.
	 * Vracilo(/Return): (int)
	 * Stevilo hranjenih elementov(/vozlisc) v tem drevesu oz.
	 * 0, ce drevo nima korenskega vozlisca.
	 */
	int size() const
	{
		if (koren == NULL/*empty()*/)
			return 0;
		else
			return koren->size();
		return -1;	//dead code
	}

	//metode za dodatno funkcionalnost
	double najvecjiElement() const
	//TODO: implementation
	{
	    return koren -> najvecji();
	}

	double najmanjsiElement() const
	//TODO: implementation
	{
	    return koren -> najmanjsi();
	}


	/*
	 * Povzetek(/Summary):
	 * Metoda s pomo&#232;jo pregleda iskalnega drevesa vrne vrsto (vseh) hranjenih
	 * elementov po narascajocem vrstnem redu.
	 * Vracilo(/Return):
	 * Vrsta decimalnih števil (tipa queue<double>), urejenih naraš&#232;ajo&#232;e.
	 */
	queue<double> narascajocaVrsta() const
	{
		queue<double> narascajoca;
		if (koren!=NULL)
        {
            koren->narascajocaVrsta(narascajoca);
        }
        return narascajoca;
	}

	queue<double> padajocaVrsta() const
	//TODO: implementation
	{
		queue<double> padajoca;
		if (koren!=NULL)
        {
            koren->padajocaVrsta(padajoca);
        }
        return padajoca;
	}


	queue<double> prefixQueue() const
	//TODO: implementation
	{
		queue<double> prefix;
		if (koren!=NULL)
        {
            koren->prefixQueue(prefix);
        }
        return prefix;
	}

	queue<double> infixQueue() const
	//TODO: implementation
	{
		queue<double> narascajoca;
		if (koren!=NULL)
        {
            koren->infixQueue(narascajoca);
        }
        return narascajoca;
	}

	queue<double> postfixQueue() const
	//TODO: implementation
	{
		queue<double> postfix;
		if (koren!=NULL)
        {
            koren->postfixQueue(postfix);
        }
        return postfix;
	}

};

//proste metode v imenskem prostoru

}

using namespace vaja6;

//glavna metoda - globalna

/*
 * Povzetek(/Summary):
 * (*description*)
 * Opombe(/Remarks):
 * (*description*)
 * Parametri(/Parameters):
 *     ime(/name): argn (int)
 *     Stevilo argumentov programa - tj. dolzina polja args (2. parametra metode).
 *     ime(/name): args (char**)
 *     Argumenti programa (oz. argumenti podani v program ob zagonu) v obliki nizov,
 *     ki se prenesejo v main kot polje (C-jevskih) nizov (tj. polja polj znakov,
 *     zaradi cesar je tip parametra kazalec na polje (C-jevskih) nizov (tj.
 *     kazalec na polje polj znakov).
 * Vracilo(/Return): (int)
 * (*description*)
 */
int main(int argn, char** args)
{
    IskalnoDrevo a;

    a.vstavi(50);
    a.vstavi(40);
    a.vstavi(45);
    a.vstavi(32);
    a.vstavi(20);
    a.vstavi(35);
    a.vstavi(30);
    a.vstavi(38);
    a.vstavi(60);

    cout << "NAJVECJI ELEMENT: " << a.najvecjiElement() << endl;
    cout << "NAJMANJSI ELEMENT: " << a.najmanjsiElement() << endl;

    cout << "INFIX" << endl;
    queue<double> vrsta = a.infixQueue();

    while(vrsta.size() > 0)
    {
        cout << vrsta.front() << " ";
        vrsta.pop();
    }
    cout << endl;

    cout << "NARASCAJOCA" << endl;
    queue<double> vrsta2 = a.narascajocaVrsta();

    while(vrsta2.size() > 0)
    {
        cout << vrsta2.front() << " ";
        vrsta2.pop();
    }
    cout << endl;

    cout << "PADAJOCA" << endl;
    queue<double> vrsta3 = a.padajocaVrsta();

    while(vrsta3.size() > 0)
    {
        cout << vrsta3.front() << " ";
        vrsta3.pop();
    }
    cout << endl;

    cout << "PREFIX" << endl;
    queue<double> vrsta4 = a.prefixQueue();

    while(vrsta4.size() > 0)
    {
        cout << vrsta4.front() << " ";
        vrsta4.pop();
    }
    cout << endl;

    cout << "POSTFIX" << endl;
    queue<double> vrsta5 = a.postfixQueue();

    while(vrsta5.size() > 0)
    {
        cout << vrsta5.front() << " ";
        vrsta5.pop();
    }
    cout << endl;
}


Hvaležen bom kakršnekoli pomoči

LP

corwin68 ::

To imam jaz za size() (+ 1)
S fix-i zaenkrat tudi v temi.

int size() const {
  int s = 0;
  if (levo!=NULL)
  {
    s+=levo->size();
  }
  if (desno!=NULL)
  {
    s+=desno->size();
  }
  return s;
}

mallard ::

Kopirni konstruktor drevesa je mal... pomanjkljiv (dela shallow copy, kopira samo pointer, medtem ko destruktor sprošča pomnilnik prek tega pointerja brez obzira na to, al je že kje drugje bil sproščen).

Preverjanje v destruktorju (če pointer ni NULL), je brezpredmetno. delete NULL je no-op.

corwin68 ::

Binary expression tree @ Wikipedia

Mislim, da je point *fix-ov samo kje izpišeš vozlišče - pred,po,med. (???)

roba87 ::

s (velikost) postavi na začetno vrednost 1, ker ti vrača 0 v primeru, da je koren == NULL. Torej, če koren != NULL imaš vsaj 1 vozlišče.

Zgodovina sprememb…

  • spremenil: roba87 ()

eXoo ::

A se je že kdo mogoče lotil 7 naloge ?

#include <iostream>
#include <queue>
#include <list>
#include <map>

//definicija imenskega prostora(/podrocja)
namespace vaja7 {
//uporabljeni imenski prostori
using namespace std;

//nastevni tipi
/*
 * Povzetek(/Summary):
 * Oznacuje ali je sedez v prostoru spredaj ali v prostoru zadaj.
 */
enum Sedez {
	spredaj, zadaj
};

//strukture
/*
 * Povzetek(/Summary):
 * (*description*)
 */
struct LetalskaKarta {
private:
	string destinacija;
	double cena;
	string letalska_druzba;
	Sedez sedec;
public:
	/// <summary>
	/// Konstruktor strukture LetalskaKarta
	/// </summary>
	LetalskaKarta(const string &destinacija, const double &cena,
			const string &letalska_druzba, const Sedez &sedez) :
			destinacija(destinacija), cena(cena), letalska_druzba(
					letalska_druzba), sedec(sedez) {
	}

	/// <summary>
	/// Lastnosti strukture LetalskaKarta
	/// </summary>
	string get_Destinacija() const {
		return destinacija;
	}

	void set_Destinacija(const string& value) {
		destinacija = value;
	}

	double get_Cena() const {
		return cena;
	}

	void set_Cena(const double &value) {
		cena = value;
	}

	string get_LetalskaDruzba() const {
		return letalska_druzba;
	}

	void set_LetalskaDruzba(const string &value) {
		letalska_druzba = value;
	}

	Sedez get_Sedec() const {
		return sedec;
	}
	void set_Sedec(const Sedez &value) {
		sedec = value;
	}
};

bool operator==(const LetalskaKarta &leva, const LetalskaKarta &desna) {
	if (&leva == &desna)
		return true;
	if (leva.get_Cena() == desna.get_Cena()
			&& leva.get_Sedec() == desna.get_Sedec()
			&& leva.get_Destinacija() == desna.get_Destinacija()
			&& leva.get_LetalskaDruzba() == desna.get_LetalskaDruzba())
		return true;
	return false;
}

struct Potnik {
private:
	// lastnosti
	string ime;
	string priimek;
	int starost;
	string davcna;
	LetalskaKarta letalskaKarta;
public:
	/// <summary>
	/// Konstruktor strukture Potnik
	/// </summary>
	Potnik(const string &ime, const string &priimek, const int &starost,
			const string &davcna) :
			ime(ime), priimek(priimek), starost(starost), davcna(davcna), letalskaKarta(
					"", 0.0, "", spredaj) {
	}

	/// <summary>
	/// Lastnosti strukture Potnik
	/// </summary>
	string get_Ime() const {
		return ime;
	}
	void set_Ime(const string &value) {
		ime = value;
	}

	string get_Priimek() const {
		return priimek;
	}
	void set_Priimek(const string &value) {
		priimek = value;
	}

	int get_Starost() const {
		return starost;
	}
	void set_Starost(const int &value) {
		starost = value;
	}

	string get_Davcna() const {
		return davcna;
	}
	void set_Davcna(const string &value) {
		davcna = value;
	}

	LetalskaKarta get_LetalskaKarta() const {
		return letalskaKarta;
	}
	void set_LetalskaKarta(const LetalskaKarta &value) {
		letalskaKarta = value;
	}
};

bool operator==(const Potnik &levi, const Potnik &desni) {
	if (&levi == &desni)
		return true;
	if (levi.get_Davcna() == desni.get_Davcna()
			/*&& levi.get_Starost() == desni.get_Starost()
			&& levi.get_Priimek() == desni.get_Priimek()
			&& levi.get_Ime() == desni.get_Ime()
			&& levi.get_LetalskaKarta() == desni.get_LetalskaKarta()*/)
		return true;
	return false;
}

//razredi
class Letalo {
private:
	string letalskaDruzba;
	string naziv;
	string destinacija;
public:
	//potniki, ki cakajo na vkrcanje
	queue<Potnik> vrstaPotnikov;
	//potniki, ki so ze vkrcani na letalo
	list<Potnik> vkrcaniPotniki;

	/// <summary>
	/// Konstruktor razreda Letalo
	/// </summary>
	/// <param name="letalskaDruzba"></param>
	/// <param name="naziv"></param>
	Letalo(const string &letalskaDruzba = "", const string &naziv = "") :
			letalskaDruzba(letalskaDruzba), naziv(naziv), destinacija("") {
	}

	/// <summary>
	/// Lastnosti strukture LetalskaDruzba
	/// </summary>
	string get_LetalskaDruzba() const {
		return letalskaDruzba;
	}
	void set_LetalskaDruzba(const string &value) {
		letalskaDruzba = value;
	}

	string get_Naziv() const {
		return naziv;
	}
	void set_Naziv(const string &value) {
		naziv = value;
	}

	string get_Destinacija() const {
		return destinacija;
	}
	void set_Destinacija(const string &value) {
		destinacija = value;
	}

	/// <summary>
	/// </summary>
	/// <param name="pt"></param>
	/// <returns></returns>
	bool vrstaPotnikovDodajanje(const Potnik &pt) {
		//TODO: implementation
		//HINT: destinacija

		return false;
	}

	/// <summary>
	/// </summary>
	/// <param name="pt"></param>
	void vrstaPotnikovOdstranjevanje(const Potnik &pt) {
		//TODO: implementation
		//HINT: davcna
	}

	/// <summary>
	/// </summary>
	void vkrcajPotnike() {
		//Opomba: vkljucena metoda Uredi() ni pogoj za priznano vajo 7; prav tako se urejenosti potnikov ne bo testiralo
		//vrstaPotnikov = Uredi(vrstaPotnikov); // namenjeno izključno vasi lastni vadbi (Vaja4)

		//TODO: implementation

	}

	/// <summary>
	/// </summary>
	/// <param name="pt"></param>
	void izkrcajPotnika(const Potnik &pt) {
		//TODO: implementation
	}

	/// <summary>
	/// </summary>
	void izkrcajPotnike() {
		//TODO: implementation
	}
};

class Letalisce {
public:
	//destinacija, cena
	map<string, double> cenik;
	//destinacija, letalo
	map<string, Letalo> letala;

	/// <summary>
	/// Konstruktor razreda Letalisce
	/// </summary>
	Letalisce() {
	}

	/// <summary>
	/// </summary>
	/// <param name="destinacija"></param>
	/// <param name="cena"></param>
	/// <returns></returns>
	bool dodajVCenik(string destinacija, double cena) {
		//TODO: implementation
		//HINT: destinacija s ceno 0.0 ali manj ne obstaja

		return false;
	}

	/// <summary>
	/// </summary>
	/// <param name="destinacija"></param>
	/// <param name="letalo"></param>
	/// <returns></returns>
	bool dodajVLetala(const string &destinacija, Letalo &letalo) {
		//TODO: implementation
		//HINT: letalo ne more leteti na destinacijo, ki ni vpisana v cenik

		return false;
	}

	/// <summary>
	/// </summary>
	/// <param name="pt"></param>
	/// <param name="destinacija"></param>
	/// <param name="s"></param>
	/// <returns></returns>
	bool nakupKarte(Potnik &pt, const string &destinacija, const Sedez &s) {
		//TODO: implementation
		//HINT: nakup karte ni mozen brez vpisa v oba slovarja

		return false;
	}

};

}

using namespace vaja7;

//glavna metoda - globalna
/*
 * Povzetek(/Summary):
 * (*description*)
 * Opombe(/Remarks):
 * (*description*)
 * Parametri(/Parameters):
 *     ime(/name): argn (int)
 *     Stevilo argumentov programa - tj. dolzina polja args (2. parametra metode).
 *     ime(/name): args (char**)
 *     Argumenti programa (oz. argumenti podani v program ob zagonu) v obliki nizov,
 *     ki se prenesejo v main kot polje (C-jevskih) nizov (tj. polja polj znakov,
 *     zaradi cesar je tip parametra kazalec na polje (C-jevskih) nizov (tj.
 *     kazalec na polje polj znakov).
 * Vracilo(/Return): (int)
 * (*description*)
 */
int main(int argn, char** args) {
	//preprosto testiranje

	Potnik pt("Janez", "Kranjski", 25, "12345678");
	Potnik pt2("Tomislav", "Vizinski", 23, "87654321");
	Potnik pt3("Marija", "Okrep", 24, "45278964");
	//Letalo lt(1, "Air France", "Boeing st.1");
	//Letalo lt2(2, "Air India", "Boeing st.2");
	Letalo lt("Air France", "Boeing st.1");
	Letalo lt2("Air India", "Boeing st.2");
	Letalisce let;

	let.dodajVCenik("Benetke", 120);
	if (let.dodajVCenik("Benetke", 120) == true)
		cout << "Dodajanje v slovar cenik ne deluje pravilno!" << endl;
	;
	let.dodajVCenik("Rim", 500);

	if (let.cenik.size() == 3)
		cout << "Dodajanje v slovar cenik ne deluje pravilno!" << endl;

	let.dodajVLetala("Benetke", lt);
	let.dodajVLetala("Rim", lt2);
	if (let.dodajVLetala("Rim", lt2) == true)
		cout << "Dodajanje v slovar letala ne deluje pravilno!" << endl;

	if (let.letala.size() == 3)
		cout << "Dodajanje v slovar letala ne deluje pravilno!" << endl;

	let.nakupKarte(pt, "Benetke", zadaj);
	let.nakupKarte(pt2, "Benetke", spredaj);

	lt.vrstaPotnikovDodajanje(pt);
	lt.vrstaPotnikovDodajanje(pt2);
	lt.vrstaPotnikovDodajanje(pt3);
	// potnik brez karte
	if (lt.vrstaPotnikov.size() != 2)
		cout << "Dodajanje potnikov v vrsto ne deluje pravilno!" << endl;
	lt.vkrcajPotnike();
	if (lt.vkrcaniPotniki.size() != 2)
		cout << "Vkrcavanje potnikov ne deluje pravilno!" << endl;
	lt.izkrcajPotnika(pt);
	if (lt.vkrcaniPotniki.size() != 1)
		cout << "Izkrcavanje enega potnika ne deluje pravilno!" << endl;
	lt.izkrcajPotnike();
	if (lt.vkrcaniPotniki.size() != 0)
		cout << "Izkrcavanje potnikov ne deluje pravilno!" << endl;

	//Potnik brez veljavne vozovnice.
	Potnik pt4("Ana", "Lenkova", 19, "47259685");
	Letalo lt3("Air USA", "Concord");
	let.dodajVLetala("Miami", lt3);
	let.nakupKarte(pt4, "Florida", spredaj);
	lt3.vrstaPotnikovDodajanje(pt4);
	if (lt3.vrstaPotnikov.size() == 1)
		cout << "Napaka: Potnik brez veljavne vozovnice je uspesno prisel v vrsto za vkrcanje!"
				<< endl;

	//napacna destinacija na karti
	let.dodajVCenik("Miami", 150);
	let.dodajVLetala("Miami", lt3);
	let.dodajVCenik("Florida", 150);
	let.dodajVLetala("Florida", lt2);
	let.nakupKarte(pt4, "Florida", spredaj);
	lt3.vrstaPotnikovDodajanje(pt4);
	if (lt3.vrstaPotnikov.size() == 1)
		cout << "Napaka: Letalo leti v Miami, potnik pa ima kupljeno karto za Florido!"
				<< endl;


	return 0;
}

//na koncu prazna vrstica



Vredno ogleda ...

TemaSporočilaOglediZadnje sporočilo
TemaSporočilaOglediZadnje sporočilo
»

[C#] Iskalno Drevo

Oddelek: Programiranje
131633 (1199) Ciklamen
»

Predstavitev dvojiškega drevesa z seznamom

Oddelek: Programiranje
141516 (1116) ktka
»

Za programerske teoretike

Oddelek: Programiranje
477913 (4715) Jerry000
»

pomoc pri skladu

Oddelek: Programiranje
51114 (1039) NoUse4AName
»

C++ kopirni konstruktor

Oddelek: Programiranje
103056 (2787) noraguta

Več podobnih tem