J'essaie de faire un programme qui fait une capture d'écran sur un
poste, et affiche cette capture sur un autre poste (un peu comme VNC).
J'ai donc une classe Bitmap, qui sert à deux choses :
- sur le premier poste, elle effectue la capture d'écran, et
envoie les données
- sur le second poste, elle récupère les données, puis affiche
l'image à l'écran
class Bitmap
{
public :
// fonctions générales
Bitmap();
int NbOctetsParLigne();
// fonctions spécifiques au 1er poste
void CaptureEcran (Ecran*);
void EnvoieDonnees (SOCKET);
// fonctions spécifiques au 2è poste
void RecupereDonnees (SOCKET);
void AfficheBitmap (Ecran*);
private:
// Données privées, communes
};
Et là j'hésite : dois-je laisser ma classe comme ça, ou serait-il
mieux que je fasse une classe de base, plus deux classes dérivées
Bitmap_reception (contenant "RecupereDonnees()" et "AfficheBitmap()")
et Bitmap_envoi (contenant "CaptureEcran()" et "EnvoieDonnees()") ?
Ça empêcherait qu'on appelle EnvoieDonnees() sur un objet prévu pour
la réception, mais le jeu en vaut-il la chandelle ?
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
<snip>
Et là j'hésite : dois-je laisser ma classe comme ça, ou serait-il mieux que je fasse une classe de base, plus deux classes dérivées Bitmap_reception (contenant "RecupereDonnees()" et "AfficheBitmap()") et Bitmap_envoi (contenant "CaptureEcran()" et "EnvoieDonnees()") ? Ça empêcherait qu'on appelle EnvoieDonnees() sur un objet prévu pour la réception, mais le jeu en vaut-il la chandelle ?
Ça me rappelle l'exemple de Stroustrup (je crois) avec les pingouins qui héritaient de la classe oiseau, mais qui affichaient une erreur quand on voulait les faire voler. Quelque chose comme "It's ok for them to fly, but they can't."
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes? amha, il n'y a aucun héritage ici. Mais je me plante peut-être.
Jonathan
J'ai donc une classe Bitmap, qui sert à deux choses :
- sur le premier poste, elle effectue la capture d'écran, et
envoie les données
- sur le second poste, elle récupère les données, puis affiche
l'image à l'écran
<snip>
Et là j'hésite : dois-je laisser ma classe comme ça, ou serait-il
mieux que je fasse une classe de base, plus deux classes dérivées
Bitmap_reception (contenant "RecupereDonnees()" et "AfficheBitmap()")
et Bitmap_envoi (contenant "CaptureEcran()" et "EnvoieDonnees()") ?
Ça empêcherait qu'on appelle EnvoieDonnees() sur un objet prévu pour
la réception, mais le jeu en vaut-il la chandelle ?
Ça me rappelle l'exemple de Stroustrup (je crois) avec les pingouins
qui héritaient de la classe oiseau, mais qui affichaient une erreur
quand on voulait les faire voler. Quelque chose comme "It's ok for
them to fly, but they can't."
Mais pourquoi ne pas faire deux classes séparées si elles font des
choses différentes? amha, il n'y a aucun héritage ici. Mais je
me plante peut-être.
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
<snip>
Et là j'hésite : dois-je laisser ma classe comme ça, ou serait-il mieux que je fasse une classe de base, plus deux classes dérivées Bitmap_reception (contenant "RecupereDonnees()" et "AfficheBitmap()") et Bitmap_envoi (contenant "CaptureEcran()" et "EnvoieDonnees()") ? Ça empêcherait qu'on appelle EnvoieDonnees() sur un objet prévu pour la réception, mais le jeu en vaut-il la chandelle ?
Ça me rappelle l'exemple de Stroustrup (je crois) avec les pingouins qui héritaient de la classe oiseau, mais qui affichaient une erreur quand on voulait les faire voler. Quelque chose comme "It's ok for them to fly, but they can't."
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes? amha, il n'y a aucun héritage ici. Mais je me plante peut-être.
Jonathan
Jonathan Mcdougall
"It's ok for them to fly, but they can't."
Un bon coup de pied à l'endroit adéquat, et tu verras qu'ils sont capables de voler. Et vu le climat, on retrouve le "How to freeze your own foot" ;-)
:)
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes?
Les variables, et quelques fonctions, sont communes. En fait les deux sont des bitmaps, i.e. des classes qui stockent une image pour faire la liaison entre l'écran et le réseau.
Je ne suis pas sur de comprendre l'utilité même de la classe, mais je crois qu'une bonne approche serait que la représentation soit dans une classe à part avec des fonctions statiques qui y sont liées (s'il y en a).
Tes deux classes (Save et Load) devraient contenir une instance chacune de cette représentation.
Si tu as encore des fonctions communes, fait une autre classe (quelque chose comme BitmapOperations) pour ces deux et fait les hériter privatement ou même, met les statiques ou freestanding.
Jonathan
"It's ok for
them to fly, but they can't."
Un bon coup de pied à l'endroit adéquat, et tu verras qu'ils sont
capables de voler. Et vu le climat, on retrouve le "How to freeze your
own foot" ;-)
:)
Mais pourquoi ne pas faire deux classes séparées si elles font des
choses différentes?
Les variables, et quelques fonctions, sont communes.
En fait les deux sont des bitmaps, i.e. des classes qui stockent une
image pour faire la liaison entre l'écran et le réseau.
Je ne suis pas sur de comprendre l'utilité même de la classe, mais
je crois qu'une bonne approche serait que la représentation soit
dans une classe à part avec des fonctions statiques qui y sont
liées (s'il y en a).
Tes deux classes (Save et Load) devraient contenir une instance
chacune de cette représentation.
Si tu as encore des fonctions communes, fait une autre classe
(quelque chose comme BitmapOperations) pour ces deux et fait les
hériter privatement ou même, met les statiques ou freestanding.
Un bon coup de pied à l'endroit adéquat, et tu verras qu'ils sont capables de voler. Et vu le climat, on retrouve le "How to freeze your own foot" ;-)
:)
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes?
Les variables, et quelques fonctions, sont communes. En fait les deux sont des bitmaps, i.e. des classes qui stockent une image pour faire la liaison entre l'écran et le réseau.
Je ne suis pas sur de comprendre l'utilité même de la classe, mais je crois qu'une bonne approche serait que la représentation soit dans une classe à part avec des fonctions statiques qui y sont liées (s'il y en a).
Tes deux classes (Save et Load) devraient contenir une instance chacune de cette représentation.
Si tu as encore des fonctions communes, fait une autre classe (quelque chose comme BitmapOperations) pour ces deux et fait les hériter privatement ou même, met les statiques ou freestanding.
Jonathan
Fabien LE LEZ
On Mon, 6 Oct 2003 20:40:24 -0400, "Jonathan Mcdougall" wrote:
"It's ok for them to fly, but they can't."
Un bon coup de pied à l'endroit adéquat, et tu verras qu'ils sont capables de voler. Et vu le climat, on retrouve le "How to freeze your own foot" ;-)
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes?
Les variables, et quelques fonctions, sont communes. En fait les deux sont des bitmaps, i.e. des classes qui stockent une image pour faire la liaison entre l'écran et le réseau.
On Mon, 6 Oct 2003 20:40:24 -0400, "Jonathan Mcdougall"
<jonathanmcdougall@DELyahoo.ca> wrote:
"It's ok for
them to fly, but they can't."
Un bon coup de pied à l'endroit adéquat, et tu verras qu'ils sont
capables de voler. Et vu le climat, on retrouve le "How to freeze your
own foot" ;-)
Mais pourquoi ne pas faire deux classes séparées si elles font des
choses différentes?
Les variables, et quelques fonctions, sont communes.
En fait les deux sont des bitmaps, i.e. des classes qui stockent une
image pour faire la liaison entre l'écran et le réseau.
On Mon, 6 Oct 2003 20:40:24 -0400, "Jonathan Mcdougall" wrote:
"It's ok for them to fly, but they can't."
Un bon coup de pied à l'endroit adéquat, et tu verras qu'ils sont capables de voler. Et vu le climat, on retrouve le "How to freeze your own foot" ;-)
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes?
Les variables, et quelques fonctions, sont communes. En fait les deux sont des bitmaps, i.e. des classes qui stockent une image pour faire la liaison entre l'écran et le réseau.
"They can fly, but it is an error for them to do so"
Jonathan
Loïc Joly
Fabien LE LEZ wrote:
On Mon, 6 Oct 2003 20:40:24 -0400, "Jonathan Mcdougall" wrote:
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes?
Les variables, et quelques fonctions, sont communes. En fait les deux sont des bitmaps, i.e. des classes qui stockent une image pour faire la liaison entre l'écran et le réseau.
En ce cas là, pourquoi pas deux classes distincte (l'une BitmapClient, l'autre BitmapServer) qui utilisent toutes deux une variable Bitmap dans leur implémentation ?
-- Loïc
Fabien LE LEZ wrote:
On Mon, 6 Oct 2003 20:40:24 -0400, "Jonathan Mcdougall"
<jonathanmcdougall@DELyahoo.ca> wrote:
Mais pourquoi ne pas faire deux classes séparées si elles font des
choses différentes?
Les variables, et quelques fonctions, sont communes.
En fait les deux sont des bitmaps, i.e. des classes qui stockent une
image pour faire la liaison entre l'écran et le réseau.
En ce cas là, pourquoi pas deux classes distincte (l'une BitmapClient,
l'autre BitmapServer) qui utilisent toutes deux une variable Bitmap dans
leur implémentation ?
On Mon, 6 Oct 2003 20:40:24 -0400, "Jonathan Mcdougall" wrote:
Mais pourquoi ne pas faire deux classes séparées si elles font des choses différentes?
Les variables, et quelques fonctions, sont communes. En fait les deux sont des bitmaps, i.e. des classes qui stockent une image pour faire la liaison entre l'écran et le réseau.
En ce cas là, pourquoi pas deux classes distincte (l'une BitmapClient, l'autre BitmapServer) qui utilisent toutes deux une variable Bitmap dans leur implémentation ?
-- Loïc
David Brabant
"Fabien LE LEZ" wrote
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
Tu ne penses pas que l'envoi et la réception du bitmap devrait faire l'objet d'une (ou deux) classe(s) séparée(s) offrant ces services, classe(s) utilisée(s) (composition) par Bitmap? C'est ce que je ferais personnellement plutôt que d'avoir recours à l'héritage.
-- David
"Fabien LE LEZ" <gramster@gramster.com> wrote
J'ai donc une classe Bitmap, qui sert à deux choses :
- sur le premier poste, elle effectue la capture d'écran, et
envoie les données
- sur le second poste, elle récupère les données, puis affiche
l'image à l'écran
Tu ne penses pas que l'envoi et la réception du bitmap
devrait faire l'objet d'une (ou deux) classe(s) séparée(s)
offrant ces services, classe(s) utilisée(s) (composition)
par Bitmap? C'est ce que je ferais personnellement plutôt
que d'avoir recours à l'héritage.
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
Tu ne penses pas que l'envoi et la réception du bitmap devrait faire l'objet d'une (ou deux) classe(s) séparée(s) offrant ces services, classe(s) utilisée(s) (composition) par Bitmap? C'est ce que je ferais personnellement plutôt que d'avoir recours à l'héritage.
-- David
Marc Boyer
Fabien LE LEZ wrote:
Bonjour,
J'essaie de faire un programme qui fait une capture d'écran sur un poste, et affiche cette capture sur un autre poste (un peu comme VNC).
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
Je crois qu'il faudrait surtout une délégation (si c'est bien le mot). Tu as 3 objets, un Bitmap, un Captureur et un Afficheur. Captureur a un champ Bitmap, et Afficheur a surement un champ /const/ Bitmap.
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
Fabien LE LEZ wrote:
Bonjour,
J'essaie de faire un programme qui fait une capture d'écran sur un
poste, et affiche cette capture sur un autre poste (un peu comme VNC).
J'ai donc une classe Bitmap, qui sert à deux choses :
- sur le premier poste, elle effectue la capture d'écran, et
envoie les données
- sur le second poste, elle récupère les données, puis affiche
l'image à l'écran
Je crois qu'il faudrait surtout une délégation (si c'est bien le mot).
Tu as 3 objets, un Bitmap, un Captureur et un Afficheur.
Captureur a un champ Bitmap, et Afficheur a surement
un champ /const/ Bitmap.
Marc Boyer
--
Lying for having sex or lying for making war? Trust US presidents :-(
J'essaie de faire un programme qui fait une capture d'écran sur un poste, et affiche cette capture sur un autre poste (un peu comme VNC).
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
Je crois qu'il faudrait surtout une délégation (si c'est bien le mot). Tu as 3 objets, un Bitmap, un Captureur et un Afficheur. Captureur a un champ Bitmap, et Afficheur a surement un champ /const/ Bitmap.
Marc Boyer -- Lying for having sex or lying for making war? Trust US presidents :-(
Frédéri MIAILLE
"Fabien LE LEZ" a écrit dans le message de news:
Bonjour,
J'essaie de faire un programme qui fait une capture d'écran sur un poste, et affiche cette capture sur un autre poste (un peu comme VNC).
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
class Bitmap { public :
// fonctions générales Bitmap(); int NbOctetsParLigne();
// fonctions spécifiques au 1er poste void CaptureEcran (Ecran*); void EnvoieDonnees (SOCKET);
// fonctions spécifiques au 2è poste void RecupereDonnees (SOCKET); void AfficheBitmap (Ecran*);
private: // Données privées, communes };
Et là j'hésite : dois-je laisser ma classe comme ça, ou serait-il mieux que je fasse une classe de base, plus deux classes dérivées Bitmap_reception (contenant "RecupereDonnees()" et "AfficheBitmap()") et Bitmap_envoi (contenant "CaptureEcran()" et "EnvoieDonnees()") ? Ça empêcherait qu'on appelle EnvoieDonnees() sur un objet prévu pour la réception, mais le jeu en vaut-il la chandelle ? Oui car l'utilisateur de ta classe lui est une personne en laquelle tu ne
peux pas avoir confiance. Autre chose, "AfficheBitmap (Ecran*);" est une fonction que l'utilisateur va certainement appeler sans avoir appelé préalablement "RecupereDonnees(SOCKET);".
"Fabien LE LEZ" <gramster@gramster.com> a écrit dans le message de
news:ig24ov04c4fqckj4ra32o7hjq2hsqclg6e@4ax.com...
Bonjour,
J'essaie de faire un programme qui fait une capture d'écran sur un
poste, et affiche cette capture sur un autre poste (un peu comme VNC).
J'ai donc une classe Bitmap, qui sert à deux choses :
- sur le premier poste, elle effectue la capture d'écran, et
envoie les données
- sur le second poste, elle récupère les données, puis affiche
l'image à l'écran
class Bitmap
{
public :
// fonctions générales
Bitmap();
int NbOctetsParLigne();
// fonctions spécifiques au 1er poste
void CaptureEcran (Ecran*);
void EnvoieDonnees (SOCKET);
// fonctions spécifiques au 2è poste
void RecupereDonnees (SOCKET);
void AfficheBitmap (Ecran*);
private:
// Données privées, communes
};
Et là j'hésite : dois-je laisser ma classe comme ça, ou serait-il
mieux que je fasse une classe de base, plus deux classes dérivées
Bitmap_reception (contenant "RecupereDonnees()" et "AfficheBitmap()")
et Bitmap_envoi (contenant "CaptureEcran()" et "EnvoieDonnees()") ?
Ça empêcherait qu'on appelle EnvoieDonnees() sur un objet prévu pour
la réception, mais le jeu en vaut-il la chandelle ?
Oui car l'utilisateur de ta classe lui est une personne en laquelle tu ne
peux pas avoir confiance.
Autre chose, "AfficheBitmap (Ecran*);" est une fonction que l'utilisateur
va certainement appeler sans avoir appelé préalablement
"RecupereDonnees(SOCKET);".
J'essaie de faire un programme qui fait une capture d'écran sur un poste, et affiche cette capture sur un autre poste (un peu comme VNC).
J'ai donc une classe Bitmap, qui sert à deux choses : - sur le premier poste, elle effectue la capture d'écran, et envoie les données - sur le second poste, elle récupère les données, puis affiche l'image à l'écran
class Bitmap { public :
// fonctions générales Bitmap(); int NbOctetsParLigne();
// fonctions spécifiques au 1er poste void CaptureEcran (Ecran*); void EnvoieDonnees (SOCKET);
// fonctions spécifiques au 2è poste void RecupereDonnees (SOCKET); void AfficheBitmap (Ecran*);
private: // Données privées, communes };
Et là j'hésite : dois-je laisser ma classe comme ça, ou serait-il mieux que je fasse une classe de base, plus deux classes dérivées Bitmap_reception (contenant "RecupereDonnees()" et "AfficheBitmap()") et Bitmap_envoi (contenant "CaptureEcran()" et "EnvoieDonnees()") ? Ça empêcherait qu'on appelle EnvoieDonnees() sur un objet prévu pour la réception, mais le jeu en vaut-il la chandelle ? Oui car l'utilisateur de ta classe lui est une personne en laquelle tu ne
peux pas avoir confiance. Autre chose, "AfficheBitmap (Ecran*);" est une fonction que l'utilisateur va certainement appeler sans avoir appelé préalablement "RecupereDonnees(SOCKET);".
On Tue, 7 Oct 2003 09:27:41 +0200, "David Brabant" wrote:
Tu ne penses pas que l'envoi et la réception du bitmap devrait faire l'objet d'une (ou deux) classe(s) séparée(s) offrant ces services, classe(s) utilisée(s) (composition) par Bitmap?
En fait les fonctions de Bitmap sont vraiment directement liées à ses données : elles ne font en fait que transformer la représentation interne soit en flux d'octets (pour le réseau), soit en BMP reconnaissable par Windows (et les fonctions inverses qui font les transformation dans l'autre sens). Elles sont une interface publique assez "basique" de la classe, i.e. des fonctions n'ayant pas accès direct aux variables membres ne pourraient pas faire correctement le boulot.
On Tue, 7 Oct 2003 09:27:41 +0200, "David Brabant"
<david.brabant@qwanful.design.no.invalid> wrote:
Tu ne penses pas que l'envoi et la réception du bitmap
devrait faire l'objet d'une (ou deux) classe(s) séparée(s)
offrant ces services, classe(s) utilisée(s) (composition)
par Bitmap?
En fait les fonctions de Bitmap sont vraiment directement liées à ses
données : elles ne font en fait que transformer la représentation
interne soit en flux d'octets (pour le réseau), soit en BMP
reconnaissable par Windows (et les fonctions inverses qui font les
transformation dans l'autre sens). Elles sont une interface publique
assez "basique" de la classe, i.e. des fonctions n'ayant pas accès
direct aux variables membres ne pourraient pas faire correctement le
boulot.
On Tue, 7 Oct 2003 09:27:41 +0200, "David Brabant" wrote:
Tu ne penses pas que l'envoi et la réception du bitmap devrait faire l'objet d'une (ou deux) classe(s) séparée(s) offrant ces services, classe(s) utilisée(s) (composition) par Bitmap?
En fait les fonctions de Bitmap sont vraiment directement liées à ses données : elles ne font en fait que transformer la représentation interne soit en flux d'octets (pour le réseau), soit en BMP reconnaissable par Windows (et les fonctions inverses qui font les transformation dans l'autre sens). Elles sont une interface publique assez "basique" de la classe, i.e. des fonctions n'ayant pas accès direct aux variables membres ne pourraient pas faire correctement le boulot.
On Tue, 7 Oct 2003 14:22:07 +0200, "Frédéri MIAILLE" wrote:
Autre chose, "AfficheBitmap (Ecran*);" est une fonction que l'utilisateur va certainement appeler sans avoir appelé préalablement "RecupereDonnees(SOCKET);".
Yep, c'est prévu. AfficheBitmap() est appelée quand Windows demande à la fenêtre de s'afficher, et RecupereDonnees() est appelée quand des octets arrivent depuis le réseau ; du point de vue de la classe, les deux événements sont indépendants.
On Tue, 7 Oct 2003 14:22:07 +0200, "Frédéri MIAILLE"
<bobranger@wanadoo.fr> wrote:
Autre chose, "AfficheBitmap (Ecran*);" est une fonction que l'utilisateur
va certainement appeler sans avoir appelé préalablement
"RecupereDonnees(SOCKET);".
Yep, c'est prévu. AfficheBitmap() est appelée quand Windows demande à
la fenêtre de s'afficher, et RecupereDonnees() est appelée quand des
octets arrivent depuis le réseau ; du point de vue de la classe, les
deux événements sont indépendants.
On Tue, 7 Oct 2003 14:22:07 +0200, "Frédéri MIAILLE" wrote:
Autre chose, "AfficheBitmap (Ecran*);" est une fonction que l'utilisateur va certainement appeler sans avoir appelé préalablement "RecupereDonnees(SOCKET);".
Yep, c'est prévu. AfficheBitmap() est appelée quand Windows demande à la fenêtre de s'afficher, et RecupereDonnees() est appelée quand des octets arrivent depuis le réseau ; du point de vue de la classe, les deux événements sont indépendants.
