Forum Pasja Informatyki - Najnowsze z tagiem wirtualne

Zmienne wirtualne. Jak napisać żeby było czytelnie i wydajnie?

Wed, 23 Mar 2022 21:02:06 +0000

Problem wygląda tak

#include <iostream>

class Square
{
public:
    virtual void event() = 0;
};

class GoToJail : public Square
{
public:
    const int type = 0;

    void event()
    {
        //jakis kod
    }
};

class Property : public Square
{
public:
    const int type = 1;

    void event()
    {
        //jakis kod
    }
};

class Empty : public Square
{
public:
    const int type = 2;

    void event()
    {
        //jakis kod
    }
};

int main()
{
    Property property[ 3 ];
    Empty empty;
    GoToJail gotojail;

    Square *square[ 5 ];

    square[ 0 ] = &empty;
    square[ 1 ] = &property[ 0 ];
    square[ 2 ] = &property[ 1 ];
    square[ 3 ] = &property[ 2 ];
    square[ 4 ] = &gotojail;

    std::cout << square[ 3 ] -> type;

    return 0;
}

Jak zrobić żeby pisząc square[ n ] -> type wyświetlało mi typ pola o indeksie n? Można dodać virtual int getType() każdej klasie ale wydaje mi się że dodawanie dodatkowej metody jest trochę nieładne i też nie wiem czy wywoływanie tej metody nie jest mniej wydajne od przekazywania od razu zmiennej. Czytałem też coś o dynamic_cast ale też to rozwiązanie intuicyjnie nie wydaje mi się najbardziej optymalne. Jak profesjonalny programista by to rozwiązał?

Co to jest wirtualny destruktor i do czego służy?

Mon, 29 Mar 2021 19:25:34 +0000

Co to jest wirtualny destruktor i do czego służy? W Eclipse for C++ jak się generuje nową klasę to powstaje destruktor, który jest wirtualny. Czemu tak jest?

Klasy abstrakcyjne i destruktor wirtualny

Sun, 07 Jun 2020 16:57:49 +0000

Witam, Mam problem z poniższym kodem . Z góry dziękuję za pomoc.

C:\Users\Mateusz_2\Desktop\programy\rozdz14 zad 4\person.h|68|undefined reference to `PokerPlayer::~PokerPlayer()'|

C:\Users\Mateusz_2\Desktop\programy\rozdz14 zad 4\person.h|68|undefined reference to `Gunslinger::~Gunslinger()'|

#ifndef PERSON_H_
#define PERSON_H_
#include <iostream>
#include <string>
#include <cstdlib>
#include <cstdio>
#include <ctime>



using std::string;

class Person
{
private:
    string imie;
protected:
    virtual void dane() const;
    virtual void Get();

public:
    Person(): imie("Brak"){}
    Person(const string & name) : imie(name){}
    virtual ~Person()=0;
    virtual void show() const=0;
    virtual void setall()=0;
};

class Gunslinger : virtual public Person
{
private:
    double czas;
    int naciecia;
protected:
    virtual void dane() const;
    virtual void Get();
public:
    Gunslinger() :Person(), czas(0), naciecia(0) {}
    Gunslinger(const string & name,  double time, int nac) : Person(name), czas(time), naciecia(nac) {}
    Gunslinger(const Person & p, double time, int nac) : Person(p), czas(time), naciecia(nac) {}
    ~Gunslinger();
    double draw() const {return czas;}
    void show() const;
    void setall();


};

class PokerPlayer : public virtual Person
{
private:
    int liczba;
protected:
      virtual void Get();
    virtual void dane() const;

public:
    PokerPlayer(): Person(), liczba(0){}
    PokerPlayer(const Person & p, int licz): Person(p), liczba(licz){}
    PokerPlayer(const string & name, int licz) : Person(name), liczba(licz){}
     ~PokerPlayer();
    int  draw() const;
    void show() const;
    void setall();

};

class BadDude : public Gunslinger, public PokerPlayer
{
     virtual void dane() const;
         virtual void Get();
public:
    BadDude() : Gunslinger(), PokerPlayer() {}
    BadDude(const string & name,  double time, int nac, int licz) : Person(name), Gunslinger(name, time, nac), PokerPlayer(name, licz){}
    BadDude(const Gunslinger & g, int licz ): Person(g), Gunslinger(g), PokerPlayer(g,licz){}
    BadDude(const Person & p, double time, int nac, int licz) :Person(p), Gunslinger(p,time,nac), PokerPlayer(p, licz){}
    BadDude(const PokerPlayer & pp, double time, int nac): Person(pp), Gunslinger(pp,time, nac), PokerPlayer(pp){}
    double Gdraw() const;
    int Cdraw() const;
    void show() const;
    void setall();


};



