Discussion :

[Sébastien P]

Salut à tous ! je suis en train de travailler sur un projet de traitement d'image.
Et j'ai donc créé une classe abstraite couleur que je spécialise dans les différents formats : RVBA32, RVB etc... et pour l'affichage j'aimerais pouvoir éviter de dupliquer mes données donc considérer par exemple mon tableau :

Couleur_RVB32* couleurs; comme un tableau de unsigned char or cela ne fonctionne pas puisque j'ai 4 octets qui s'intercalent à cause de mon héritage de la classe Couleur....

Voila j'espère que vous pourrez m'indiquer un moyen de remédier à mon problème.

En vous remerciant d'avance ++
Seb

[olive_le_malin]

Couleur_RVB32* couleurs; comme un tableau de unsigned char or cela ne fonctionne pas puisque j'ai 4 octets qui s'intercalent à cause de mon héritage de la classe Couleur....

Je comprends pas bien, mais ca sera pas plutot que tu fais un :

Couleur_RVB32* couleurs;
sizeof(couleurs) ... = 4 ?
ben sizeof(de n'importe quel pointeur) c'est toujours 4 octets !

[Sébastien P]

Nono c'est bien ça le problème !!!

C'est sizeof( Couleur ) = 4 qui me pose probleme et non pas sizeof( couleur ) qui d'ailleurs ne me plait pas trop du point de vu conceptuel si tu n'y voit pas d'inconvénient

D'autres idées ? dois-je être plus clair peut-être quand à ma question ?

++
Seb

[olive_le_malin]

Salut,

D'autres idées ? dois-je être plus clair peut-être quand à ma question ?

Oui.

En tout cas moi j'ai pas compris ce que tu cherches à faire.

donc considérer par exemple mon tableau :
Couleur_RVB32* couleurs; comme un tableau de unsigned char or cela ne fonctionne pas puisque j'ai 4 octets qui s'intercalent à cause de mon héritage de la classe Couleur....

Grace au sizeof tu veux récupérer ton nombre d'éléments ? et ce qui te perturbe c'est le + 4 octets ?

@+

[Sébastien P]

Non je cherche surtout pas à connaitre le nombre d'éléments !!! ça je le connais dieu merci !

Je vais essayer de faire un petit schéma :

Code :

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

1
2
3
4
5
6
7
8
9
class Couleur {
    public :
        Couleur() {}
        virtual ~Couleur() {}
 
        virtual void  setRouge(uint8 r) = 0;
        virtual uint8 getRouge() const = 0;
        etc ... pour toutes les composantes
};

ensuite je veux pouvoir spécialiser par exemple en RVBA32 ce qui donnerais :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
class CouleurRVBA32 : public Couleur {
    private :
        uint32;
 
    public :
        CouleurRVBA32();
        ~CouleurRVBA32();
 
        void setRouge( uint8 r );
        uint8 getRouge();
        etc .....
};

Voila et maintenant si je fais sizeof( CouleurRVBA32 ) = 16 ce qui n'es pas normal .... car si je retire l'héritage j'ai une valeur correcte c'est à dire :
sizeof( CouleurRVB32 ) = 8

voila merci d'avance ! ++
Seb

[Luc Hermitte]

virtual => tu paies une vtable.

[Sébastien P]

Et donc la seule solution c'est ? ^o)

Pas d'héritage ?
en plus une vtable pour chaque objet ya de l'abus (même si j'admet que ca peut etre utile )

++
Seb

[olive_le_malin]

désolé si ça parait neuneu, mais pourquoi diable le fait que
sizeof( CouleurRVBA32 ) = 16 ou 8 ou autre chose te pose un problème ?

Pourquoi et en vue de quelle pertinence le testes-tu ? Connaitre le type de ta donnée ?

@+

[Luc Hermitte]

La solution ? C'est peut-être que le polymorphisme d'inclusion n'est pas la réponse à la question.
Regarde ce qu'à fait adobe pour GIL.

[koala01]

Salut,

La vtable est quelque chose d'inhérant à l'héritage et aux phénomènes de polymorphisme...

En effet, cela revient à dire, pour la classe de base que "certaines classes qui héritent de la classe de base vont avoir des fonctions membres qui ne réagissent pas de la meme manière que celle dont est prévue la fonction correspondante de la classe mere"

Comme, justement, la manière dont réagissent ces fonctions va différer en fonction de la classe "finale", hé bien, il n'y a pas beaucoup le choix: il faut disposer d'un tableau de pointeurs sur fonctions qui permettra d'appeler la bonne fonction...

Ce tableau de pointeurs sur fonctions, ce sera la vtable...

Et, comme un tableau est toujours représenté en mémoire comme un pointeur sur le premier élément du tableau, il est logique que la taille de l'objet qui instancie une classe utilisant une vtable soit... de la taille totale de ses membres plus celle d'un pointeur

Ceci dit, il y a parfaitement moyen de faire de manière à provoquer une convertion dans des valeurs à ta discrétion:

Tu pourrais, par exemple, utiliser les opérateurs de convertion du genre de

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
 
