Problem z c++

[ilear 0]

Ehh...mam gruby problem - zawislem...

mam program wyjsciowy - klasa Figury i dziedziczace ja klasy Kwadrat, Trojkat ...

w ktorych moge sobie wyliczac pole, obwod itp.

I teraz mam zrobic cos ala to:

 

Należy zaimplementować dynamiczną strukturę danych - łańcuch odsyłaczowy dwukierunkowy - w którym będą przechowywane figury.

Zaimplementować klasę Zbiór Figur - która w sobie zawiera figury powiązane za pomocą łańcucha odsyłaczowego. Powinna ona posiadać metody dodaj, usuń, znajdź figurę.

Przeciążając operator [ ] umożliwić dostęp do poszczególnych figur w taki sposób jakby to była zwykła tablica. Bład odwołania poza tablicę zabezpieczyć za pomocą mechanizmu wyjątków.

Używając strumieni należy umożliwić zapis oraz odczyt całej struktury Zbiór Figur do/z pliku tekstowego.

Zaimplementować krótki programik przykładowy który tworzy klasę

Zbiór Figur, oraz wykonuje na niej podstawowe operacje.

 

moze mi ktos pomoc?

[MFW 0]

Rozbawiłeś mnie troche

Normalnie może bym i napisal ale Stary tego jest w Kosmos i jeszcze troche...

Lepiej powiedz na czym zawisłeś wtedy bedzie łatwiej bo jakoś nie widze abyś znalazł kogoś kto ci napisze tak z palca program na 200+ lini kodu.

[ilear 0]

struct lancuch

{

char typ,kolejka;

float pozycja,nast,poprz;

lancuch *wsk,*tmp;

lancuch()

{

strcpy(typ,"");

strcpy(kolejka,"");

pozycja=nast=poprz=0;

}

dodaj(char *str)

{

double x;

if (pozycja=0)

{

str.pozycja=1.1;

str.nast=-1;

str.poprz=1.1;

*wsk=&str;

strcat(kolejka,*str);

}

else

{

tmp=wsk;

while (strcmp(tmp->typ, *str.typ)!= 0 || tmp==null)

{

*tmp=strspn(kolejka,tmp->typ); // ???? chyba trzeba jeszcze jedna zmienna pomocnicza...

x=tmp->pozycja;

}

if (tmp==null)

{

strcat(kolejka,*str);

tmp->pozycja=x

break;

}

else

{

str.pozycja=tmp->pozycja+0.1;

str.poprz=tmp->pozycja;

str.nast=-1;

tmp->nast=str.pozycja;

strcat(kolejka,*str);

}

}

}

};

 

nabazgralem cos takiego

 

mam napisane klasy figura i te mniejsze,

jak zrobic to?

Zaimplementować klasę Zbiór Figur - która w sobie zawiera figury powiązane za pomocą łańcucha odsyłaczowego. Powinna ona posiadać metody dodaj, usuń, znajdź figurę.

Przeciążając operator [ ] umożliwić dostęp do poszczególnych figur w taki sposób jakby to była zwykła tablica. Bład odwołania poza tablicę zabezpieczyć za pomocą mechanizmu wyjątków.

 

w skrucie choc napisz jak mozesz:)

co pokolei zrobic, kod sam dopisze

p.s.

jak ci sie chce gg-4178690...bo niewiem czy wyrobie sie do jutra z tym bez pomocy:)

[ilear 0]

bleee..bez sensu to jest:P

 

jak mozesz to mi powiedz tak:

 

co mam dac w strukturze a co w definicji tej klasy Zbior Figur?

czy definiowac dodaj usun znajdz w klasie czy w strukturze lancuchowej?

i co to kruca jest ten lancuch odnosnikow dwukierunkowy...zebym chociaz to wiedzial

to z klasa sobie moze poradze...

bo to co nabazgralem sie kupy nie trzyma:P

[januzi 24]

biblioteka standardowa, klasa list

#include

 

masz dostep do listy poprzez begin i rbegin, end oraz rend (r od reverse), iterator, iterator staly, wrzucanie push_back oraz pop_back, lista chodzi jako szablon wiec mozesz na nia wrzucic dowolny obiekt, a potem po przejechaniu po liscie odwolywac sie wskaznikiem na niego

[januzi 24]

ale jakby co to moge podeslac tez liste dwukierunkowa, przeciazenie << i pare innych rzeczy, moze sie przydadza

[ilear 0]

Januzi, nie moge tego na liscie zrobic, tylko musze na łancuchu odsyłaczowym dwukierunkowym:/ mam zaimplementowac dynamiczna strukture danych sam, nie korzystajac z bibl. standard....

 

