Dziedziczenie prywatne C++

Question

Witam 

Mam problem... właśnie nie wiem jaki :P

class1.h

#ifndef NAGLOWEK_H_
#define NAGLOWEK_H_

class Gra
{
private:
    std::string name;
public:
	Gra();
	Gra(std::string n);
	~Gra(){std::cout<<"Usunieto Obiekt"<<std::endl;}
	virtual void Pokaz();
};

class Gracz : private std::string 
{
private:
	int ration;
public:
    Gracz(){};
	explicit Gracz(std::string &n,int r) : std::string(n) {ration=r;}
	void Gracz::Pokaz();
};

#endif // 

Źrodło.cpp

#include <iostream>
#include <string>
#include "class1.h"

using namespace std;

// class Gra

Gra::Gra(){}

Gra::Gra(std::string n)
{
	name=n;
}

void Gra::Pokaz()
{
	cout<<"Nazwa gracza: "<<name<<endl;
}


//class Gracz

void Gracz::Pokaz()
{
	return *this;
}

main.cpp

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

using namespace std;

int main()
{
    Gra gracz1("ANONYMUS");
    gracz1.Pokaz();
    
	Gracz gracz2("LEL",100);
	gracz2.Pokaz();

	getchar();
	return 0;
}

 

 

Za wszelką pomoc Dziękuję ;) 

Answer 1

Poczytaj o dziedziczeniu prywatnym i czym się różni od zawierania, bo to dosyć szeroki temat i inne techniki się stosuje. Poprawiony kod:

main.cpp

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

using namespace std;

int main() {
	Gra gracz1("ANONYMUS");
	gracz1.Pokaz();

	Gracz gracz2("WOW", 100);
	gracz2.Pokaz();

	getchar();
	return 0;
}

class1.h

#ifndef NAGLOWEK_H_
#define NAGLOWEK_H_
#include <iostream>
#include <string>
using namespace std;

class Gra
{
private:
	string name;
public:
	Gra() {}
	Gra(string n) : name(n) {}
	~Gra() { cout << "Usunieto Obiekt" << endl; }
	void Pokaz() {
		cout << "Nazwa gracza: " << name << endl;
	}
};

class Gracz : private std::string
{
private:
	int ration;
public:
	Gracz() {};
	Gracz(const string &n, const int r) : string(n), ration(r) {}
	void Gracz::Pokaz() {
		cout << "Ration gracza: " << ration << endl;
	}
};

#endif

 

Comments

Ok udało się wielkie dzięki ;)

Jeszcze tego do końca nie rozumiem dlatego zapewne popełniłem dużo "banalnych" błędów i przepraszam za niedokładne wyjaśnienia mojego problemu.

Answer 2

Chwila... dlaczego chcesz dziedziczyć po std::string? I to jeszcze prywatnie? Kontenery STL nie są napisane z myślą o byciu klasami bazowymi.

Zastanawia mnie też co miałeś na myśli poprzez tą linijke wewnątrz klasy Gracz:

std::string Gra::Pokaz();

Najpierw pozbądź sie tego dziedziczenia,a potem pomyślimy, bo póki co ten kod to kompletny chaos :P

Comments

Criss, czyż nie jest tak, że można stosować dwie metody: albo zawieranie albo dziedziczenie prywatne? Każde z nich ma swoje plusy i minusy.

---

Metody na co? Tutaj w sumie nawet nie wiem jaki był cel.

---

Zdziwiłeś się, że Programeł dziedziczy po klasie String. Więc mówię, że można. Jest to przykład relacji ma-coś i jest to poprawne.

---

Poprawne jest, tylko nie widze sensu. Tzn. chyba już rozumiem o co chodzi, ale nadal wydaje mi się to dziwne. Może ktoś tu jeszcze wpadnie (albo ty, Evelek, rozwiniesz myśl o plusach i minusach) i się wypowie na ten temat, ale ja w życiu nie widziałem czegoś takiego i szczerze mówiąc nie wiem po co coś takiego.

@Programeł - chyba przy edycji swojego posta usunąłeś treści błędów. W każdym razie - Źródło.cpp, linia 26: zwracasz z metody z zadeklarowanym typem zwracanym void.

Domyślam się, że chciałeś zrobić coś takiego (chociaż nie jestem pewien, bo ten return jest troche mylący):

void Gracz::Pokaz()
{
    std::cout << static_cast<std::string>(*this) /*static_cast chyba nie jest konieczny w tym przypadku */ << '\n';
}

Tylko, że jako że dziedziczysz prywatnie, to std::string jest "prywatnym rodzicem" (private base brzmi lepiej :D) i wszelkie konwersje (operatorami rzutowania czy choćby copy ctorem) są niemożliwe.

---

O plusach i minusach... A więc tak. Zawieranie jest na pewno łatwiejsze do zrozumienia i umożliwia nam umieszczenie więcej niż jednego podobiektu tej samej klasy, czyli możemy mieć w składowych takiej klasy np. 5 obiektów klasy string. W porównaniu do dziedziczenia prywatnego możemy korzystać tylko i wyłącznie z jednego takiego obiektu, ponieważ w dziedziczeniu prywatnym obiekty te nie mają nazw. A teraz cytat:

Jednak dziedziczenie prywatne ma pewne właściwości, których nie ma zawieranie. Załóżmy, że w klasie znajdują się składowe chronione, które mogą być danymi lub funkcjami. Takie składowe są dostępne w klasie pochodnej, ale nie dla obiektów zewnętrznych. Jeśli umieścimy taką klasę w innej za pomocą zawierania, nowa klasa nie jest traktowana jak klasa pochodna, ale jak zewnętrzna. Dlatego nowa klasa nie ma dostępu do składowych chronionych. Używanie dziedziczenia czyni z nowej klasy klasę pochodną, która dzięki temu ma dostęp do składowych chronionych.

Są też pewne różnice w zwracaniu z funkcji takich obiektów:

const string & Klasa::funkcja() const {
	return (const string &) *this;
}

 

---

No tak, to dość oczywiste - o to chodzi w dostępie chronionym. Ale nie widzę powodu dla którego mielibyśmy mieć dostęp do składowych chronionych stringa (tym bardziej, że najpewniej w ogóle takich nie ma, bo, jak mówiłem, std::string nie było pisane z myślą o byciu klasą bazową).

---

Cytat ten jak i cały komentarz odnosi się raczej do ogólnych pojęć, jakim są dziedziczenie prywatne oraz zawieranie - nie precyzuje tu konkretnej klasy, a klasę string wymieniam jeden raz jako przykład.