#endif // PERSON_H_

#include <iostream>
#include "person.h"
#include <string>
#include <cstdlib>
#include <cstdio>
#include <ctime>



using namespace std;


     void Person::dane() const
     {
         cout<<"Imie i nazwisko: "<<imie;
     }
     void Person::Get()
     {
         cout<<"Podaj imie i nazwisko: ";
         getline(cin, imie);
         while(cin.get() != '\n')
            continue;
     }


    void Gunslinger::dane() const
    {
        cout<<"\nCzas wyciagania rewolweru: "<<czas;
        cout<<"\nLiczba naciec na rewolwerze: "<<naciecia;
    }
    void Gunslinger::Get()
    {
        cout<<"\nPodaj czas wyciagania rewolweru: ";
        cin>>czas;
        cout<<"\nPodaj liczbe naciec na rewolwerze: ";
        cin>>naciecia;
    }
    void Gunslinger::show() const
    {
        cout<<"\nRewolwerwiec\n ";
        Person::dane();
        dane();
    }
    void Gunslinger::setall()
    {
        Person::Get();
        Get();
    }


    void PokerPlayer::Get()
    {
        Person::Get();
    }
    void PokerPlayer::dane() const
    {
        cout<<"Numer karty: "<<liczba;
    }
    int  PokerPlayer::draw() const
    {
        srand(time(NULL));
      return rand()%52+1;
    }
    void PokerPlayer::setall()
    {
        Get();
    }
    void PokerPlayer::show() const
    {
        cout<<"\nPokerzysta\n";
        Person::dane();
        dane();
    }

     void BadDude::dane() const
     {
         Gunslinger::dane();
         PokerPlayer::dane();
     }
     void BadDude::Get()
     {
         Gunslinger::Get();
         PokerPlayer::Get();
     }
    double BadDude::Gdraw() const
    {
        return Gunslinger::draw();
    }
    int BadDude::Cdraw() const
    {
        return PokerPlayer::draw();
    }
    void BadDude::show() const
    {
        cout<<"\nBadDude\n";
        dane();
        cout<<"\nCzas wyciagnania rewolweru: "<<Gdraw();
        cout<<"\nLosowa karta od 1 do 52: "<<Cdraw();
    }
    void BadDude::setall()
    {
        Get();
    }

#include  <iostream>
#include "person.h"

using namespace std;

int main()
{
    const int SIZE = 5;
    Person * Tab[SIZE];
    int ct;
    for (ct = 0; ct <SIZE; ct++)
    {
        int choice;
        cout << "Kim chcesz byc???? :D\n"
                "1: pokerzysta, 2: rewolwerowiec, 3: Zly gosc!, 4: wyjscie\n";
        while (!(cin >> choice) && (choice == 1 || choice == 2 || choice == 3 || choice == 4))
        {
            cout <<"Wpisz 1 lub 2 lub 3 lub 4!";
        }
        if (choice == 4)
            break;
        switch(choice)
        {
           case 1 : Tab[ct] = new PokerPlayer; //Tutaj jest blad
                break;
            case 2 : Tab[ct] = new Gunslinger;
                break;
            case 3 : Tab[ct] = new BadDude;
                break;
        }
        cin.get();
        Tab[ct]->setall();
    }
    cout <<"\nLista bohaterow:\n";
    int i;
    for (i = 0; i < ct;i++)
    {
        cout<<endl;
        Tab[i]->show();
    }
    for (i = 0; i < ct; i ++)
        delete Tab[i];

    cin.get();
    cin.get();
    return 0;
}

Funkcje wirtualne

Tue, 29 Jan 2019 17:22:46 +0000

Cześć,

Mam problem ze zrozumieniem przydatności i możliwości jakie dają funkcje wirtualne. Pewnie wynika to z faktu, że "wydaje" mi się, że rozumiem temat.

Przechodząc do rzeczy. Jeśli ktoś ma pomysł jak na najprostszych przykładach z życia wziętych, wytłumaczyć możliwości jakie dają funkcje wirtualne, będę ogromnie wdzięczny. Czemu lepiej użyć takiej metody niżeli pisania dla każdego obiektu osobnej np nazwanej tak samo lub odziedziczonej.

Ja to widzę mniej więcej tak: Po co tworzyć f. wirtualną, potem wskaźniki itp. skoro i tak każdą metodę musimy napisać jeszcze raz, ponieważ różne obiekty mogą mieć różne właściwości danej metody. Piszemy każdą osobno (bo i tak musimy to zrobić) następnie tylko używamy obiekt.metoda(); i gotowe w przypadku funkcji wirtualnych, dochodzą wskaźniki itp.