mam cos takiego

 

struct lancuch

{

char kolejka;

char typ;

lancuch *wsk, *nast, *poprz;

lancuch()

{

strcpy(typ,"");

strcpy(kolejka,"");

*wsk=*nast=*poprz=null;

}

 

tylko niewiem czy to wszystko w strukturze , czy mam cos jeszcze dodac, w jakim to ma byc pliku i wogole

potem chyba musze zrobic klase

ZbiorFigur zaprzyjazniona z klasa Figur (ktora dziedzicza klasy Kwadrat, Kolo, Trojkat itp)

i teraz musze w klasie ZbiorFigur dac metody dodajl, usun, znajdz - figure, operujac na tej strukturze...

rzeybm choc wiedzial jak to ma ogolnie wygladac, co gdzie wsadzic, do jakich plikow co z czym polaczyc:)

[ilear 0]

Figury.cpp

--------------

#include "Figury.h"

double pole(Figura &figura)

{

cout << figura.pole();

return figura.pole();

}

///////////////////////////////////////////////////

 

double Kwadrat::pole()

{

return bok*bok;

}

double Kwadrat::obwod()

{

return bok*4;

}

double Kwadrat::ZwrocBok()

{

return bok;

}

///////////////////////////////////////////////////

 

double Trojkat::pole()

{

p=0.5*(boka+bokb+bokc);

return sqrt(p*(p-boka)*(p-bokb)*(p-bokc));

}

double Trojkat::obwod()

{

return boka+bokb+bokc;

}

///////////////////////////////////////////////////

 

double Kolo::pole()

{

return promien*promien*3.14;

}

double Kolo::obwod()

{

return promien*2*3.14;

}

double ZwrocPromien()

{

return promien;

}

///////////////////////////////////////////////////

 

double Prostokat::pole()

{

return boka*bokb;

}

double Prostokat::obwod()

{

return 2*boka+2*bokb;

}

double ZwrocBok()

{

return boka;

}

 

///////////////////////////////////////////////////

 

Figury.h

------------------

 

#include

#ifndef FIGURAHEADER

#define FIGURAHEADER

 

//////////////////////////////////////////////////////////////

 

class Figura

{

public:

Figura()

{

strcpy(nazwa,"");

wierzcholki=0;

}

Figura(char* wnazwa, int wwierzcholki)

{

strcpy(nazwa, wnazwa);

wierzcholki=wwierzcholki;

}

 

virtual double pole() = 0;

virtual double obwod() = 0;

char* ZwrocNazwe()

{

return nazwa;

}

protected:

char nazwa[10];

int wierzcholki;

//////////////////////////////////////////////////////////////

 

class Kwadrat : public Figura

{

public:

Kwadrat() : Figura()

{

bok=0;

}

Kwadrat(double wbok) : Figura("Kwadrat",4)

{

bok=wbok;

}

 

 

double pole();

double obwod();

double ZwrocBok();

private:

double bok;

};

 

//////////////////////////////////////////////////////////////

class Prostokat : public Figura

{

public:

Prostokat() : Figura()

{

boka=0;

bokb=0;

}

Prostokat(double wboka, double wbok) : Figura("Prostokat",4)

{

boka=wboka;

bokb=wbokb;

}

 

 

double pole();

double obwod();

double ZwrocBok();

private:

double boka, bokb;

 

};

 

//////////////////////////////////////////////////////////////

class Trojkat : public Figura

{

public:

Trojkat() : Figura()

{

boka=0;

bokb=0;

bokc=0;

}

Trojkat(double wboka, double wbokb, double wbokc) : Figura("Trojkat",3)

{

if (()||()||())

boka=wboka;

bokb=wbokb;

bokc=wbokc;

}

 

double pole();

double obwod();

private:

double boka, bokb, bokc,p;

 

 

};

 

 

//////////////////////////////////////////////////////////////

class Kolo : public Figura

{

public:

Kolo() : Figura()

{

promien=0;

}

Kolo(double wpromien) : Figura("Kolo",0)

{

promien=wpromien;

}

 

 

double pole();

double obwod();

double ZwrocPromien();

private:

double promien;

};

 

////////////////////////////////////////////////////////////// to nizej sam dodalem, w orginale nie bylo

 

double pole(Figura &figura)

{

cout << figura.pole();

return figura.pole();

}

#endif

 

Runfigury.cpp

--------

#include "Figury.h"

#include

 

void main()

{

Kwadrat* k=new Kwadrat(10);

printf("%f",k->pole());

}

 

 

i tyle bylo podstaw...

a koles chcial by z tego zrobic:

Punktem wyjścia jest aktualny program opisujący figury geometryczne oraz pozwalający na obliczenie ich pól i obwodów.

Należy zaimplementować dynamiczną strukturę danych - łańcuch odsyłaczowy dwukierunkowy - w którym będą przechowywane figury.

Zaimplementować klasę Zbiór Figur - która w sobie zawiera figury powiązane za pomocą łańcucha odsyłaczowego. Powinna ona posiadać metody dodaj, usuń, znajdź figurę.

Przeciążając operator [ ] umożliwić dostęp do poszczególnych figur w taki sposób jakby to była zwykła tablica. Bład odwołania poza tablicę zabezpieczyć za pomocą mechanizmu wyjątków.

Używając strumieni należy umożliwić zapis oraz odczyt całej struktury Zbiór Figur do/z pliku tekstowego.

Zaimplementować krótki programik przykładowy który tworzy klasę

Zbiór Figur, oraz wykonuje na niej podstawowe operacje.

 

 

 

tak wyglada calosc, moze teraz bedziesz mial lepszy przeglad

bo ja juz sie kruca gubie, niewiem jak to powiazac i poustawiac i kompletnie nie wiem co z tym łancuchem odsyłaczowym dwukierunkowym (bo to chyba o char chodzi i stringi...)

 

p.s.

wklejaj co masz, wszystko lepsze niz nic:)

