Discussion :

[Nurza]

Bonjour, j'utilise une classe dans un projet de prog où il y a une méthode que j'aimerai bien virtualiser car je t'utilise avec une classe fille.

Mais le problème c'est que cette méthode utilise un template:

Code :

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

template<typename T> T to();

Et j'ai essayé ça:

Code :

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

template<typename T> virtual T to();

Mais j'ai le message " error: templates may not be 'virtual' "

Donc quand j'appel la méthode avec un objet fille, la méthode mère est appelée

Une solution svp? Merci d'avance

[Flob90]

Bonjour,

Une fonction template ne peut être virtuelle (ca pose quelques problèmes techniques).

Ne peux tu pas exporter le paramètre template au sein de la classe ? Tu utilises cette fonction template membre sur le même objet avec plusieurs paramètres différents ?

Il est difficile de te donner une solution alternative sans savoir exactement pourquoi tu as ce besoin (il peut-être compréhensible ceci dit) ? Peux tu préciser le contexte et le pourquoi de ce besoin, ie ton design actuel et son objectif ?

[Nurza]

Bonjour,

Une fonction template ne peut être virtuelle (ca pose quelques problèmes techniques).

Ne peux tu pas exporter le paramètre template au sein de la classe ? Tu utilises cette fonction template membre sur le même objet avec plusieurs paramètres différents ?

Il est difficile de te donner une solution alternative sans savoir exactement pourquoi tu as ce besoin (il peut-être compréhensible ceci dit) ? Peux tu préciser le contexte et le pourquoi de ce besoin, ie ton design actuel et son objectif ?

Alors en gros, la classe mère s'appelle "Variable" et les classe filles "Char" "Int" "Double" etc

Et j'aimerai par exemple convertir un tableau de Variable (contenant des "Char" "Int" "Double" etc ) en un seul type donc je fais:

for (bla bla bla)
monTableau[i]->to<Int>();

Pour convertir tout le tableau en Int.

J'espère avoir été clair dans mes explications

[mitkl]

tu ne voudrais pas imiter le principe de boost::variant par hasard ?

[Nurza]

tu ne voudrais pas imiter le principe de boost::variant par hasard ?

Pas vraiment, mais je connaissais pas et je trouve ça très intéressant merci

[Lintel-oo]

Salut

Quel est ton but lorsque tu déclares plusieurs classes Int, Double etc ... héritant de Variable ?

Edit : en fait en relisant ton post je me suis aperçu que cela revenait exactement à ce qu'avait dit @mitkl, c'est à dire à boost::variant
Je crois que j'avais aussi testé ce genre de chose avant qu'on me dise que cela ne servait à rien de réinventer la roue même si c'est vrai que ça peut être assez intéressant

Donc désolé mais je crois que je ne peux rien t'apporter de plus

[Nurza]

Salut

Quel est ton but lorsque tu déclares plusieurs classes Int, Double etc ... héritant de Variable ?

Edit : en fait en relisant ton post je me suis aperçu que cela revenait exactement à ce qu'avait dit @mitkl, c'est à dire à boost::variant
Je crois que j'avais aussi testé ce genre de chose avant qu'on me dise que cela ne servait à rien de réinventer la roue même si c'est vrai que ça peut être assez intéressant

Donc désolé mais je crois que je ne peux rien t'apporter de plus

C'est pas grave, je crois que je vais devoir surcharger à fond la méthode to()

[Nurza]

Bon finalement je pense avoir trouvé la solution:

Une fonction amie avec la classe Variable et un nouvel attribut qui renseigne sur le type de variable:

Variable.h:

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
 
class Variable
{
    /* bla bla bla */
 
 
    // Attributs
public:
    char typeVar; // Type de la variable (exemple: 6 pour Int)
 
 
    template<typename T> friend T to(Variable& v);
 
    /* bla bla bla */
 
};

Cast.cpp: (fichier où se trouve la fonction amie)

Code :

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

1
2
3
4
5
6
7
 
using namespace std;
 
template<typename T2>
T2 to(Variable& v){
    return Variable();
}

Bon j'ai encore rien mis dedans, mais c'est juste que j'ai une erreur lors de la compilation (pourtant je me suis inspiré de http://cpp.developpez.com/faq/cpp/?page=templates)


Cast.cpp|7|error: redefinition of 'template<class T2> T2 to(Variable&)'|
Cast.cpp|7|error: 'template<class T> T to(Variable&)' previously declared here|

Où se situe l'erreur?

[Bousk]

Bonjour,

les fonctions template ne peuvent pas être définies dans un .cpp, elles doivent être écrites dans un fichier inclus (généralement dans le .h directement, ou dans un fichier quelconque .inl, .tpl, .hxx ...)

[Nurza]

Bonjour,

les fonctions template ne peuvent pas être définies dans un .cpp, elles doivent être écrites dans un fichier inclus (généralement dans le .h directement, ou dans un fichier quelconque .inl, .tpl, .hxx ...)

Oui désolé j'avais oublié