class Couleur
{
    public:
        Couleur(){}
        ~Couleur(){}
        //rajoute les fonctions membres qui t'intéressent ;)
};
class RGB24:public Couleur
{
    public:
       RGB24(char R, char G, char B):m_red(R),m_green(G),m_blue(B){}
       RGB24(char* val):m_red(val[0]),m_green(val[1]),m_blue(val[2]){}
       virtual ~RGB24(){}
       //n'oublie pas de redéfinir les fonctions virtuelles pures ;)
       //l'opérateur de convertion en tableau de caractères
       operator const char*();//ici, j'ai préféré rendre le pointeur constant
 
    private:
       char m_red;
       char m_green;
       char m_blue;
};

L'implémentation de l'opérateur se ferait sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
 
RGB24::operator const char*()
{
    char *ret=new char[3];
    ret[0]=m_red;
    ret[1]=m_green;
    ret[2]=m_blue;
    return ret;
}

La convertion se fera alors de manière tout à fait automatique sous une forme proche de

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int main(int argc, char* argv[])
{
    //création d'un objet de type RGB24
    RGB24 macoul(100,25,240);
    const char* coul24b=macoul;
    std::cout<<(int)coul24b[0]<<" "<<(int)coul24b[1]<<" "
             <<(int)coul24b[2]<<std::endl;
    //n'oublie pas de libérer coul24b quand tu n'en a plus besoin
    delete[] coul24b;
    return 0;
}

Evidemment, les définition "inline" peuvent tres bien ne pas l'être... je n'y ai eu recours que par "fadesse"

[loufoque]

Et, comme un tableau est toujours représenté en mémoire comme un pointeur sur le premier élément du tableau

Oulah, n'importe quoi.
Dans le cas des tables de fonctions virtuelles, la table est statique et stockée en dehors de la classe. Sa taille n'est pas du tout celle d'un pointeur, plutôt quelque chose du genre la taille d'un pointeur de fonction multiplié par le nombre de fonctions virtuelles de la classe.
La classe ne fait que contenir un pointeur vers ce tableau statique.

[Sébastien P]

He bien je vois que ma question pose débat et j'en suis heureux bon j'ai compris que je ne pourrais pas échapper à un petit bout de donnée servant aux redirection des appels.

Pour ce qui es de ta solution koala01 j'avais déjà pensé à un équivalent mais mon souhait serait de ne pas avoir à faire de copie de mes données justement ..... et j'espérais ainsi que je pourrais aligner toutes mes couleurs les unes à la suite des autre et le considérer comme un unsigned char* mais donc je ne pourrais pas ....

Par contre je suis très intéressé par ce qu'as fait apercevoir Luc Hermitte à propos d'un polymorphisme non inclusif.... mais heuu plutôt que de devoir étudier tous le code de la GIL pendant des heures y aurait-il possibilité d'avoir une explication du principe ou un lien vers un tuto/cours ?

En vous remerciant d'avance
++
Seb

[Jean-Marc.Bourguet]

La vtable est quelque chose d'inhérant à l'héritage et aux phénomènes de polymorphisme...

Absolument pas. Ce qui est inhérent à tout type de polymorphisme dynamique, c'est la nécessité de récuperer indication de type; mais inclure un pointeur vers une vtable n'est qu'une technique possible, qui a d'ailleurs ses limites. Certaines techniques (ayant aussi leurs limites) n'ont pas besoin d'un tel pointeur -- par exemple si on alloue les objets d'un type donné dans une région fixée de la mémoire virtuelle, on peut récuperer le type a partir de l'adresse (cette technique est souvent utilisée pour un nombre limité de type en utilisant d'autres techniques pour les autres types).

Comme, justement, la manière dont réagissent ces fonctions va différer en fonction de la classe "finale", hé bien, il n'y a pas beaucoup le choix: il faut disposer d'un tableau de pointeurs sur fonctions qui permettra d'appeler la bonne fonction...

A la place de la vtable (qui contient d'ailleurs aussi d'autres info que des pointeurs de fonctions), on peut avoir un tableau associatif. Ou l'info peut être regroupée ailleurs qu'avec l'objet: dans la fonction par exemple qui contient un tableau associatif utilisant le marqueur de type -- qui peut être implicite voir ci-dessus -- avec le code.

Ce tableau de pointeurs sur fonctions, ce sera la vtable...

Et, comme un tableau est toujours représenté en mémoire comme un pointeur sur le premier élément du tableau, il est logique que la taille de l'objet qui instancie une classe utilisant une vtable soit... de la taille totale de ses membres plus celle d'un pointeur

Là tu pars d'une mauvaise idée de ce que sont les tableaux en C et en C++ (un tableau n'y est pas un pointeur vers son premier élément en C++, voir les innombrables discussions à ce sujet sur le forum C) et tu en fais une nécessité absolue...

[Jean-Marc.Bourguet]

Oulah, n'importe quoi.
Dans le cas des tables de fonctions virtuelles, la table est statique et stockée en dehors de la classe. Sa taille n'est pas du tout celle d'un pointeur, plutôt quelque chose du genre la taille d'un pointeur de fonction multiplié par le nombre de fonctions virtuelles de la classe.