[ilear 0]

normalnie mam dylemat...czy ten łancuch odsyłaczowy dwukierunkowy....to faktycznie moze mu chodzic o liste???

[januzi 24]

W morde, jak cos trzeba, to tego nie ma pod reka. Mam to gdzies wydrukowane, ale chyba zostalo we Wrocku. Jesli znajde tutaj, to zeskanuje i podesle na serwer.

http://rab.ict.pwr.wroc.pl/~kreczmer/po/ Tutaj jest sporo materialow. A przeciazenie pobierania musisz oprzec na :

 

ostream &operator<<(ostream &ost, operacja &arg) // pokazywanie parametru

{

ost << "(" << arg.typ() << "," << arg.we() << "," << arg.wy() << "," <<

arg.start() << "," << arg.stop() << ")" ;

return ost ;

}

 

Bedzie podobnie, tylko trzeba zmienic na >> i cos jeszcze zrobic, ale juz nie pamietam co

[ilear 0]

Hmm ok , ale jeszcze prosbulka

...

jestem zielony z c++:>

szczerze, to siadlem do nauki wczoraj o 2 w nocy i nadrabiam caly semestr...ale kumam o co biega. Tylko nie mam jeszcze tego pojecia wbudowanego w mozdzek, jak to ma w calosci wygladac...bylbys w stanie to jakos punktami ujac?

co w jakim pliku itp

mam klasy Figura, dziedziczace ja Kwadrat, Kolo, Trojkat itp, teraz musze zrobic str.danych i do tego na koniec ta najwazniejsza klase ZbiorFigur...moglbys mi sam szkielet nakreslic co z czym gdzie i co wykorzystuje? chocby same te trzy metody

dodaj , usun, znajdz, jakich arg maja uzywac...juz bedzie lepiej:)

[ilear 0]

ale sie wkur...lem...bosz...faktycznie chodzi o pieprz..liste!!

a nie o strukture stringowa kurw...tyle godzin na marne:/

