/*

Vytvotře třídy pro práci s lineárním obousměrným zřetězeným

cyklickým seznamem s hlavou.

Vytvořte implementaci tohoto seznamu pro seznam řetězců znaků.

*/

Stdafx.h

#pragma once

#include <iostream>

using namespace std;

#pragma warning(disable:4996)

Stdafx.cpp

// stdafx.cpp : source file that includes just the standard includes

// Program05.pch will be the pre-compiled header

// stdafx.obj will contain the pre-compiled type information

#include "stdafx.h"

// TODO: reference any additional headers you need in STDAFX.H

// and not in this file

Objekt.h

#pragma once

class Objekt {

public:

     virtual ~Objekt() { }

     virtual void Vypis()const = 0;

     virtual  Objekt* DejKopii()const=0; 

};

Objekt.cpp

#include "stdafx.h"

#include "Objekt.h"

Prvek.h

#pragma once

#include "Objekt.h"

class Prvek {

     friend class Seznam;

     Prvek *Naslednik;

     Prvek *Predchudce;

     Objekt *Data;

public:

     Prvek(Objekt *data=0);

     ~Prvek() { delete Data;}

};

Prvek.cpp

#include "stdafx.h"

#include "Prvek.h"

Prvek::Prvek(Objekt *data)

:Data(data),Naslednik(0),Predchudce(0){ }

Řetězec.h

#pragma once

#include "Objekt.h"

class Retezec : public Objekt{

     char* s;

     int n;

     void Kopie(const Retezec& t);

public:

     Retezec(const char* _s);

     Retezec(){s=0;n=0;}

     Retezec(const Retezec& t){Kopie(t);}

     ~Retezec() { delete[] s; }

     void Vypis()const{ cout << (n==0?"":s) << '\n';}

     void Nacti(char konc_znak);

     void Vymaz();

     bool JePrazdny()const{return n==0;}

     Retezec& operator=(const Retezec& t);

     virtual  Objekt* DejKopii()const {return new Retezec(*this); }

};

Řetězec.cpp

#include "Stdafx.h"

#include "Retezec.h"

Retezec::Retezec(const char* _s)

{

     n=static_cast<int>(strlen(_s));

     s=new char[n+1];

     strcpy(s,_s);

}

void Retezec::Nacti(char konc_znak){

     char str[256];

     Vymaz();

     do

     {

         if (fgets(str,sizeof str,stdin)==0)return;

     }

     while(str[0]=='\n');

     n=static_cast<int>(strlen(str));

     if (n==2 && str[0]==konc_znak)

     {   

         n=0;

         return;

     }

     s=new char[n];

     str[n-1]=0;

     strcpy(s,str);

}

void Retezec::Vymaz(){

     delete[] s;

     s=0;

     n=0;

}

Retezec& Retezec::operator =(const Retezec &t){

     if(this != &t){

         Vymaz();

         Kopie(t);

     }

     return *this;

}

void Retezec::Kopie(const Retezec &t){

     n=t.n;

     if(n>0){

         s=new char[n+1];

         strcpy(s,t.s);

     }

}

Seznam.h

#pragma once

#include "Prvek.h"

class Seznam{

     Prvek *Hlava;

     int Pocet;

private:

     void Kopie(const Seznam &t);

     void Init();

public:

     Seznam(){Init();}

     Seznam(const Seznam& t);

     virtual~Seznam();

     void Vymaz(Prvek* prvek);

     void Vymaz();

     void Vloz(Objekt* Data,Prvek* Pozice);

     void VlozNaZacatek(Objekt* Data){Vloz(Data,Hlava->Naslednik);}

     void VlozNaKonec(Objekt* Data){Vloz(Data,Hlava);}

     void Vypis() const;

     Seznam& operator= (const Seznam& t);

};

Seznam.cpp

#include "stdafx.h"

#include "Seznam.h"

void Seznam::Init(){

     Pocet=0;

     Hlava=new Prvek;

     Hlava->Naslednik=Hlava;

     Hlava->Predchudce=Hlava;

}

Seznam::~Seznam(){

     Vymaz();

     delete Hlava;

}

void Seznam::Vymaz(Prvek* prvek){

     if (prvek!=Hlava){

         prvek->Predchudce->Naslednik=prvek->Naslednik;

         prvek->Naslednik->Predchudce=prvek->Predchudce;

         delete prvek;

         Pocet--;

     }

}

void Seznam::Vymaz(){

     while(Hlava->Naslednik!=Hlava){

         Vymaz(Hlava->Naslednik);

     }   

}

void Seznam::Vloz(Objekt* Data,Prvek* Pozice)

{

     Prvek* novy=new Prvek(Data);

     novy->Naslednik=Pozice;

     novy->Predchudce=Pozice->Predchudce;

     Pozice->Predchudce->Naslednik=novy;

     Pozice->Predchudce=novy;

     Pocet++;

}

void Seznam::Vypis() const

{

     Prvek* pom;

     pom=Hlava->Naslednik;

     while (pom!=Hlava)

     {

         pom->Data->Vypis();

         pom=pom->Naslednik;

     }

}

void Seznam::Kopie(const Seznam &t)

{

     Prvek* pom;

     pom=t.Hlava->Naslednik;

     while (pom!=t.Hlava)

     {

         VlozNaKonec(pom->Data->DejKopii());

         pom=pom->Naslednik;

     }

}

Seznam::Seznam(const Seznam& t){

     Init();

     Kopie(t);

}

Seznam& Seznam::operator= (const Seznam& t)

{

     if (&t!=this)

     {   

         Vymaz();

         Kopie(t);

     }

     return *this;

}

Main…

#include "stdafx.h"

#include "Seznam.h"

#include "Retezec.h"

void NactiSeznam(Seznam &seznam)

{   

     Retezec retezec;

     int poc;

     const char konc_znak = ';';

     poc = 0;

     seznam.Vymaz();

     do{

         poc++;

         cout <<"Zadej "<< poc << ". retezec(pro konec - "<<konc_znak

              <<" ): ";

         retezec.Nacti(konc_znak);

         if (retezec.JePrazdny())return;

         seznam.VlozNaKonec(new Retezec(retezec));

     }while(true);

}

int main()

{

     char volba;

     Seznam seznam;

     do{

         cout<<"MENU:\n";

         cout<<"1. Nacteni seznamu\n";

         cout<<"2. Vypis seznamu\n";

         cout<<"3. Vypis kopie seznamu\n";

         cout<<"0. Konec\n";

         cout<<"Volba: ";

         cin>>volba;

         switch(volba){

              case '1':

                   NactiSeznam(seznam);

                   break;

              case '2':

                   seznam.Vypis();

                   break;

              case '3':

                   //Seznam Kopie(seznam);

                   Seznam Kopie;

                   Kopie = seznam;

                   Kopie.Vypis();

                   break;

         }

     }while (volba!='0');

     return 0;

}