Plus un certain nombre de choses comme un pointeur vers une structure de donnée permettant au RTTI de fonctionner. Sans compter ce qui est nécessaire pour l'héritage multiple.

[Médinoc]

Je crois que pour l'héritage multiple, il y a deux pointeurs de vtables (ou plus) dans la classe.
En tout cas, c'est le cas dans l'implémentation Microsoft : L'objet contient un vfptr et un vbptr.

[Sébastien P]

Pour en revenir à mon problème ....

Quand tu suggérais de passer par ce que tu appelle un polymorphisme non inclusif je suppose que tu pensais à des systèmes à base de template ...

C'est une notion que je découvre petit à petit depuis peu et donc il y a certain problèmes liés à l'utilisation de ceux qui ne me paraissent pas terrible ... surement parce qu'il me manque les méthodes appropriées.

Par exemple .. et c'est ce qui me fais le plus souffrir dans mon apprentissage :p il est plus que difficile de créer des pointeur vers des classes templates ou même vers des fonctions template.

J'ai étudié un peu le principe des foncteurs ou effectivement on peut déclarer un objet étant en réalité une fonction qui prendra ses paramètres plus tard .... ceci est tres pratique mais par exemple est-il possible d'avoir un objet général foncteur ??? un pointeur ou quoi que ce soit ??? j'en doute puisqu'il est impossible de créer une fonction template virtuelle ....

Donc voila, mon problème repose réellement sur au final le manque de Généricité que l'on perd en essayant d'en gagner avec le système de template ....

VOila si vous pouviez m'éclairer un peu plus sur les methodes de conceptions ? ou de codage qui permettent de contourner ces proplemes ou se passer de ces methodes de pointeur ??

Merci d'avance
++
Seb

[loufoque]

Par exemple .. et c'est ce qui me fais le plus souffrir dans mon apprentissage :p il est plus que difficile de créer des pointeur vers des classes templates ou même vers des fonctions template.

Pas particulièrement, non.
Enfin bon je ne vois pas vraiment l'utilité d'avoir des pointeurs de fonctions de toutes façons.

J'ai étudié un peu le principe des foncteurs ou effectivement on peut déclarer un objet étant en réalité une fonction qui prendra ses paramètres plus tard .... ceci est tres pratique mais par exemple est-il possible d'avoir un objet général foncteur ??? un pointeur ou quoi que ce soit ??? j'en doute puisqu'il est impossible de créer une fonction template virtuelle ....

Il en existe mais la signature du foncteur doit être fixe.
boost::function<void (int)> par exemple, pour un foncteur prenant un int en paramètre et retournant un void.
De toutes manières le principe même des templates c'est que normalement tu ne devrais pas avoir un type général, utilise simplement les templates pour que ça fonctionne avec tous les types.

[Sébastien P]

Bon je vais expliquer mon objectif pour que ma question soit plus clair.

Je voudrais avoir une interface pour afficher des images et ensuiote lancer des traitements dessus.

J'ai donc un systeme de multidocumet et de calques le probleme est le suivant : je veut pouvoir avoir des calques de différentes forme (profondeur de couleur, mode etc ...) mon calque contien donc un buffer de couleur template donc ce qui m'oblige par conséquent à avoir la classe Calque en template ... ensuite mes calques sont stoqués dans une pile dans mon document ... mais cela m'oblige donc à templatiser mon document egalement ce qui en soit n'est pas gènant....mes documents étant contenu dans l'interface ce n'es plus admissible .. il faut tout de même pouvoir avoir des documents de différentes formes !

J'ai donc créé une surclasse de document non template qui me permet de garder tous mes documents quel que soit leur type en virtualisant toutes les methodes utiles.

Le probleme qui se pose ensuite est le suivant : pour appliquer mes filtres que je veut pouvoir ajouter facilement je voulais pouvoir conserver une liste de pointeur vers mes fonctions de filtrage .. qui prendraient des clques en parametres template .. voila donc pourquoi je voulais faire toutes ces manipulation de pointeurs ...

Voila la raison de tous mes ennuis .. mais peut-etre que cela vien principalement de ma conception du logiciel mais dans ce cas j'aimerais avoir quelques pistes pour me réorienter car je n'en voit réellement aucune autre......et je me dis que ce sont mes connaissances qui m'y empèche


Merci d'avance @++
Seb

[Jean-Marc.Bourguet]

Avoir une base non template à une classe template est une technique courante et utile.

Je ne suis pas sûr de bien comprendre quel est ton problème avec les filtres. Je me demande si le pattern visiteur et plus largement les techniques de dispatch multiples ne seraient pas une solution.

[loufoque]

Le probleme qui se pose ensuite est le suivant : pour appliquer mes filtres que je veut pouvoir ajouter facilement je voulais pouvoir conserver une liste de pointeur vers mes fonctions de filtrage .. qui prendraient des clques en parametres template .. voila donc pourquoi je voulais faire toutes ces manipulation de pointeurs ...

Dans ce cas il te faut un foncteur polymorphique comme boost::function effectivement.