Egy feladat osztály hierarchiájának felépítésére
2008-11-24T22:42:04+01:00
2008-11-27T13:15:08+01:00
2022-06-29T06:15:27+02:00
  • Első probléma:
    És erre megint azt a hiát dobja,h:
    [Linker error] undefined reference to `vtable for CFonok


    Korábbi hozzászólásomban már megadtam a választ a problémára:
    Remélem tudod mi volt a gond.
    Deklarálva voltak a metódusuk, de nem definiáltad, hogy mit csináljanak.


    Tehát ebben az esetben nem adtad meg, hogy mit csináljanak a CFonok osztály metódusai.
    Megoldás:

    class CFonok : public CMember { protected: CRaktar Raktar; CRendelheto Rendelheto; CRendelesek Rendelesek; CJavitando Javitando; public: virtual void Listaz(string s="default") {}; virtual void Hozzaad(string mit,string s="default") {}; virtual void Torol(string mit, string s="default") {}; virtual int Keres(string mit, string s="default") {}; }; class CUzletvezeto : public CFonok { public: virtual void Listaz(string s="default") {}; virtual void Hozzaad(string mit,string s="default") {}; virtual void Torol(string mit, string s="default") {}; virtual int Keres(string mit, string s="default") {}; };

    Másik probléma:
    Még azt nem értem,h ha valaki belép mondjuk eladóként (CElado : public CDolgozo), akkor,h csinálom meg,h ne tudjon mondjuk torolni?


    Érintőlegesen erre a problémára is adtam már választ korábban:
    Először csinálnék egy "Database" osztályt, ami alapja lehetne a többi adatbázis osztálynak (a Member-eknek nem!). Itt megadnék pár virtuális metódust (pl. a listázást), ami a különböző leszármazottaknál máshogy viselkednek majd.
    Ebből az alap osztályból származtatnám a különböző adatállományokat kezelő osztályokat (raktár, rendelhető, rendelések, javítandó, esetleg még ügyfelek, felhasználók adatbázisa /jogosultságokkal!/).


    Tehát létre kellene, hozni egy adatbázist, ahol a felhasználókat tárolod a jogosultságokkal együtt, és amikor az adott műveletet kellene végrehajtani, ellenőrzöd, hogy az adatbázis szerint van-e az illetőnek jogosultsága hozzá, ha nincs kiírod, hogy "Ehhez önnek nincs jogosultsága!".
    Mutasd a teljes hozzászólást!
  • Megint beakadtam...


    #include <iostream> #include <fstream> #include <string> #include <vector> using namespace std; /************************************************** * Class' **************************************************/ class CDatabase { public: virtual ~CDatabase(){}; virtual void Listaz(){}; virtual int Keres(string s){return 0;}; virtual void Torol(string s){}; virtual void Hozzaad(string s){}; }; class CRaktar : public CDatabase { private: vector<string> raktar; public: CRaktar(); virtual ~CRaktar(); virtual void Listaz(); virtual int Keres(string s); virtual void Torol(string s); virtual void Hozzaad(string s); }; class CRendelheto : public CDatabase { public: vector<string> rendelheto; public: CRendelheto(); virtual ~CRendelheto(); virtual void Listaz(); virtual int Keres(string s); virtual void Torol(string s); virtual void Hozzaad(string s); }; class CRendelesek : public CDatabase { public: vector<string> rendelesek; public: CRendelesek(); virtual ~CRendelesek(); virtual void Listaz(); virtual int Keres(string s); virtual void Torol(string s); virtual void Hozzaad(string s); }; class CJavitando : public CDatabase { public: vector<string> javitando; public: CJavitando(); virtual ~CJavitando(); virtual void Listaz(); virtual int Keres(string s); virtual void Torol(string s); virtual void Hozzaad(string s); }; class CMember { public: virtual void Listaz(string s="default"){}; }; class CDolgozo : public CMember { private: CRaktar Raktar; public: virtual void Listaz(string s="default"); }; class CFonok : public CMember { protected: CRaktar Raktar; CRendelheto Rendelheto; CRendelesek Rendelesek; CJavitando Javitando; public: virtual void Listaz(string s="default"); virtual void Hozzaad(string mit,string s="default"); virtual void Torol(string mit, string s="default"); virtual int Keres(string mit, string s="default"); }; class CUzletvezeto : public CFonok { public: virtual void Listaz(string s="default"); virtual void Hozzaad(string mit,string s="default"); virtual void Torol(string mit, string s="default"); virtual int Keres(string mit, string s="default"); }; /************************************************** * Functions of Class ***************************************************/ . . . /************************************************** * Main **************************************************/ int main() { CMember * felhasznalo; felhasznalo = new CUzletvezeto; delete felhasznalo; int a; cin>>a; return 0; }

    És erre megint azt a hiát dobja,h:
    [Linker error] undefined reference to `vtable for CFonok

    Ezt most mire dobja?

    Még azt nem értem,h ha valaki belép mondjuk eladóként (CElado : public CDolgozo), akkor,h csinálom meg,h ne tudjon mondjuk torolni? vagy akármit csinálni? Vagy a megfelelő virtuális fgv-je csak annyit fog csinálni,h törlés helyett kiírja,h nem lehet?
    Mutasd a teljes hozzászólást!
  • Pontosítsd az elgondolásodat, mert még nem értem.
    Milyen menüről beszélsz?

    egyébként:

    if (felhasznev.compare("szerelo") == 0)

    Szerintem.
    Mutasd a teljes hozzászólást!
  • Valamit nem értek, bár még nem járok ott, de ha mondjuk van nekem egy menüm, akkor ott,h tudom megoldani a dolgokat?
    Én így gondoltam rá:

    string felhasznev; cin >> felhasznev; Member* felhasznalo; if (felhasznev.compare("szerelo")) { bool bQuit=false; felhasznalo = new CSzerelo(); while (bQuit) { /* itt valosítom meg a függvényeket, amiből a kilep(bool & b){b=false;}fogja megvalosítani a tényleges kilépést, de lehetséges az,h pl egy "felhasználónak" van olyan függvénye, ami a többieknek nincs és én azt itt előre leírom,h a felhasznev->tobbineknincsfgv() akkor abból nem lehet gond? Na mind1, lehet,h értelmetlen, ha majd eljutok odáig és dob rá valamit oszt nem tudom mi van akkor írok, persze azért szenvedni is fogok előtte:P*/ } } delete felhasznalo;
    Mutasd a teljes hozzászólást!
  • Igaz, ha végig írom a virtuális függvények elé a virtual-t akkor nehezebben keveredek meg... Amúgy közben rájöttem,h mi votl a hiba, be is írtam a postod alá, de azt még nem értem,h a másik esetben akkor miért nem működött:(
    No mind1:D
    Írok ha elakadok de most szépen haladok, köszi:D
    Mutasd a teljes hozzászólást!
  • Nézd meg, hogy mi történik, ha a Listaz() függvény virtuálisságát megszünteted!
    Mutasd a teljes hozzászólást!
  • Remélem tudod mi volt a gond.
    Deklarálva voltak a metódusuk, de nem definiáltad, hogy mit csináljanak.

    Szerintem jó lenne a destruktor függvényt is virtuálisra venni. Továbbá ajánlatos a leszármazott osztályokban is jelezni, hogy mi volt eredetileg is virtuális.


    #include <iostream> #include <fstream> #include <string> #include <vector> using namespace std; /********************************* * Class' *********************************/ class CDatabase { public: virtual ~CDatabase(); virtual void Listaz(); virtual int Keres(string s); virtual bool Torol(string s); virtual void Hozzaad(string s); }; class CRaktar : public CDatabase { private: vector<string> raktar; public: CRaktar(); virtual ~CRaktar(); virtual void Listaz(); virtual int Keres(string s); virtual bool Torol(string s); virtual void Hozzaad(string s); }; /********************************** * Functions of Class ***********************************/ CDatabase::~CDatabase() {} void CDatabase::Listaz() { cout << "\nCDatabase:Listaz\n";} void CDatabase::Hozzaad(string s) {} bool CDatabase::Torol(string s) { return true; } int CDatabase::Keres(string s) { return 0; } CRaktar::CRaktar() {} CRaktar::~CRaktar() {} void CRaktar::Listaz() { cout << "\nCRaktar:Listaz\n";} void CRaktar::Hozzaad(string s) {} bool CRaktar::Torol(string s) { return true; } int CRaktar::Keres(string s) { return 0; } /************************************** * Main **************************************/ int main() { //int a; cin>>a; CDatabase* db; db = new CRaktar(); db->Listaz(); delete db; return 0; }

    A return... visszatérési adatokat azért írtam be a függvényekbe, mert az én fordítóm kiabál, ha egy nem void függvényt return nélkül akarok létrehozni.
    Mutasd a teljes hozzászólást!
  • Megvan a hiba, bennhagyom hátha valaki még fogja olvasni, bár nem hiszem,h valaki is elkövetne egy ien hiábet
    Nem definiáltam az ősosztály virtuális fgv-it:(
    tehát ha kijavítom az ősosztályt így akkor máris faja:

    class CDatabase { public: virtual void Listaz() { }; virtual int Keres(string s){}; virtual bool Torol(string s){}; virtual void Hozzaad(string s){}; };

    De arra még mindig kiváncsi lennék,h az egyik esetben akkor miért működött a dolog??
    Mutasd a teljes hozzászólást!
  • Meg tudnád mondani azt,h így miért dob fordítási hibát:

    #include <iostream> #include <fstream> #include <string> #include <vector> using namespace std; /********************************* * Class' *********************************/ class CDatabase { public: virtual void Listaz(); virtual int Keres(string s); virtual bool Torol(string s); virtual void Hozzaad(string s); }; class CRaktar : public CDatabase { private: vector<string> raktar; public: void Listaz(); int Keres(string s); bool Torol(string s); void Hozzaad(string s); CRaktar(); ~CRaktar(); }; void CRaktar::Listaz(){}; void CRaktar::Hozzaad(string s){}; bool CRaktar::Torol(string s){}; int CRaktar::Keres(string s){}; CRaktar::CRaktar(){}; CRaktar::~CRaktar(){}; /************************************** * Main **************************************/ int main() { int a; cin>>a; return 0; }


    És így miért nem:


    #include <iostream> #include <fstream> #include <string> #include <vector> using namespace std; /********************************* * Class' *********************************/ class CDatabase { public: virtual void Listaz(); virtual int Keres(string s); virtual bool Torol(string s); virtual void Hozzaad(string s); }; class CRaktar : public CDatabase { private: vector<string> raktar; public: void Listaz(){}; int Keres(string s){}; bool Torol(string s){}; void Hozzaad(string s){}; CRaktar(){}; ~CRaktar(){}; }; /************************************** * Main **************************************/ int main() { int a; cin>>a; return 0; }

    Nem értem,h mi a különbség a kettő között...
    Azt hittem,h teljesen egyenértékű ha az osztályon belül illetve ha az osztályon kívül hatókör operátorral csinálom, max esztétikai dolog illetve átláthatóbb.. Ezek szerint nem:(
    Mutasd a teljes hozzászólást!
  • Értem, de csak a destruktornál kell ugyanúgy elé a virtual kulcsszó, no majd kiprószálom de mgé nem tartok ott, most megint megakadtam, eddig van ez:

    #include <iostream> #include <fstream> #include <string> #include <vector> using namespace std; /********************************* * Class' *********************************/ class CDatabase { public: virtual void Listaz(); virtual int Keres(string s); virtual bool Torol(string s); virtual void Hozzaad(string s); }; class CRaktar : public CDatabase { private: vector<string> raktar; public: void Listaz(); int Keres(string s); bool Torol(string s); void Hozzaad(string s); CRaktar(); ~CRaktar(); }; /********************************** * Functions of Class ***********************************/ CRaktar::CRaktar() { /* string s; //raktar.txt beolvasása ifstream be_raktar("raktar.txt"); getline(be_raktar, s); raktar.push_back(s); while (!be_raktar.eof()) { getline(be_raktar, s); raktar.push_back(s); } be_raktar.close();*/ } void CRaktar::Listaz(){} void CRaktar::Hozzaad(string s){} bool CRaktar::Torol(string s){} int CRaktar::Keres(string s){} /************************************** * Main **************************************/ int main() { int a; cin>>a; return 0; }

    viszont már itt is hibát dob (DevCpp Message rész):

    In function `ZSt38__copy_backward_output_normal_iteratorIPSsN9__gnu_cxx17__normal_iteratorIS0_St6vectorISsSaISsEEEEET0_T_S8_S7_11__true_type':
    [Linker error] undefined reference to `vtable for CDatabase'
    ld returned 1 exit status

    szal erősen rátapadtam egy szótárra meg a googlira megint:D
    Mutasd a teljes hozzászólást!
  • Itt akkor (destruktoroknál,konstruktoroknál) ha virtuális lesz akkor autómatikusan a belőle származtatott is virtuális lesz?


    Ha jól tudom igen.
    Sőt, ha az ős osztályban virtuálisnak deklaráltad a destruktor függvényt, akkor a leszármazott osztályokban a felül deklaráláskor kötelező, virtuálisként deklarálni továbbra is. Ebben a különleges esetben nem fontos a névazonosság, hiszen a rendszer tudja, hogy ez függvény a destruktor. És csak ez a fontos számára ilyenkor.

    Viszont a konstruktor függvényeket sosem szokták virtuálisra deklarálni. Talán nem is lehet, azt hiszem, mert az objektum létrehozásakor úgyis egyértelműen meg kell adni, hogy milyen konstruktorral hozza létre a rendszer az objektumot. És a rendszer nem hozhat létre másfajta objektumot, csak azt amit a konstruáláskor megadtunk neki. Tehát itt nem lehet virtualizálni, konkrétan meg kell mondanunk, milyen objektumra van szükségünk. Honnan tudhatná a program, hogy CSzerelo példányt akarunk létrehozni, ha a Member konstruktorát hívjuk meg? Találja ki? Miből?

    A példámban ez így nézett ki:

    if (felhasznev.compare("szerelo")) { felhasznalo = new CSzerelo(); }

    Tehát konkrétan egy CSzerelo osztályba tartozó objektumot akarok létrehozni.
    Majd ha már létrehoztam, akkor elérhetem a virtuális metódusait, akkor is, ha a felhasználo -t csak "Member" osztályba tartozó pointernek deklaráltam.

    Pl.

    felhasznalo->egyVirtualisMetodus();

    utasítás, nem a Member egyVirtualisMetodus() metódusát fogja végrehajtani, hanem a CSzerelo-ét.
    Mutasd a teljes hozzászólást!
  • Csodákra képes a google
    Mutasd a teljes hozzászólást!
  • Ave!

    Most olvastam át tüzetesebben... Kezd világosodni a dolog, bár az elméletét teljesen leírtad, viszont azt nem értem,h lehet destruktorhoz-konstruktorhoz virtuális függvényt rendelni?
    Csak mert én úgy tanultam(!nem röhög),h a virtuális függvény az azonos nevű és paraméterezésű függvényt "keresi" meg a gyerekekben és azt hajtja végre...
    De akkor nem világos ez a destruktoros dolog mert pl.:

    class CMember { public: virtual ~CMember(); }; class CSzerelo : public CMember { public: ~CZerelo(); };

    Itt akkor (destruktoroknál,konstruktoroknál) ha virtuális lesz akkor autómatikusan a belőle származtatott is virtuális lesz?
    Mutasd a teljes hozzászólást!
  • Ami az objektum orientáltságban, szerintem, az egyik legnagyobb előny, hogy a virtuális metódusok révén könnyen megvalósítható, hogy futás időben el fogja tudni dönteni a program, hogy most éppen milyen objektum lett létrehozva, és annak meg tudja keresni a hozzátartozó virtuális metódusát, aminek le kell futnia.

    A te feladatodban ezt nagyon jól ki lehetne használni, hisz nem tudhatod előre, hogy ki fog leülni a számítógép elé, az igazgató vagy a szerelő vagy az eladó.

    Korábbi példámban már mutattam, hogyan működhet ez:


    string felhasznev; cin >> felhasznev; Member* felhasznalo; if (felhasznev.compare("szerelo")) { felhasznalo = new CSzerelo(); } //...stb. // a program befejezésekor (pontosabban a felhasználó kilépésekor): delete felhasznalo; // természetesen minden Member leszármazottnak virtuális destruktor függvénnyel kell rendelkeznie, hogy a rendszer a megfelelő destruktort hívhassa meg!

    Ha megfigyeled, itt már maximálisan kihasználjuk az objektum orientáltság előbb említett előnyét. Nem tudjuk, hogy ki fog leülni a számítógép elé, ezért adjuk meg hogy

    Member* felhasznalo;

    Hangsúlyoznom kell, hogy ez még nem példány!!! Ez csak egy pointer típusú változó, ami jelen állapotban nem mutat még semmilyen valós objektumra.

    Viszont, amikor bejelentkezett a felhasználó, akkor létrehozunk egy objektumot, amire fog mutatni "felhasználo" mutató.

    if (felhasznev.compare("szerelo")) { felhasznalo = new CSzerelo(); }

    Ezt megtehetjük, hiszen a CSzerelo osztályt a "Member" osztályból származtattuk. Amint látod, futás időben mondtuk meg, hogy milyen típusú példányt szeretnénk létrehozni.

    És ami nagyon fontos, ezek után a virtuális metódusok közül nem a "Member" metódusai fognak meghívódni, hanem a "CSzerelo" metódusai. Így az objektumom úgy fog viselkedni, mint egy CSzerelo, nem mint egy "Member".

    Ezért írtam az előbb is, hogy a destruktor függvénynek virtuálisnak kell lennie. Hiszen a destrukciót csak az az objektum ismerheti, ami létre lett hozva. A "Member" osztály nem tudhatja, hogyan kell egy "CSzerelo" osztályt megszüntetni.

    De ha a destruktor virtuális, akkor nincs gond. A "CSzerelo" destruktora fog végrehajtódni.
    Mutasd a teljes hozzászólást!
  • Az osztályokat is ugyanúgy kell elképzelni, mint a C++ -ba beépített többi típust (int, char, bool, double ...). A programírás közben ezek csak absztrakt fogalmak, és csak azokat példányosítjuk, amelyekre ténylegesen szükség van a program megírásához. Minek hoznék létre egy double objektumot (példányt), ha egyébként nincs rá szükségem.
    Ugyanígy van az osztályokkal, csak azokat kell példányosítani, amelyekre tényleg szükség van. De mindez, mindig a programozó feladata és felelőssége, hogy mikor milyen objektumokat hoz létre. Jól meg kell fontolni, hogy felesleges objektumok ne képződjenek.
    Mutasd a teljes hozzászólást!
  • mert egyszer benne lesz az A és egyszer a B példányában is


    Tökéletesen jól látod. Két olyan példányod lesz, amiben van "adatok" adattag, de a program írásakor el kell döntened, hogy vajon akarod-e mindkét osztályt példányosítani. Minek példányosítanád "A" ősosztályt, ha egyébként csak arra hoztad létre, hogy egy bázis osztálya legyen a többi hasonlónak ("B"-nek, "C"-nek és "D"-nek)? Amelyeket már tényleg szeretnél működtetni, mer "B" a készleteket tárolja, "C" a rendeléseket, stb...
    "A"-t felfoghatod egy absztrakt osztálynak, amit tulajdonképpen sosem akarsz példányosítani. Úgyis elérhetőek lesznek az adattagjai és metódusai a leszármazott osztályokban is.

    És még egyszer hangsúlyozom, hogy te vagy a programozó, te döntöd el, hogy mikor melyik osztályt példányosítod. Ha úgy döntesz, hogy mindkét osztály példányára szükséged van, az a te felelősséged, hogy utána azokat jól kezeld.
    Mutasd a teljes hozzászólást!
  • Holnap, vagyis ma átolvasom kicsit tisztább fejjel...
    Amit kevertem az nem az osztály-objektum dolog volt, az tiszta, bár ez a kutyás dolog tényleg nem rossz, én ezt nem értettem:


    class A { protected: vector<string> adatok; } class B : public A { protected: int x;

    csinálok mind1ikből 1-1 példányt:

    B b; A a;

    És így gondoltam,h kettő lesz az adatok adattagból, mert egyszer benne lesz az A és egyszer a B példányában is, és nem úgy lesz,h az A-é lesz benne a B-ben is... Tudom, hülyén hangzik illetve még egy hiányosságról tettem tanúbizonyságot:(
    Remélem azért majd idővel belejövök az OOP-be is...
    Mutasd a teljes hozzászólást!
  • "Database" osztályt, aminek gondolom lesznek vektorai

    Hát nem biztos, hogy ennek az ős osztálynak még szüksége van bármiféle vektorra. Ez tulajdonképpen arra lesz csak jó, hogy meghatározd, hogy mik azok az alap tulajdonságok és metódusok, amik egy adatbázist jellemzik. A konkrét vektorokat inkább a konkrét leszármazottakban tudnám elképzelni.

    Értem itt azt,h ha megváltoztatom a "Database" osztály egyik adattagját, akkor az a leszármazottakéban nem fog megváltozni, viszont így akkor nem lesz egy adatbázisról több másolatom?


    Látom alapvető fogalmak nem tiszták. A leszármazás csak elméleti dolog, azt írja le hogy két osztály milyen öröklési viszonyban van egymással. Ez az adatbázisok mennyiségére semmiféle kihatással nincs. Az adatbázisok akkor duplázódhatnának, ha két példányt (objektumot) is létrehoznál egy osztályból.

    Nézzünk egy példát:


    class A { protected: vector<string> adatok; } class B : public A { protected: int x;

    Mi történik ha példányosítom B-t?

    B b_peldany;

    Létrejön a vektor és az x is, tehát hivatkozhatnék rájuk így, ha nem lennének protected-ek:

    b_peldany.adatok; b_peldany.x;

    Csak akkor duplázódik meg a vektor, ha létrehozok még egy példányt:

    B b_peldany_2;

    Ekkor már tényleg két vektorom lenne, egyik a "b_peldany"-ban a másika "b_peldany_2"-ben.

    Gondolj ilyenkor mindig valami egyszerű dologra, ha nem tiszta. Vegyük pl. az állatok fogalmát ez lehetne egy osztály. Ennek egyik leszármazottja pl. a kutyák osztálya. Ha az én kutyám megfial, és világra hoz egy kölyköt, akkor azt mondhatjuk példányosította a kutyák osztályát. Létrehozott 1db példányt. Attól függetlenül, hogy ez a kölyök állat is meg kutya is, nem létezik kétszer. Csak egy van belőle. Csak akkor lesz két élő kutya, ha fial még egy kölyköt a kutyám.

    Érted már mi a különbség az osztály és a példány (objektum) között. Az osztály csak fogalmi kategória, a példány pedig a valóság (kutyakölyök vagy memória tárhely az x változónak.)

    Tehát a program indulásakor, csak egy-egy példányt hozunk létre az adatbázisokból. Nem fogjuk megkettőzni. Hisz mi írjuk a programot. Ezáltal minden módosítás, látszani fog mindenhol.



    Amit még nem értek az-az,h h tudom megcsinálni,h csak egyet példányosítok meg attól függően,h ki jelentkezett be?

    pl így:

    string felhasznev;
    cin>>felhasznev;
    if (felhasznev=="szerelo") CSzerelo szerelo;
    if (felhasznev=="elado") CElado elado;


    Igen valami hasonlóra gondoltam:

    string felhasznev; cin >> felhasznev; Member* felhasznalo; if (felhasznev.compare("szerelo")) { felhasznalo = new CSzerelo(); } //...stb. // a program befejezésekor (pontosabban a felhasználó kilépésekor): delete felhasznalo; // természetesen minden Member leszármazottnak virtuális destruktor függvénnyel kell rendelkeznie, hogy a rendszer a megfelelő destruktort hívhassa meg!
    Mutasd a teljes hozzászólást!
  • Tényleg, úgy látszik,h már komolyan le kellene feküdnöm, mert már egy épkézláb mondatot sem tudok értelmezni... Hát akkor sorry még egyszer, de már reggel 11 óta nyomatom a forráskódokat és asszem itt a határ^^
    Mutasd a teljes hozzászólást!
  • Szerintem: ME = Miskolci Egyetem.
    Mutasd a teljes hozzászólást!
  • Hát sorry de akkor nem értem ezt az ME-s dolgot...
    Mutasd a teljes hozzászólást!
  • Nem írtam tárgyat. Viszont tévedsz, arra ráillik.
    Mutasd a teljes hozzászólást!
  • Hm, eléggé épkézláb...
    Viszont 2 dolog van amit nem értek:
    - Az addig tiszta,h van egy "Database" osztályt, aminek gondolom lesznek vektorai amik tárolják az adatokat, vagy ezeket csak a megfelelő leszármazottakba raknám bele? De még utána is származtatnék belőle a végsőkig, viszont akkor nem lépne fel az mint utoljára? (Értem itt azt,h ha megváltoztatom a "Database" osztály egyik adattagját, akkor az a leszármazottakéban nem fog megváltozni, viszont így akkor nem lesz egy adatbázisról több másolatom? Mármint módosítom aztán máshol kilistázom, és akkor nem biztos,h listázni fogja a változást is)
    - Amit még nem értek az-az,h h tudom megcsinálni,h csak egyet példányosítok meg attól függően,h ki jelentkezett be?

    pl így:

    string felhasznev; cin>>felhasznev; if (felhasznev=="szerelo") CSzerelo szerelo; if (felhasznev=="elado") CElado elado; . . .

    persze bele lehet rakni a cin-es részt mondjuk egy while-ciklusba ami csak akkor lép ki ha valóst ír be (ami mondjuk kell is), így gondoltad?
    Mutasd a teljes hozzászólást!
  • ME mint mi?
    Amúgy se sulira se tárgyra nem illik ráxd (suli:Pannon Egyetem, tárgy:Szoftvertechnológiák)
    Mutasd a teljes hozzászólást!
  • Csak nem ME?
    Mutasd a teljes hozzászólást!
  • Hát így én sem biztos, hogy segíteni tudok.

    Viszont nagyjából a következőre gondolok. (Természetesen nem kell 100-asnak venni!)
    Először csinálnék egy "Database" osztályt, ami alapja lehetne a többi adatbázis osztálynak (a Member-eknek nem!). Itt megadnék pár virtuális metódust (pl. a listázást), ami a különböző leszármazottaknál máshogy viselkednek majd.
    Ebből az alap osztályból származtatnám a különböző adatállományokat kezelő osztályokat (raktár, rendelhető, rendelések, javítandó, esetleg még ügyfelek, felhasználók adatbázisa /jogosultságokkal!/).
    Ezeket a program indításakor a fájlokból beolvasnám és létrehoznék egy-egy objektumot az adatbázisokra.
    Ezután megalkotnám a "Member" osztályt, amiből származtatnám az egyéb kategóriákat (pl. dolgozó, főnök, computer-szakértő, stb.) És ezekből származtatnám a tényleges végső osztályokat (pl. szerelő, eladó, üzletvezető, szerviz veető, stb..).
    A felhasználó bejelentkezése után lehetne példányosítani a neki megfelelő osztályt, és a példány megkonstruálásakor az adattagjai közzé fel kellene venni azokat az adatbázisokat, amelyek szükségesek a munkájához, és jogosultsága van hozzá. Ezeket ő kezelhetné az adatbázis függvényein keresztül.
    Mutasd a teljes hozzászólást!
  • Azt hiszem,h úgy van,h projecteket kell csinálni meg ledokumentálni & leprogramozni(csak nekem már meg van ez a tárgyam, de amikor én csináltam elég volt ledokumentálni), és haver megkért,h programozzam le, csak Ők úgy gondolták,h előbb a programozás és abból majd a dokumentáció, de még egy alap UML-diagrammér is könyörögnöm kellett.. Szal ezért nincs pontos feladatkiírás, az van amit ők akarnának csak az nem biztos,h logikus:D
    Mutasd a teljes hozzászólást!
  • Nincs pontos feladatkiírás:D
    Csak laza keretek vannak megadva:

    telefon eladó-javító cég
    több felhasználó (elég 2-3 is ha úgy adódik)
    bejelentkezési rész (nem feltétlenül kell jelszó, elég ha a felhasznévvel lép be)
    8-10 osztály

    a többit márt csak haver-csoportja csapja hozzá:
    eladásnál lehessen "blokkot noymtatni" ami abból áll,h kiír egy rakat hülyeséget, meg h dinamikus adatbázisok legyenek txt file-okbe lementve program indulásánál onnét betöltve majd végeztével visszatöltve
    Mutasd a teljes hozzászólást!
  • Aha!

    Ide tetted a témát.
    Nem lehetne a pontos feladatkiírást megadnod?
    Mutasd a teljes hozzászólást!
  • A feladat a következő lenne, van egy telefon eladó-vevő cég, és ezt kellene leprogramozni 8-10 osztályt felhasználva c++ nyelven (Devcpp-t használok)...
    Sajnos hamar elakadtam illetve logikátlan hierarchiát kaptam ill. csináltam:(

    Nálam volt egy Adatbázis osztály ami tárolta vona az adatokat (raktár-, rendlehető-, rendelések-, javítandó-, adatbázisok), lett volna 7 további osztály: member, vendég,szerelő, eladó, beszállító, rendszergazda,üzletvezető...
    A meberből származna az üzletvezető kivételével mind1ik, majd az üzletvezető a rendszergazda és a member kivételével a többiből... Az adatbázis külön lenne, csak ez így nagoyn nem jó vhogy...
    Mutasd a teljes hozzászólást!
Ez a téma lezárásra került a moderátor által. A lezárás oka: Konkr�t k�rd�seket a Tud�st�rban k�retik feltenni (am�gy is kezd egyre kev�sb� programoz�s-elm�leti t�m�v� v�lni)!
abcd