Nie zrozumcie mnie źle, ja nie próbuję negować przydatności f. wirtualnych, dlatego opisałem jak ja to widzę, żeby osoba, która to przeczyta wskazała błąd w moim rozumowaniu.

(czysto) wirtualny destruktor

Sat, 08 Dec 2018 13:04:07 +0000

Witam, ostatnio natknął się na taki problem, że chciałem stworzyć czysto wirtualny destruktor, więc napisałem taki kod:

#include <iostream>

using namespace std;

class Ca
{
public:

      virtual ~Ca() = 0;
};

class Cb :public Ca
{

public:

      virtual ~Cb()
      {
          cout << "(obiekt) UMIERAM!!!" << endl;
      }

};

int main()
{
   Ca *wsk = new Cb;

   delete wsk;

   return 0;
}

I nagle kompilator pokazał błąd, więc postanowiłem napisać tego destruktora normalnie wirtualnego, czyli z ciałem i wyszło, że tym razem kod działał.

I teraz mam takie pytanie, czy to oznacza, że wirtualnych destruktorów nie można pisać jako czyste metody wirtualne?

Metoda wirtualna vs czysto wirtualna

Sun, 11 Mar 2018 18:14:16 +0000

Hej. Na podstawię tego wpisu dotyczącego polimorfizmu w C#:

https://www.p-programowanie.pl/c-sharp/metody-wirtualne-abstrakcyjne-i-polimorfizm/

Postanowiłam napisać taki prosty programik w C++ aby utrwalić zdobytą wiedzę dotycząca róznic między metodami wirtualnymi a abstrakcyjnymi. Z tacji tego, ze C++ metod abstrakcyjnych nie ma to wykorzystałam metodę czysto wirtualna w przypadku figur i zwykła wirtualna w przypadku pracowników. Wybaczcie istnienie zmiennych napisanych po polsku ale nie miałam zbytnio czasu no i zapomniałam o zasadach nazewnictwa xD.

#ifndef KSZTALT_H
#define KSZTALT_H

class Ksztalt
{
public:
    virtual float Oblicz() = 0;
};

class Kwadrat: public Ksztalt
{
    float a;
public:
    Kwadrat(int x)
    {
        a=x;
    }
    float Oblicz()
    {
        return a*a;
    }
};

class Prostokat: public Ksztalt
{
    float a;
    float b;
public:
    Prostokat(int x, int y)
    {
        a=x;
        b=y;
    }
    float Oblicz()
    {
        return a*b;
    }
};

class Kolo: public Ksztalt
{
    float r;
    const float PI = 3.14;
public:
    Kolo (int x)
    {
        r=x;
    }
    float Oblicz()
    {
        return 2*PI*r;
    }
};

#endif // KSZTALT_H

#define PRACOWNIK_H
#include <iostream>

using namespace std;

class Pracownik
{
public:
    virtual void Pracuj()
    {
        cout <<"Przychodze do pracy i wykonuje ja."<<endl;
    }
};

class Sekretarka: public Pracownik
{
    int wiek = 21;
public:
    void Pracuj()
    {
        Pracownik x;
        x.Pracuj();
        cout<<"Mam "<<wiek<<" lat."<<"Odbieram telefony od klientow"<<endl;
    }
};

class Sprzataczka: public Pracownik
{
    int wiek = 34;
public:
    void Pracuj()
    {
        Pracownik y;
        y.Pracuj();
        cout<<"Mam "<<wiek<<" lat. Sprzatam zaklad pracy."<<endl;
    }
};


#endif // PRACOWNIK_H

#include <iostream>
#include "Ksztalt.h"
#include "Pracownik.h"

using namespace std;

int main()
{
  float wynik;

  Ksztalt *a = new Kwadrat(3);
  Ksztalt *b = new Prostokat(2,3);
  Ksztalt *c = new Kolo(2);

  Pracownik *d = new Sprzataczka();
  Pracownik *e = new Sekretarka();

  cout<<"------------METODY CZYSTO WIRTUALNE----------------"<<endl;
  wynik = a->Oblicz();
  cout<<"Pole kwadratu wynosi: "<<wynik<<endl;
  wynik = b->Oblicz();
  cout<<"Pole prostokata wynosi: "<<wynik<<endl;
  wynik = c->Oblicz();
  cout<<"Pole kola wynosi: "<<wynik<<endl;
  cout<<"------------METODY WIRTUALNE-----------------------"<<endl;
  d->Pracuj();
  e->Pracuj();

  return 0;

}

