Discussion :

[rXpCH]

Bonjour,

J'ai créé une classe MySprite qui contient toutes les informations sur un sprite et je veux ensuite dériver mes sprites de cette classe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#ifndef MYSPRITE_H
#define MYSPRITE_H
 
#include <windows.h>
#include <sstream>
#include <string>
#include <vector>
#include <d3d9.h>
#include <d3dx9.h>
#include <time.h>
#include <fcntl.h>
#include <io.h> 
#include <iostream>
using namespace std;
 
#pragma once
 
#pragma comment(lib,"d3d9.lib")
#pragma comment(lib,"d3dx9.lib")
 
	/* structures */
	struct STRUCT_Location
	{
		float x,y;
	};
 
	struct STRUCT_Velocity
	{
		float velX, velY;
	};
 
	struct STRUCT_Size
	{
		int width, height;
	};
 
 
class MySprite
{
 
public:
	MySprite();
	MySprite(bool alive, string name, int width, int height, LPDIRECT3DTEXTURE9 texture, int startFrame = 0, int endFrame = 0, int columns = 1, int delay = 10, int direction = 0);
	virtual void reset();
	void animate();
 
	STRUCT_Location getLocation();
	D3DXVECTOR2 getLocationVector2();
	virtual void setLocation(float x,float y);
	virtual void move(float x,float y);
 
	bool isAlive();
	void setAlive(bool alive);
 
	STRUCT_Velocity getVelocity();
	virtual void setVelocity(float velX, float velY);
	virtual void changeVelocity(float velX, float velY);
 
	float getScaling();
	virtual void setScaling(float scaling);
	virtual void changeScaling(float scaling);
 
	float getRotation();
	virtual void setRotation(float angle);
	virtual void changeRotation(float angle);
 
	STRUCT_Location getCenter();
	D3DXVECTOR2 getCenterVector2();
	virtual void setCenter(float x, float y);
 
	STRUCT_Size getSize();
 
	int getCurrentFrame();
	void setCurrentFrame(int i);
 
	int getStartFrame();
	void setStartFrame(int i);
 
	int getEndFrame();
	void setEndFrame(int i);
 
	int getStartTime();
	void setStartTime(int start);
 
	int getDelay();
	void setDelay(int delay);
 
	int getDirection();
	void setDirection(int direction);
 
	int getColumns();
	void setColumns(int columns);
 
	D3DCOLOR getColor();
	void setColor(D3DCOLOR color);
 
	void getTexture(LPDIRECT3DTEXTURE9* texture);
	void setTexture(LPDIRECT3DTEXTURE9* texture);
 
	virtual ~MySprite(void);
 
protected:
	double toRadians(double degrees);
	double toDegrees(double radians);
 
	bool m_alive;
	string m_name;
	STRUCT_Location m_location;
	STRUCT_Location m_center;
	float m_scaling, m_rotation;
	STRUCT_Velocity m_velocity;
	STRUCT_Size m_size;
	int m_currentFrame, m_startFrame, m_endFrame;
	int m_startTime, m_delay, m_direction, m_columns;
	D3DCOLOR m_color;
	LPDIRECT3DTEXTURE9 m_texture;
 
};
 
#endif

Donc avec cela je crée un vrai sprite, disons Bomb :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#pragma once
#include "mysprite.h"
class Bomb :
	protected MySprite
{
 
 
public:
	Bomb(bool alive, string name, int width, int height, LPDIRECT3DTEXTURE9 texture, int startFrame = 0, int endFrame = 0, int columns = 1, int delay = 10, int direction = 0);
	void reset();
 
	~Bomb(void);
 
private:
 
};

Mais quand je crée mon objet Bomb et que je veux utiliser la fonction isAlive, le compilateur me dit que ce n'est pas possible car Bomb hérite en protected et pas en public...

Est-ce possible d'hériter des protected et des public ?

Cordialement,

rXp>!<

[salseropom]

quelle plus-value auras-tu à dériver en protected plutôt qu'en public ?

[rXpCH]

quelle plus-value auras-tu à dériver en protected plutôt qu'en public ?

Pour avoir accès au fonction protected et aux variables.

[koala01]

Salut,

De manière générale, on peut estimer que ta classe Bomb sera malgré tout... un sprite, et qu'il y a de fortes chances pour que les différentes instances de Bomb soient, pour une bonne partie en tout cas géré avec d'autres sprites de types différents (en gros, pour tout ce qui est commun au différents sprites ).

Dés lors, il semble cohérent de se dire que ce n'est pas un héritage protégé qu'il te faut (je n'ai encore jamais trouvé un cas dans lequel il s'avère utile, même si je sais que certains l'ont déjà utilisé ) mais bel et bien un héritage public.

Il faut en effet comprendre que, pour ce qui concerne l'héritage, l'accessiblité des membres et fonctions de la classe de base ne sera jamais suppérieure à l'accessibilité définie pour l'héritage.

Ainsi, pour qu'une fonction publique dans la classe de base soit accessible depuis "n'importe où" dans la classe dérivée, il faut impérativement que l'héritage soit public.

Dans le même ordre d'idée, si tu pars sur le principe d'un héritage protégé (privé), les fonctions publiques de la classe de base ne seront que protégées (respectivement privées) dans la classe dérivée, avec tout ce que cela comporte.

[rXpCH]

Et pour les variables qui sont sous protected, je dois les passer en public ? Mais après il sera possible de modifier la variable sans passer par les fonctions non ?

[koala01]

Et pour les variables qui sont sous protected, je dois les passer en public ? Mais après il sera possible de modifier la variable sans passer par les fonctions non ?

Tu les laisse bien protected, voire, même, tu les passe en private...

Comprend moi: les principes de base de l'accessibilité sont :

Tout ce qui est privé dans la classe de base ne sera accessible que depuis les fonctions de la classe de base (quelle qu'en soit l'accessibilité): si seules les fonctions de la classe de base doivent accéder aux membres, autant que ces derniers restent privé

Tout ce qui est protégé dans la classe de base est non seulement accessible depuis la classe de base, mais également depuis les classes qui en dérivent de manière directe ou indirecte

Tout ce qui est publique dans la classe de base sera enfin accessible depuis "n'importe où" dans ton projet.

Lorsque tu défini un héritage entre une classe de base et une classe dérivée, c'est à dire sous la forme d'un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
class Derivee : <accessibilité> Base
{
};

(ou <accessibilité> est soit "public", soit "protected", soit "private"), tu obtiens obtient l'une des 9 possibilités suivantes:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/*
accessibilité : accessibilité du (de la fonction) membre de la classe 
                de base
héritage      : accessibilité définie pour l'héritage
résultat      : accessibilité du (de la fonction) membre obtenue au niveau
                de la classe dérivée
*/
accessibilité | héritage  | résultat
=========================================
public        | public    | public
protected     | public    | protected
private       | public    | inaccessible
public        | protected | protected
protected     | protected | protected
private       | protected | inaccessible
public        | private   | private
protected     | private   | private
private       | private   | inaccessible