o 12 mam zaliczenie a jest 3:((((

tragedia

niewyrobie sie chyba, ale dzieki tej stronce co mi rzuciles mam wieksze pojecie o tym

[januzi 24]

problemem jest to, ze to sa 4 rozne klasy do wrzucenia na jedna liste. trzeba by zrobic jedna klase wspolna, nastepnie przy pomocy konstruktora kopiujacego wrzucac na liste dwukierunkowa kopie obiektu wspolnego. przeciazenie [] : oznaczasz poczatek na 0 i lecisz po liscie zwiekszajac ta zmienna++, jesli jest == to zwracasz wskaznik do obiektu.

 

ten zbior figur moze byc

class figury

{

private:

kwadrat _kw ;

prostokat _pr ;

kolo _ko ;

trojkat _tr ;

public:

// cala ta reszta bajerow

} ;

 

ZbiorFigur lista_figur ; // cos w tym stylu, musisz zdefiniowac ta liste zeby byl dany typ

[januzi 24]

ok, mam, znalazlem kolejke dwukierunkowa, wrzucam na serwer

http://jscripts.scrypty.com/materialy5.pdf

http://jscripts.scrypty.com/materialy6.pdf

http://jscripts.scrypty.com/materialy7.pdf

http://jscripts.scrypty.com/materialy8.pdf

[ilear 0]

O widzisz, zajebiscie tego mi brakowalo, teraz mam choc to w wyobrazni:DDDD

 

Dobra, z klasa sobie poradze, tylko....jak to na liste wrzucic?

jakiej tam zaleznosci musze uzyc zeby pole listy odnosilo sie do danej figury?

[januzi 24]

7 albo 8 to kolejka niejednorodna. Mozna wrzucac dowolny typ. Ale radzilbym stworzyc klase wspolna dla wszystkich, ktora bedzie zawierala w sobie wszystkie pozostale klasy. I wtedy wrzucasz to jako obiekt ktory ma jakas figure w sobie. Jesli figura ma ilosc bokow != 0 to pokazujesz odpowiednie dane. Trzeba by tylko przypilnowac, zeby nie bylo dwoch figur w jednym obiekcie zdefiniowanych.

[ilear 0]

Kurde...temu studiuje informatyke, ze mozna spotkac takich ludzi:) nawet nie wiesz jak mi pomagasz stary:)

Juz prawie wsio jest z tego wynika

Zrobie ta klase zbiorfigor z private - kazda figura, kolejeczki mi dales, tylko pozostaje to cholerstwo z metodami dodaj usun znajdz, dalbys jeszcze rade jakos to mi nakreslic?

[januzi 24]

w klasie zbiorczej zdefiniuj pole string typ, wpisuj do niego jaka jest to figura

dodaj - wrzucanie na liste, jako parametry string typ oraz figura (bez szablonu beda z tego 3 funkcje)

usun - prostsze, na wejsciu wskaznik na obiekt do usuniecia, na ktorej z folii bylo usuwanie, poprzedni->nastepny = nastepny ; nastepny->poprzedni = poprzedni ; a obiekt znajdujacy sie posrodku delete

szukanie - przegladanie listy w poszukiwaniu typ == nazwa_figura; ew. z parametrami ale to juz hardcore totalny

[ilear 0]

Oka, dzieki za wsio, zabieram sie za skladanie...dobrze ze szybko na kibordzie pisze:P

Thx, masz u mnie wirtualne pifko

[ilear 0]

#include

#include

#include

#include

 

 

double pole(Figura &figura)

{

cout << figura.pole(); //////// CZY TO TU MA BYC?

return figura.pole();

}

//////////////////////////////////////////////////////////////

//------------------Definicje Klas---------------------

///////////////////////////////////////////////////////////////

 

 

/// KLASA ABSTRAKCYJNA ///

class Figura

{

friend ZbiorFigur;

public:

Figura(); // Konstruktor bezparametrowy

Figura(char* wnazwa, int wwierzcholki); // Konstruktor z parametrem typu charakter oraz calkowitym

 

virtual double pole() = 0; // obliczanie pola - metoda wirtualna

virtual double obwod() = 0; // obliczanie obwodu - metoda wirtualna

char* ZwrocNazwe() // metoda zwracajaca nazwe figury

 

protected:

char nazwa[10]; // nazwa figury

int wierzcholki; // liczba wierzcholkow

 

/// KLASA KWADRAT ///

class Kwadrat : public Figura

{

public:

Kwadrat();

Kwadrat(double wbok);

 

double pole();

double obwod();

 

private:

double bok;

};

 

/// KLASA PROSTOKAT ///

class Prostokat : public Figura

{

public:

Prostokat();

Prostokat(double wboka, double wbok);

 

double pole();

double obwod();

 

private:

double boka, bokb;

 

};

 

/// KLASA TROJKAT ///

class Trojkat : public Figura

{

public:

Trojkat();

Trojkat(double wboka, double wbokb, double wbokc) : Figura("Trojkat",3);

 

double pole();

double obwod();

 

private:

double boka, bokb, bokc,p;

 

 

};

 

/// KLASA KOLO ///

class Kolo : public Figura

{

public:

Kolo();

Kolo(double wpromien);

 

double pole();

double obwod();

 

private:

double promien;

};

 

//////////////////////////// KLASA ZBIOR FIGUR //////////////////////////////

class ZbiorFigur

{

public:

char *info;

 

ZbiorFigur(void);

ZbiorFigur(char *);

~ZbiorFigur();

 

dodaj_figura(char *opis);

szukaj_figura(char czego);

usun_figura(char co)

 

 

 

/// KLASA LISTA ///

class lista

{

friend ZbiorFigur;

public:

lista(void);

void dodaj(char *,int);

void Put(char *a);

int nastepny(void);

char* odczyt(void);

void poczatek(void);

int ilosc_el(void);

int poprzedni(void);

int ustaw(int gdzie);

void usun(int ktory);

 

private:

char dane[20];

lista *head;

lista *next;

lista *curr;

lista *prev;

};

 

 

//////////////////////////////////////////////////////////////

//------------------Metody Klas---------------------

///////////////////////////////////////////////////////////////

 

// Klasa Figura

Figura::Figura()

{

strcpy(nazwa,"");

wierzcholki=0;

}

 

Figura::Figura(char wnazwa, int wwierzcholki)

{

strcpy(nazwa, wnazwa);

wierzcholki=wwierzcholki;

}

//--------

Figura::ZwrocNazwe()

{

return nazwa;

}

 

// Klasa Kwadrat

//---------

Kwadrat::Kwadrat() : Figura()

{

bok=0;

}

//---------

Kwadrat::Kwadrat(wbok) : Figura("Kwadrat",4)

{

bok=wbok;

}

//---------

double Kwadrat::pole()

{

return bok*bok;

}

//---------

double Kwadrat::obwod()

{

return bok*4;

}

 

// Klasa Prostokat

Prostokat::Prostokat() : Figura()

{

boka=0;

bokb=0;

}

//---------

Prostokat::Prostokat(double wboka, double wbok) : Figura("Prostokat",4)

{

boka=wboka;

bokb=wbokb;

}

//---------

double Prostokat::pole()

{

return boka*bokb;

}

//---------

double Prostokat::obwod()

{

return 2*boka+2*bokb;

}

// Klasa Trojkat

Trojkat::Trojkat() : Figura()

{

boka=0;

bokb=0;

bokc=0;

}

//---------

Trojkat::Trojkat(double wboka, double wbokb, double wbokc) : Figura("Trojkat",3)

{

if (()||()||())

boka=wboka;

bokb=wbokb;

bokc=wbokc;

}

//---------

double Trojkat::pole()

{

p=0.5*(boka+bokb+bokc);

return sqrt(p*(p-boka)*(p-bokb)*(p-bokc));

}

//---------

double Trojkat::obwod()

{

return boka+bokb+bokc;

}

// Klasa Kolo

Kolo::Kolo() : Figura()

{

promien=0;

}

//---------

Kolo::Kolo(double wpromien) : Figura("Kolo",0)

{

promien=wpromien;

}

//---------

double Kolo::pole()

{

return promien*promien*3.14;

}

//---------

double Kolo::obwod()

{

return promien*2*3.14;

}

 

// Klasa ZbiorFigur

ZbiorFigur::ZbiorFigur()

{

info=NULL;

}

//-------

ZbiorFigur::ZbiorFigur(char *winfo)

{

info=strdup(winfo);

}

//-------

ZbiorFigur::~ZbiorFigur(void)

{

delete[] info;

}

//------

ZbiorFigur::dodaj_figura(char *opis)

{

strcpy(info, opis);

strcat(info, opis.pole);

strcat(info, opis.obwod);

dodaj(info,1);

}

 

 

// METODY LISTY

// Konstruktor listy

lista::lista(void)

{

head=NULL;

next=NULL;

prev=NULL;

curr=NULL;

}

// Wstawianie figur

void lista::Put(char *a)

{

int i=0;

while((a=='n')||(i<20))

{

dane=a[i++];

}

dane='n';

}

// Przesuwanie wskaznika na nastepna figure

int lista::nastepny(void)

{

if(curr->next)

{

curr=curr->next;

return 1;

}

else {

return 0;

}

}

// Przesuwanie wskaznika na poprzednia figure

int lista::poprzedni(void)

{

if(curr->prev)

{

curr=curr->prev;

return 1;

}

else return 0;

}

// Odczytywanie danych

char* lista::odczyt(void)

{

return curr->dane;

}

 

void lista::poczatek(void)

{

curr=head;

}

// Sprawdzenie ilosci figur w liscie

int lista::ilosc_el(void)

{

int ilosc=0;

lista *temp;

temp=curr;

curr=head;

do

{

ilosc++;

}

while(nastepny());

curr=temp;

return ilosc;

}

/****************************************************/

void lista::dodaj(char *tekst,int miejsce)

{

lista *a=new lista(); // tworzymy nowy obiekt

a->Put(tekst); // umieszczamy w nim tekst

lista *wsk;

 

if(miejsce==1 && curr==NULL) //jesli lista byla pusta

{

a->prev=NULL;

a->next=NULL;

head=a;

curr=a;

}

 

else if(miejsce>this->ilosc_el()) // jesli wstawiamy na koniec listy

{

this->ustaw(miejsce-1);

curr->next=a;

a->prev=curr;

a->next=NULL;

}

else

{

this->ustaw(miejsce);

wsk=curr;

 

if(this->poprzedni())

{

curr->next=a;

a->prev=curr;

}

else {

head=a;

a->prev=NULL;

}

curr=wsk;

if(wsk)

{

a->next=wsk;

wsk->prev=a;

}

else a->next=NULL;

}

this->ustaw(this->ilosc_el()); // ustawiam sie na ostatnim elemencie

}

// Usuwanie figury z listy

void lista::usun(int ktory)

{

ustaw(ktory);

if(curr->prev)

{

curr->prev->next=curr->next;

}

else head=curr->next;

if(curr->next)

{

curr->next->prev=curr->prev;

curr=curr->next;

}

if(!curr->next && !curr->prev)

{

head=curr=next=prev=NULL;

}

 

}

// Ustawianie wskaznika na okreslonym elemencie

int lista::ustaw(int gdzie)

{

this->poczatek();

int i=1;

do

{

if(i==gdzie) return 1;

i++;

}while(this->nastepny());

return 0;

 

}

/********************************************************************************

***/

void rysuj(void)

{

system("clear");

cout << "************************** LISTA ***********************************nn";

cout << "1. kolejen wstawianie n";

cout << "2. wybor miejsca wstawienian";

cout << "3. pokaz liste n";

cout << "4. usun elementn";

cout << "5. KONIEC n";

}

/****************** program glowny *********************************************/

int main()

{

lista A;

int z=1;

char t[20];

int odp;

int place;

do

{

rysuj();

cin >> odp;

switch(odp)

{

case 1 :

cout << "Podaj tekst dla "<< z << " pola :" << endl;

//getchar();

cin.getline(t,sizeof(t));

A.dodaj(t,z);

z++;

break;

 

case 2: cout << " Podaj wartosc : " ;

getchar();

cin.getline(t,sizeof(t));

cout << " Podaj miejsce, w ktore chcesz wstawic obiekt : " ;

cin >> place;

A.dodaj(t,place);

z++;

break;

 

case 3: { A.poczatek();

cout << " zawartosc listy : " ;

do

{

cout << A.odczyt() << ", ";

}

while(A.nastepny());

cout << endl;

getchar();

break;

}

case 4: { cout << " Ktory element chcesz usunac ? : ";

cin >> place;

A.usun(place);

z--;

break;

}

}

cout << "nacisnij ENTER";

getchar();

rysuj();

}while(odp!=5);

return 0;

}

 

Moglby ktos to skontrolowac? czy ja wogole dobrze brne????

 

 

[Edytowane: 4/2/2004 przez ilear]

[ilear 0]

#include

#include

#include

#include

 

 

 

//////////////////////////////////////////////////////////////

//------------------Definicje Klas---------------------

///////////////////////////////////////////////////////////////

 

 

/// KLASA ABSTRAKCYJNA ///

class Figura

{

friend ZbiorFigur;

public:

Figura(); // Konstruktor bezparametrowy

Figura(char* wnazwa, int wwierzcholki); // Konstruktor z parametrem typu charakter oraz calkowitym

 

virtual double pole() = 0; // obliczanie pola - metoda wirtualna

virtual double obwod() = 0; // obliczanie obwodu - metoda wirtualna

char* ZwrocNazwe() // metoda zwracajaca nazwe figury

 

protected:

char nazwa[10]; // nazwa figury

int wierzcholki; // liczba wierzcholkow

 

/// KLASA KWADRAT ///

class Kwadrat : public Figura

{

public:

Kwadrat();

Kwadrat(double wbok);

 

double pole();

double obwod();

 

double bok;

};

 

/// KLASA PROSTOKAT ///

class Prostokat : public Figura

{

public:

Prostokat();

Prostokat(double wboka, double wbok);

 

double pole();

double obwod();

 

double boka, bokb;

 

};

 

/// KLASA TROJKAT ///

class Trojkat : public Figura

{

public:

Trojkat();

Trojkat(double wboka, double wbokb, double wbokc) : Figura("Trojkat",3);

 

double pole();

double obwod();

 

double boka, bokb, bokc,p;

 

 

};

 

/// KLASA KOLO ///

class Kolo : public Figura

{

public:

Kolo();

Kolo(double wpromien);

 

double pole();

double obwod();

 

double promien;

};

 

//////////////////////////// KLASA ZBIOR FIGUR //////////////////////////////

class ZbiorFigur

{

public:

char *info;

char *zmienna;

char *typ;

 

ZbiorFigur(void);

ZbiorFigur(char *zmienna);

 

dodaj_figura(int wmiejsce,char *typ);

szukaj_figura(char *typ);

usun_figura(int windex)

 

/// Struktura Rekord ///

struct Rekord

{

int indeks;

char stringi;

}

 

 

 

/// KLASA LISTA ///

class lista

{

friend ZbiorFigur;

public:

lista(void);

void dodaj(char *);

void Put(char *a);

int nastepny(void);

char* odczyt(void);

void poczatek(void);

int ilosc_el(void);

int poprzedni(void);

int ustaw(int gdzie);

void usun(int ktory);

 

Rekord slot;

private:

lista *head;

lista *next;

lista *curr;

lista *prev;

};

 

 

//////////////////////////////////////////////////////////////

//------------------Metody Klas---------------------

///////////////////////////////////////////////////////////////

 

// Klasa Figura

Figura::Figura()

{

strcpy(nazwa,"");

wierzcholki=0;

}

 

Figura::Figura(char wnazwa, int wwierzcholki)

{

strcpy(nazwa, wnazwa);

wierzcholki=wwierzcholki;

}

//--------

Figura::ZwrocNazwe()

{

return nazwa;

}

 

// Klasa Kwadrat

//---------

Kwadrat::Kwadrat() : Figura()

{

bok=0;

}

//---------

Kwadrat::Kwadrat(wbok) : Figura("Kwadrat",4)

{

bok=wbok;

}

//---------

double Kwadrat::pole()

{

return bok*bok;

}

//---------

double Kwadrat::obwod()

{

return bok*4;

}

 

// Klasa Prostokat

Prostokat::Prostokat() : Figura()

{

boka=0;

bokb=0;

}

//---------

Prostokat::Prostokat(double wboka, double wbok) : Figura("Prostokat",4)

{

boka=wboka;

bokb=wbokb;

}

//---------

double Prostokat::pole()

{

return boka*bokb;

}

//---------

double Prostokat::obwod()

{

return 2*boka+2*bokb;

}

// Klasa Trojkat

Trojkat::Trojkat() : Figura()

{

boka=0;

bokb=0;

bokc=0;

}

//---------

Trojkat::Trojkat(double wboka, double wbokb, double wbokc) : Figura("Trojkat",3)

{

if (()||()||())

boka=wboka;

bokb=wbokb;

bokc=wbokc;

}

//---------

double Trojkat::pole()

{

p=0.5*(boka+bokb+bokc);

return sqrt(p*(p-boka)*(p-bokb)*(p-bokc));

}

//---------

double Trojkat::obwod()

{

return boka+bokb+bokc;

}

// Klasa Kolo

Kolo::Kolo() : Figura()

{

promien=0;

}

//---------

Kolo::Kolo(double wpromien) : Figura("Kolo",0)

{

promien=wpromien;

}

//---------

double Kolo::pole()

{

return promien*promien*3.14;

}

//---------

double Kolo::obwod()

{

return promien*2*3.14;

}

 

// Klasa ZbiorFigur

ZbiorFigur::ZbiorFigur()

{

strcpy(zmienna,"");

}

//-------

ZbiorFigur::ZbiorFigur(char *wzmienna)

{

strcpy(zmienna, *wzmienna);

}

//-------

ZbiorFigur::dodaj_figura(char *typ)

{

switch(*typ)

{

case 'Kwadrat':

cout<<"Podaj dlugosc boku kwadratu: ";

getchar(zmienna.typ->bok);

break;

case 'Prostokat':

cout<<"Podaj dlugosci boku a: ";

getchar(zmienna.typ->boka);

cout<<"Podaj dlugosci boku b: ";

getchar(zmienna.typ->bokb);

break;

case 'Trojkat':

cout<<"Podaj dlugosc boku a: ";

getchar(zmienna.typ->boka);

cout<<"Podaj dlugosc boku b: ";

getchar(zmienna.typ->bokb);

cout<<"Podaj dlugosc boku c: ";

getchar(zmienna.typ->bokc);

break;

case 'Kolo':

cout<<"Podaj dlugosc promienia: ";

getchar(zmienna.typ->promien);

break;

default:

cout<<"Nie zaimplementowano mi takiej figury-sprobuj jeszcze raz.";

break;

}

 

int wmiejsce=ilosc_el+1

strcpy(info, zmienna);

strcat(info, "|");

strcat(info, *typ);

strcat(info, "|");

strcat(info, (char)zmienna.typ->pole);

strcat(info, "|");

strcat(info, (char)zmienna.typ->obwod);

dodaj(wmiejsce,info);

info="";

}

//----

ZbiorFigur::szukaj_figura(char *typ)

{

poczatek();

strtok(curr->slot.stringi, typ)==NULL? nastepny(): cout<<"Figura ktorej szukasz posiada index = ",

curr->slot.index," oraz n parametry: ",curr->slot.stringi," przy czym pierwsza wartosc to pole, a druga to obwod."

}

 

ZbiorFigur::usun_figura(int windeks)

{

if ((liczba_el

usun(windex)

}

 

// METODY LISTY

// Konstruktor listy

lista::lista(void)

{

head=NULL;

next=NULL;

prev=NULL;

curr=NULL;

}

// Wstawianie figur

void lista::Put(char *a)

{

int i=0;

while((a=='n')||(i<20))

{

dane=a[i++];

}

dane='n';

}

// Przesuwanie wskaznika na nastepna figure

int lista::nastepny(void)

{

if(curr->next)

{

curr=curr->next;

return 1;

}

else {

return 0;

}

}

// Przesuwanie wskaznika na poprzednia figure

int lista::poprzedni(void)

{

if(curr->prev)

{

curr=curr->prev;

return 1;

}

else return 0;

}

// Odczytywanie danych

char* lista::odczyt(void)

{

 

return strcat((char)curr->slot.indeks,curr->slot.stringi);

}

 

void lista::poczatek(void)

{

curr=head;

}

// Sprawdzenie ilosci figur w liscie

int lista::ilosc_el(void)

{

int ilosc=0;

lista *temp;

temp=curr;

curr=head;

do

{

ilosc++;

}

while(nastepny());

curr=temp;

return ilosc;

}

/****************************************************/

void lista::dodaj(int miejsce,char *tekst)

{

lista *a=new lista(); // tworzymy nowy obiekt

a->Put(tekst); // umieszczamy w nim tekst

 

 

if(miejsce==1 && curr==NULL) //jesli lista byla pusta dodaje jako 1 element

{

a->prev=NULL;

a->next=NULL;

head=a;

curr=a;

}

 

else //jesli nie, to na koniec dodaje

{

this->ustaw(miejsce-1);

curr->next=a;

a->prev=curr;

a->next=NULL;

}

 

this->ustaw(this->ilosc_el()); // ustawiam sie na ostatnim elemencie

}

// Usuwanie figury z listy

void lista::usun(int ktory)

{

ustaw(ktory);

Lista *tmp

tmp=curr

curr=head;

int b=tmp->slot.index;

if(tmp->prev)

{

tmp->prev->next=tmp->next;

tmp->next->prev=tmp->prev;

delete tmp;

}

else

{

head=tmp->next;

tmp->next->prev=head;

delete tmp;

}

if(!tmp->next && !tmp->prev)

{

delete tmp;

head=curr=next=prev=NULL;

}

for(b+1, ilosc_el+1, nastepny()) //niweluje roznice 1 miejsca indeksowego po usunieciu elementu

{

curr->slot.index--; }

}

// Ustawianie wskaznika na okreslonym elemencie

int lista::ustaw(int gdzie)

{

this->poczatek();

int i=1;

do

{

if(i==gdzie) return 1;

i++;

}while(this->nastepny());

return 0;

 

}

/********************************************************************************

***/

void rysuj(void)

{

system("clear");

cout << "************************** LISTA ***********************************nn";

cout << "1. Dodaj figure n";

cout << "2. Pokaz liste n";

cout << "3. Usun figuren";

cout << "4. KONIEC n";

}

/****************** program glowny *********************************************/

int main()

{

char x;

int odp;

int place;

do

{

rysuj();

cin >> odp;

switch(odp)

{

case 1 : cout<<"Podaj identyfikator figury: n";

getchar(x);

ZbiorFigur x;

cout<<"Podaj rodzaj figury (z duzej litery): n";

getchar(x.typ);

x.dodaj_figura(typ);

cout<<"Bum..." ;

break;

 

case 2: { x.poczatek();

cout << " zawartosc listy : " ;

do

{

cout << x.odczyt() << ", ";

}

while(x.nastepny());

cout << endl;

getchar();

break;

}

case 3: { cout << " Ktory element chcesz usunac ? : ";

cin >> place;

x.usun(place);

break;

}

}

cout wszystkie bledy?

Bylbym wdzieczny