Przeanalizujcie to bo chcę wiedzieć, czy dobrze to zrozumiałam...rozumiem, ze jak klasy pochodne nie mają metod wykonujących dokładnie to samo to wykorzystujemy metody czysto wirtualne (w C# klasę abstrakcyjną) a jeśli tak to zwykłe wirtualne ?

wywołanie metody wirtualnej w c++

Mon, 05 Feb 2018 21:49:25 +0000

Witam,

Mam do was jedno pytanie na egzaminie z c++ mam pytanie : zaznacz zdanie prawdziwe nie moge sobie z nim poradzić. Proszę o pomoc

Wywołanie metody wirtualnej jest szybsze niż wywołanie metody niewirtualnej.	Nie ma różnicy szybkości przy wywołaniu metody wirtualnej i niewirtualnej.
Wywołanie metody wirtualnej jest wolniejsze niż wywołanie metody niewirtualnej.	Szybkość wywołania zależy od tego, czy wywołanie metody następuje przez typ podstawowy czy pochodny w hierarchii dziedziczenia.

Sortowanie kontenera (std::vector) złożonego z klas za pomocą funkcji sort() z biblioteki

Mon, 22 Aug 2016 22:02:11 +0000

Mój program dotyczący pracowników i zarobków, który wcześniej konsultowałem na forum jest na ukończeniu, jednak mam problem z posortowaniem kontenera wg "wynagrodzenia". Rozumiem zamysł użytkownika ison z tego forum, jednak u mnie sprawa się komplikuje, gdyż działam na klasie abstrakcyjnej Pracownik, z której dziedziczą trzy pozostałe klasy, zaś sam dostęp do składowych tych klas jest prywatny, a pole "wynagrodzenie" znajduje się dopiero w trzech klasach potomnych.

Czy mógłbym prosić o wytłumaczenie w jaki sposób ugryźć rozwiązanie tego problemu w moim przypadku? Byłbym również wdzięczny za inne uwagi dotyczące mojego kodu, bo może wyrobiłem sobie jakieś niepotrzebne nawyki lub podchodzę do czegoś niepoprawnie...

Kod zamieszczam poniżej oraz podświetlam istotne linijki:

//===============================================
// Nazwa          : pracownik.h
//===============================================

#ifndef PRACOWNIK_H
#define PRACOWNIK_H
#include <iostream>
#include <cstdio>
#include <string>
#define PROCENT 0.35
#define PREMIA 1.5
#define STRUMIEN 128

using namespace std;

class Pracownik
{
private:
    bool zatrudnienie;
    string imie;
    string nazwisko;
    string nip;
    string pesel;
public:
    Pracownik();
    Pracownik(string im, string nzwsk, string psl, string np);
    bool sprawdzDane(string im, string nzwsk);
    bool porownajZarobki(Pracownik& p1,Pracownik& p2);
    virtual void wyswietlDane() = 0;
    virtual void obliczZarobki() = 0;
    virtual ~Pracownik() {};
};

class Staly: public Pracownik
{
private:
    double wynagrodzenie;
public:
    Staly();
    Staly(string im, string nzwsk, string psl, string np, double wngrdzn);
    void obliczZarobki() {} // istotne
    void wyswietlDane();
    ~Staly() {};
};

class Zleceniobiorca: public Pracownik
{
private:
    double stawka;
    int godziny;
    double wynagrodzenie;
public:
    Zleceniobiorca();
    Zleceniobiorca(string im, string nzwsk, string psl, string np, double stwk, int gdzn);
    void wyswietlDane();
    void obliczZarobki();
    ~Zleceniobiorca() {}
};

class Handlujacy: public Pracownik
{
private:
    double wartosc;
    int transakcje;
    double wynagrodzenie;
public:
    Handlujacy();
    Handlujacy(string im, string nzwsk, string psl, string np, double wrtsc, int trnskcj);
    void wyswietlDane();
    void obliczZarobki();
    ~Handlujacy() {}
};

void enter();
void naglowek();
void czyszczenie();

#endif

//===============================================
// Nazwa          : pracownik.cpp
//===============================================

#include "pracownik.h"

Pracownik::Pracownik()
{
    zatrudnienie = true;
    cout << "Wprowadzanie danych nowego pracownika..." << endl;
    cout << "Imie: ";
    cin >> imie;
    cout << "Nazwisko: ";
    cin >> nazwisko;
    cout << "PESEL: ";
    cin >> pesel;
    cout << "NIP: ";
    cin >> nip;
}

Pracownik::Pracownik(string im, string nzwsk, string psl, string np)
{
    zatrudnienie = true;
    imie = im;
    nazwisko = nzwsk;
    pesel = psl;
    nip = np;
}

Staly::Staly(): Pracownik()
{
    cout << "Miesieczne wynagrodzenie: ";
    cin >> wynagrodzenie;
}

Staly::Staly(string im, string nzwsk, string psl, string np, double wngrdzn): Pracownik(im, nzwsk, psl, np)
{
    wynagrodzenie = wngrdzn;
}

Zleceniobiorca::Zleceniobiorca(): Pracownik()
{
    cout << "Godzinna stawka: ";
    cin >> stawka;
    cout << "Przepracowane godziny: ";
    cin >> godziny;
    obliczZarobki();
}

Zleceniobiorca::Zleceniobiorca(string im, string nzwsk, string psl, string np, double stwk, int gdzn): Pracownik(im, nzwsk, psl, np)
{
    stawka = stwk;
    godziny = gdzn;
    obliczZarobki();
}

Handlujacy::Handlujacy(): Pracownik()
{
    cout << "Wartosc pojedynczej transakcji: ";
    cin >> wartosc;
    cout << "Ilosc transakcji: ";
    cin >> transakcje;
    obliczZarobki();
}

Handlujacy::Handlujacy(string im, string nzwsk, string psl, string np, double wrtsc, int trnskcj): Pracownik(im, nzwsk, psl, np)
{
    wartosc = wrtsc;
    transakcje = trnskcj;
    obliczZarobki();
}

void Zleceniobiorca::obliczZarobki()
{
    if(godziny>40)
        wynagrodzenie = stawka * PREMIA;
    else
        wynagrodzenie = stawka;
}

void Handlujacy::obliczZarobki()
{
    wynagrodzenie = wartosc * transakcje * PROCENT;
}

void Pracownik::wyswietlDane()
{
    cout.width(15);
    cout << left << imie;
    cout.width(15);
    cout << left << nazwisko;
    cout.width(15);
    cout << left << pesel;
    cout.width(15);
    cout << left << nip;
}

void Staly::wyswietlDane()
{
    Pracownik::wyswietlDane();
    cout.width(15);
    cout.setf( ios::showpoint );
    cout << left << wynagrodzenie << endl;
}

void Zleceniobiorca::wyswietlDane()
{
    Pracownik::wyswietlDane();
    cout.width(15);
    cout.setf( ios::showpoint );
    cout << left << wynagrodzenie << endl;
}

void Handlujacy::wyswietlDane()
{
    Pracownik::wyswietlDane();
    cout.width(15);
    cout.setf( ios::showpoint );
    cout << left << wynagrodzenie << endl;
}

bool Pracownik::sprawdzDane(string im, string nzwsk)
{
    if(imie == im && nazwisko == nzwsk)
        return true;
    return false;
}

bool Pracownik::porownajZarobki(Pracownik& p1, Pracownik& p2)
{
    return p1.wynagrodzenie > p2.wynagrodzenie;
}

void enter()
{
    getchar();
    getchar();
}
void naglowek()
{
    cout.width(5);
    cout << left << "Lp:";
    cout.width(15);
    cout << left << "Imie:";
    cout.width(15);
    cout << left << "Nazwisko:";
    cout.width(15);
    cout << left << "PESEL:";
    cout.width(15);
    cout << left << "NIP:";
    cout.width(15);
    cout << left << "Wynagrodzenie:" << endl;
}

void czyszczenie()
{
    printf("\033[2J"); // Czysci ekran
    printf("\033[0;0f"); // Ustawia kursor w lewym, gornym rogu
}

//==================================================
// Nazwa          : main.cpp
//==================================================

#include <vector>
#include <windows.h>
#include <algorithm>
#include "pracownik.h"

int main()
{
    vector <Pracownik*> kadra;
    kadra.push_back(new Staly("Piotr","Wierchowienski","63032300373","4457301037",3300));
    kadra.push_back(new Staly("Mikolaj","Stawrogin","89102905493","7260631988",4100));
    kadra.push_back(new Zleceniobiorca("Iwan","Szatow","77082213114","6825506522",2300,50));
    kadra.push_back(new Zleceniobiorca("Aleksy","Kirillow","85052403018","5913117469",2700,35));
    kadra.push_back(new Handlujacy("Sergiusz","Liputin","67052801713","4621950579",800,14));
    kadra.push_back(new Handlujacy("Ignacy","Lebiadkin","79091902931","8442924521",850,10));
    unsigned short wybor;
    do
    {
        cout << "Zarzadzanie kadra pracownicza:" << endl;
        cout << "[1] --> Zatrudnij stalego pracownika" << endl;
        cout << "[2] --> Zatrudnij zleceniobiorce" << endl;
        cout << "[3] --> Zatrudnij handlujacego" << endl;
        cout << "[4] --> Wyswietl dane pracownika" << endl;
        cout << "[5] --> Wyswietl dane calej kadry" << endl;
        cout << "[6] --> Wyswietl liczbe pracownikow" << endl;
        cout << "[7] --> Zwolnij pracownika" << endl;
        cout << "[8] --> Zwolnij cala kadre" << endl;
        cout << "[0] --> Wyjscie" << endl;
        cout << "Twoj wybor: " << endl;
        do
        {
            cin.clear();
            cin.sync();
            cin >> wybor;
        }
        while(!cin.good());
        cout << endl;
        switch(wybor)
        {
        case 1 :
            kadra.push_back(new Staly());
            break;
        case 2 :
            kadra.push_back(new Zleceniobiorca());
            break;
        case 3 :
            kadra.push_back(new Handlujacy());
            break;
        case 4 :
        {
            if(kadra.empty())
            {
                cout << "Brak zatrudnionych pracownikow. [ENTER]" << endl;
                enter();
                break;
            }
            cout << "Wyszukiwanie pracownika na podstawie imienia i nazwiska..." << endl;
            string szukaneImie,szukaneNazwisko;
            cout << "Imie: ";
            cin >> szukaneImie;
            cout << "Nazwisko: ";
            cin >> szukaneNazwisko;
            unsigned int i;
            for(i=0; i<kadra.size(); i++)
            {
                if(kadra[i]->sprawdzDane(szukaneImie,szukaneNazwisko))
                {
                    kadra[i]->wyswietlDane();
                    cout << "Aby powrocic do menu nacisnij [ENTER]." << endl;
                    enter();
                    break;
                }
            }
            if(i==kadra.size())
            {
                cout << "Brak pracownika o takim imieniu u nazwisku. [ENTER]";
                enter();
                break;
            }
        }
        break;
        case 5 :
        {
            if(kadra.empty())
            {
                cout << "Brak zatrudnionych pracownikow. [ENTER]" << endl;
                enter();
                break;
            }
            unsigned int i;
            sort(kadra.begin(),kadra.end(),porownanie);
            naglowek();
            for(i=0; i<kadra.size(); i++)
            {
                cout.width(5);
                cout << left << i;
                kadra[i]->wyswietlDane();
            }
            cout << "Aby powrocic do menu nacisnij [ENTER]." << endl;
            enter();
        }
        break;
        case 6 :
            cout << "Liczba pracownikow: " << kadra.size() <<  ". [ENTER]" << endl;
            enter();
            break;
        case 7 :
        {
            if(kadra.empty())
            {
                cout << "Brak zatrudnionych pracownikow. [ENTER]" << endl;
                enter();
                break;
            }
            cout << "Usuwanie pracownika o podanym indeksie" << endl;
            unsigned int szukanyIndeks;
            do
            {
                cout << "Indeks:";
                cin.clear();
                cin.sync();
                cin >> szukanyIndeks;
            }
            while(szukanyIndeks>kadra.size() || !cin.good());
            kadra.erase(kadra.begin()+szukanyIndeks);
            cout << "Usunieto pracownika. Aby powrocic do menu nacisnij [ENTER]." << endl;
            enter();
        }
        break;
        case 8 :
            kadra.clear();
            cout << "Cala kadra zostala zwolniona. [ENTER]" << endl;
            enter();
            break;
        }
        system("cls");
    }
    while(wybor!=0);
    return 0;
}

Przeciążanie metod wirtualnych, a kontener tablicy (std::vector)

Fri, 19 Aug 2016 17:35:19 +0000

Bardzo proszę o wyjaśnienie błędu, co robię niepoprawnie. Piszę program w C++, który wykorzystuje zagadnienia poliformizmu, funkcji wirtualnych oraz kontenerów na temat kadry pracowniczej. Kompilował się on bez zarzutów dopóki nie zacząłem pisać funkcji wirtualnych...

Komunikat od kompilatora:

||=== Build: Debug in ehh (compiler: GNU GCC Compiler) ===|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\bits\stl_vector.h||In instantiation of 'class std::vector<Pracownik>':|
D:\00 Kody\ehh\main.cpp|13|required from here|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\bits\stl_vector.h|713|error: invalid abstract parameter type 'Pracownik'|
D:\00 Kody\ehh\pracownik.h|17|note:   because the following virtual functions are pure within 'Pracownik':|
D:\00 Kody\ehh\pracownik.h|30|note:     virtual void Pracownik::obliczZarobki()|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\bits\vector.tcc||In instantiation of 'void std::vector<_Tp, _Alloc>::_M_insert_aux(std::vector<_Tp, _Alloc>::iterator, const _Tp&) [with _Tp = Pracownik; _Alloc = std::allocator<Pracownik>; std::vector<_Tp, _Alloc>::iterator = __gnu_cxx::__normal_iterator<Pracownik*, std::vector<Pracownik> >; typename std::_Vector_base<_Tp, _Alloc>::pointer = Pracownik*]':|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\bits\stl_vector.h|925|required from 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = Pracownik; _Alloc = std::allocator<Pracownik>; std::vector<_Tp, _Alloc>::value_type = Pracownik]'|
D:\00 Kody\ehh\main.cpp|14|required from here|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\bits\vector.tcc|337|error: cannot allocate an object of abstract type 'Pracownik'|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\bits\vector.tcc|337|error: cannot declare variable '__x_copy' to be of abstract type 'Pracownik'|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\ext\new_allocator.h||In instantiation of 'void __gnu_cxx::new_allocator<_Tp>::construct(__gnu_cxx::new_allocator<_Tp>::pointer, const _Tp&) [with _Tp = Pracownik; __gnu_cxx::new_allocator<_Tp>::pointer = Pracownik*]':|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\ext\alloc_traits.h|189|required from 'static void __gnu_cxx::__alloc_traits<_Alloc>::construct(_Alloc&, __gnu_cxx::__alloc_traits<_Alloc>::pointer, const _Tp&) [with _Tp = Pracownik; _Alloc = std::allocator<Pracownik>; __gnu_cxx::__alloc_traits<_Alloc>::pointer = Pracownik*]'|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\bits\stl_vector.h|918|required from 'void std::vector<_Tp, _Alloc>::push_back(const value_type&) [with _Tp = Pracownik; _Alloc = std::allocator<Pracownik>; std::vector<_Tp, _Alloc>::value_type = Pracownik]'|
D:\00 Kody\ehh\main.cpp|14|required from here|
c:\mingw\lib\gcc\mingw32\4.9.3\include\c++\ext\new_allocator.h|130|error: invalid new-expression of abstract class type 'Pracownik'|
||=== Build failed: 4 error(s), 9 warning(s) (0 minute(s), 0 second(s)) ===|