Merci à tous, sujet (presque ) résolu

[gbdivers]

J'ai l'impression que tu essaies de résoudre un problème de conception à coup de solutions techniques...
Ta classe Variable ressemble beaucoup à un god object. A éviter.
Ce que tu souhaites faire, c'est a priori un variant (un type qui peut contenir n'importe quoi). Tu peux également regarder du côté de boost.any. Mais c'est une forme de void* (tout comme boost.variant) et donc à éviter aussi.

Et j'aimerai par exemple convertir un tableau de Variable (contenant des "Char" "Int" "Double" etc ) en un seul type donc je fais:

for (bla bla bla)
monTableau[i]->to<Int>();

Pour convertir tout le tableau en Int.

Si je comprend bien, tu veux convertir le tableau d'un type vers un autre ?

Code :

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

1
2
3
monTableau; // de type double
blabla
monTableau; // de type int

On est d'accord qu'il faut probablement ré-allouer le tableau si les types ont des sizeof différents ? (et même si c'est pas le cas, faire la conversion sur la même adresse mémoire est casse-gueule). En gros cela revient à faire :

Code :

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

1
2
3
monTableau;
monTableau2 = monTableau.to<Int>();
monTableau = monTableau2;

J'ai l'impression que ce que tu souhaites faire, c'est un typage faible, comme on trouve dans d'autres langages ? Si c'est la cas, c'est pas forcement une bonne idée, tu perds tout ce qui fait la force du typage fort du C++

Tu peux préciser tes besoins ?

PS : quand je dis "éviter", cela ne veut pas dire qu'il faut pas utiliser ces approches. Cela veut dire que cela ne doit pas être la solution par défaut, mais la solution en dernier recours, quand toutes les autres approches ont été rejetées après réflexion

[Nurza]

Si je comprend bien, tu veux convertir le tableau d'un type vers un autre ?

Code :

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

1
2
3
monTableau; // de type double
blabla
monTableau; // de type int

On est d'accord qu'il faut probablement ré-allouer le tableau si les types ont des sizeof différents ? (et même si c'est pas le cas, faire la conversion sur la même adresse mémoire est casse-gueule). En gros cela revient à faire :

Code :

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

1
2
3
monTableau;
monTableau2 = monTableau.to<Int>();
monTableau = monTableau2;

Oula non c'est pas exactement ça, non je voulais dire que j'ai un tableau de pointeurs vers des objets de type "Variable" (donc qui peut contenir des Int, Double, Char, etc (vu que c'est des classe qui dérivent de Variable) ) et par exemple pouvoir faire en gros ce genre de chose:

Code :

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

1
2
3
4
5
6
7
 
// Declaration du tableau de Variable* (nommé t[] )
 
// Declaration du tableau Int[100] (nommé t2[] )
 
for (int i=0; i<100;i++)
t2[i] = t[i]->to<Int>();

to() est une fonction qui est censée caster n'importe quel type vers n'importe quel autre type (avec des exceptions et tout et tout)

Tout ça pour en fait un projet de 2ème année en DUT info, on cherche à faire un langage de prog ultra simple (une fonctionnalité de ce dernier est d'être vachement souple sur les types) donc là je code l'interpréteur (qui donne de TRÈS bons résultats jusqu'à maintenant)

Mais je ne peux pas utilisé de boost variant car ce langage utilise aussi des variables non typées (qui seront des boost variant) mais pour l'instant on en est au variable typées (pour optimisé le code pour éviter les conversions, même si justement là on bosse sur les conversions pour être vraiment souple)


Donc en gros le langage contient:

- Des variables non typées (boost:variant)

- Des variables typées pour optimiser le code et limiter les conversions de type (qui pourront être quand même converti pour + de souplesse), codée par une classe mère "Variable" dont héritent des classes fille comme Int, Char, SInt, Bool, etc...)

[Flob90]

Ca a déjà été dit, mais là tu es en train de recoder boost::variant (ou presque) et la fonction libre get qui va avec (sauf que toi elle est membre). Si en plus tu as le droit d'utiliser boost et que tu vas l'utiliser ensuite, je vois vraiment pas l'intérêt (autre que pédagogique) de le recoder ...

Pour un interpréteur, AMA, il y a deux approches concernant les types :

• L'ensemble des types est fixé, et dans ce cas créer un type C++ par type du langage (en utilisant au besoin directement les types primitif (*)) et utiliser une structure contenant le nom de la variable et un variant sur l'ensemble des types est une solution.
• Il y a un ensemble de type défini par le langage et un moyen d'en rajouter d'autre, dans ce cas l'idée est la même sauf que le variant doit avoir un type de plus. Ce dernier type, probablement une classe, doit pouvoir permettre de caractériser entièrement un type et l'état d'une variable de ce type (à voir pour séparer clairement les deux).

Comment comptes-tu utiliser un variant pour réaliser des variables non typées ? Personnelement, un système de variable non typée je vois ca comme des couples de chaines de caractères (une pour le nom et une pour les données). Alors qu'un variant (any) je verrais plutôt ca dans le cadre d'un typage dynamique.

(*) A quoi bon coder une classe Int si le type natif du C++ int convient ?

[Nurza]

Ca a déjà été dit, mais là tu es en train de recoder boost::variant (ou presque) et la fonction libre get qui va avec (sauf que toi elle est membre). Si en plus tu as le droit d'utiliser boost et que tu vas l'utiliser ensuite, je vois vraiment pas l'intérêt (autre que pédagogique) de le recoder ...

Pour un interpréteur, AMA, il y a deux approches concernant les types :

• L'ensemble des types est fixé, et dans ce cas créer un type C++ par type du langage (en utilisant au besoin directement les types primitif (*)) et utiliser une structure contenant le nom de la variable et un variant sur l'ensemble des types est une solution.
• Il y a un ensemble de type défini par le langage et un moyen d'en rajouter d'autre, dans ce cas l'idée est la même sauf que le variant doit avoir un type de plus. Ce dernier type, probablement une classe, doit pouvoir permettre de caractériser entièrement un type et l'état d'une variable de ce type (à voir pour séparer clairement les deux).

Comment comptes-tu utiliser un variant pour réaliser des variables non typées ? Personnelement, un système de variable non typée je vois ca comme des couples de chaines de caractères (une pour le nom et une pour les données). Alors qu'un variant (any) je verrais plutôt ca dans le cadre d'un typage dynamique.

(*) A quoi bon coder une classe Int si le type natif du C++ int convient ?

Je recréer boost::varriant car j'ai besoin d'ajouter des trucs comme un compteur de références pour CHAQUE variables pour le ramasse miette, un entier pour renseigner si cette variable est constante ou non et sa portée dans le code.
Et que pour gérer la mémoire j'utilise une classe (MemoryKernel) qui utilise un tableau de Variable* (memory[]) dont l'indice représente l'adresse de la mémoire.

Donc par exemple si j’écris un programme:

$i = 1

Après compilation on me dira que la variable d'adresse 0 (donc dans memory[0]) vaut 1.

Et aussi parce que boost::varriant peut contenir que 10 types max (or j'ai besoin de bien + de types)

[Flob90]

A la place de recoder boost::variant (*) et d'y intégrer un compteur et d'autre "truc", tu pourrais chercher à les rendre non intruisif. Typiquement en passant par une capsule intermédiaire entre les types et ceux du variant. Ca serait surment bien plus flexible (SRP).

boost::variant peut contenir au moins 10 types, si tu as besoin de plus il y a une macro pour spécifier le nombre minimal qu'il doit gérer. Tu as combien de types en tout ?

(*) D'ailleurs même en la recodant, je pense que la séparation serait bien mieux.

[Nurza]

A la place de recoder boost::variant (*) et d'y intégrer un compteur et d'autre "truc", tu pourrais chercher à les rendre non intruisif. Typiquement en passant par une capsule intermédiaire entre les types et ceux du variant. Ca serait surment bien plus flexible (SRP).

boost::variant peut contenir au moins 10 types, si tu as besoin de plus il y a une macro pour spécifier le nombre minimal qu'il doit gérer. Tu as combien de types en tout ?

(*) D'ailleurs même en la recodant, je pense que la séparation serait bien mieux.

Oula, genre 50.

Mais je fais la différence entre Char* Char et Char[] dans la gestion des types

[Bousk]

Et pourquoi tu fais pas un simple composite ?

Code :

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

1
2
3
4
5
6
class Variable
{
 boost::variant var;
 unsigned int nbRef;
 // ...
};

Parce que vouloir refaire un boost::variant pour y ajouter 3 conneries.. c'est une bête composition

[Nurza]

Et pourquoi tu fais pas un simple composite ?

Code :

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

1
2
3
4
5
6
class Variable
{
 boost::variant var;
 unsigned int nbRef;
 // ...
};

Parce que vouloir refaire un boost::variant pour y ajouter 3 conneries.. c'est une bête composition

Ce ne serait pas + simple de faire une classe qui hérite de boost::variant?

[white_tentacle]

Ce ne serait pas + simple de faire une classe qui hérite de boost::variant?

Je ne crois pas que boost::variant soit prévu pour en hériter publiquement. Donc il vaut mieux privilégier une composition (pas sûr que l’héritage privé soit plus approprié).

[Nurza]

Je ne crois pas que boost::variant soit prévu pour en hériter publiquement. Donc il vaut mieux privilégier une composition (pas sûr que l’héritage privé soit plus approprié).

Et pourtant ça économiserait quelques octets par variable.

J'avais aussi penser faire une classe template Variable

avec une spécialisation pour tous les types que je veux utiliser. On pourra donc faire un new Variable<int>, vous en pensez quoi? (ça pourrait éviter l'héritage et aussi la composition inutile)

PS: je ne cherche pas à avoir un code facile à coder/comprendre, je cherche à avoir un interpréteur de code compilé performant avec le moins de gaspillage de mémoire possible.