Natomiast kod udostępniłem poniżej:

//=======================================
// Nazwa  : pracownik.h
//=======================================

#ifndef PRACOWNIK_H
#define PRACOWNIK_H
#include <iostream>
#include <cstdio>
#include <string>
#define PROCENT 1.5

using namespace std;

class Pracownik
{
private:
    bool zatrudnienie;
    string imie;
    string nazwisko;
    string pesel;
    string nip;
public:
    Pracownik();
    Pracownik(string im, string nzwsk, string psl, string np);
    //void zmianaZatrudnienia(Pracownik prcwnk);
    //virtual void wyswietlDane() = 0;
    virtual void obliczZarobki() = 0;
    virtual ~Pracownik() {};
    // jest to jednoczesnie implementacja
    // zastanowić się gdyby nie było destruktora
};

class Staly: public Pracownik
{
private:
    double wynagrodzenie;
public:
    Staly();
    Staly(string im, string nzwsk, string psl, string np, double wngrdzn);
    void obliczZarobki() {} //musi być kurcze
    //void wyswietlDane(); // const
    ~Staly() {};
};

class Zleceniobiorca: public Pracownik
{
private:
    double stawka;
    int godziny;
    double wynagrodzenie;
public:
    Zleceniobiorca();
    Zleceniobiorca(string im, string nzwsk, string psl, string np, double stwk, int gdzn);
    //void wyswietlDane(); // const
    void obliczZarobki();
    ~Zleceniobiorca() {}
};

class Handlujacy: public Pracownik
{
private:
    double wartosc;
    int transakcje;
    double wynagrodzenie;
public:
    Handlujacy();
    Handlujacy(string im, string nzwsk, string psl, string np, double wrtsc, int trnskcj);
    //void wyswietlDane(); // const
    void obliczZarobki();
    ~Handlujacy() {}
};

void czyszczenie();
#endif

//=======================================
// Nazwa  : pracownik.cpp
//=======================================

#include "pracownik.h"

Pracownik::Pracownik()
{
    cout << "Wprowadzanie danych nowego pracownika..." << endl;
    cout << "Imie: ";
    cin >> imie;
    cout << "Nazwisko: ";
    cin >> nazwisko;
    cout << "Pesel: ";
    cin >> pesel;
    cout << "Numer identyfikacji podatkowej: ";
    cin >> nip;
}

Pracownik::Pracownik(string im, string nzwsk, string psl, string np)
{
    zatrudnienie = true;
    imie = im;
    nazwisko = nzwsk;
    pesel = psl;
    nip = np;
}

Staly::Staly(): Pracownik()
{
    cout << "Miesieczne wynagrodzenie: ";
    cin >> wynagrodzenie;
}

Staly::Staly(string im, string nzwsk, string psl, string np, double wngrdzn): Pracownik(im, nzwsk, psl, np)
{
    wynagrodzenie = wngrdzn;
}

Zleceniobiorca::Zleceniobiorca(): Pracownik()
{
    cout << "Godzinna stawka: ";
    cin >> stawka;
    cout << "Przepracowane godziny: ";
    cin >> godziny;
}

Zleceniobiorca::Zleceniobiorca(string im, string nzwsk, string psl, string np, double stwk, int gdzn): Pracownik(im, nzwsk, psl, np)
{
    stawka = stwk;
    godziny = gdzn;
}

Handlujacy::Handlujacy(): Pracownik()
{
    cout << "Wartosc pojedynczej transakcji: ";
    cin >> wartosc;
    cout << "Ilosc transakcji: ";
    cin >> transakcje;
}

Handlujacy::Handlujacy(string im, string nzwsk, string psl, string np, double wrtsc, int trnskcj): Pracownik(im, nzwsk, psl, np)
{
    wartosc = wrtsc;
    transakcje = trnskcj;
}

void Zleceniobiorca::obliczZarobki()
{

}

void Handlujacy::obliczZarobki()
{

}

void czyszczenie()
{
    printf("\033[2J"); // Czyści ekran
    printf("\033[0;0f"); // Ustawia kursor w lewym, górnym rogu
}

//=======================================
// Nazwa  : main.cpp
//=======================================

#include <vector>
#include "pracownik.h"

int main()
{
    vector <Pracownik> baza;
    baza.push_back(Staly("Piotr","Wierchowieński","63032300373","4457301037",3300));
    baza.push_back(Staly("Mikołaj","Stawrogin","89102905493","7260631988",4100));
    baza.push_back(Zleceniobiorca("Iwan","Szatow","77082213114","6825506522",2300,40));
    baza.push_back(Zleceniobiorca("Aleksy","Kiriłłow","85052403018","5913117469",2700,25));
    baza.push_back(Handlujacy("Sergiusz","Liputin","67052801713","4621950579",560,14));
    baza.push_back(Handlujacy("Ignacy","Lebiadkin","79091902931","8442924521",770,10));
    int wybor;
    do
    {
        cout << "Edycja kadry pracowniczej:" << endl;
        cout << "[1] --> Dodaj stalego pracownika na koncu danych" << endl;
        cout << "[2] --> Dodaj zleceniobiorce na koncu danych" << endl;
        cout << "[3] --> Dodaj handulajcego na koncu danych" << endl;
        cout << "[4] --> Zmien stan zatrudnienia pracownika" << endl; // zastanowi  si
        cout << "[5] --> Usun pracownika z kadry" << endl;
        cout << "[6] --> Usun cala kadre" << endl;
        cout << "[0] --> Wyjscie" << endl;
        cout << "Twoj wybor: " << endl;
        do
        {
            cin.clear();
            cin.sync();
            cin >> wybor;
        }
        while(!cin.good());
        switch(wybor)
        {
        case 1 :
            baza.push_back(Staly());
            break;
        case 2 :
            baza.push_back(Zleceniobiorca());
            break;
        case 3 :
            baza.push_back(Handlujacy());
            break;
        case 4 :
            break;
        case 5 :
            break;
        case 6 :
            break;
        }
    }
    while(wybor!=0);
    return 0;
}

Fukncje wirtualne - Polimorfizm - w C++ Builderze (przykład)

Thu, 05 May 2016 19:14:30 +0000

Witam,

Proszę o przykład stworzenia klas 1 abstrakcyjnej i 3 które z niej dziedziczą, coś na zasadzie tego przykładu z konsoli class Ksztalt i dziedziczne klasy: Kolo, Kwadrat, Trojkat (tyle że w C++ Builderze), ktore wstawiaja powiedzny obrazek w jedno pole Image w zaleznosci od tego jaka forme wybierzemy: kolo, kwadrat czy trójkąt. I przyklad wywolania tej funcji wstaw() z klasy np po nacisnieciu przycisku.

pozdrawiam.

Metoda wirtualna zwracająca różne typy

Sun, 03 May 2015 21:20:54 +0000

Witajcie Koledzy!

Mam taki oto problem. Mam dwie klasy bazowe Line i Circle a z każdej dziedziczą po 4 klasy pochodne. Tworzę listę składającą się ze wskaźników na klasy bazowe i następny element listy. W zależności od wyborów użytkownika w danym elemencie listy tworzy się odpowiednio obiekt klasy pochodnej. Chce teraz wydrukować dane, które zawierają obiekty. I tu się rodzi problem. Potrzebuje wyciągnąć atrybuty private z każdej klasy pochodnej, czyli strukturę. W każdej klasie jest inna.

I tu się rodzi moje pytanie. Jak to zrobić? Może utworzyć metody wirtualne, ale tu za każdym razem będzie zwracany inny typ. Może utworzyć metodę typu void, która będzie modyfikowała dane w kontenerze i dopiero z tego kontenera wyrzucać dane na ekran.

Proszę o podpowiedzi i dzięki! :)