Le problème est que
l'on ne peut pas mettre un type template dans un container de la STL.
Le problème est que
l'on ne peut pas mettre un type template dans un container de la STL.
Le problème est que
l'on ne peut pas mettre un type template dans un container de la STL.
On Sat, 07 May 2005 20:02:33 +0200, Stephane Wirtel
:Le problème est que
l'on ne peut pas mettre un type template dans un container de la STL.
Va voir chez Boost, il ont peut-être ce qu'il te faut.
On Sat, 07 May 2005 20:02:33 +0200, Stephane Wirtel
<stephane.wirtel@belgacom.net>:
Le problème est que
l'on ne peut pas mettre un type template dans un container de la STL.
Va voir chez Boost, il ont peut-être ce qu'il te faut.
On Sat, 07 May 2005 20:02:33 +0200, Stephane Wirtel
:Le problème est que
l'on ne peut pas mettre un type template dans un container de la STL.
Va voir chez Boost, il ont peut-être ce qu'il te faut.
Je ne pense pas que je puisse simuler une liste d'instance d'objet utilisant
des templates de manière statique.
Je ne pense pas que je puisse simuler une liste d'instance d'objet utilisant
des templates de manière statique.
Je ne pense pas que je puisse simuler une liste d'instance d'objet utilisant
des templates de manière statique.
On Sat, 07 May 2005 22:44:17 +0200, Stephane Wirtel
:Je ne pense pas que je puisse simuler une liste d'instance d'objet
utilisant des templates de manière statique.
Comme ça, brut de fonderie, non. Mais je crois avoir vu quelque chose
d'approchant chez Boost. Je ne m'en souviens pas plus que ça, mais
bon, boost:: n'est pas si gros que ça, ça ne devrait pas être trop dur
à retrouver...
J'espère trouver ;-)
On Sat, 07 May 2005 22:44:17 +0200, Stephane Wirtel
<stephane.wirtel@belgacom.net>:
Je ne pense pas que je puisse simuler une liste d'instance d'objet
utilisant des templates de manière statique.
Comme ça, brut de fonderie, non. Mais je crois avoir vu quelque chose
d'approchant chez Boost. Je ne m'en souviens pas plus que ça, mais
bon, boost:: n'est pas si gros que ça, ça ne devrait pas être trop dur
à retrouver...
J'espère trouver ;-)
On Sat, 07 May 2005 22:44:17 +0200, Stephane Wirtel
:Je ne pense pas que je puisse simuler une liste d'instance d'objet
utilisant des templates de manière statique.
Comme ça, brut de fonderie, non. Mais je crois avoir vu quelque chose
d'approchant chez Boost. Je ne m'en souviens pas plus que ça, mais
bon, boost:: n'est pas si gros que ça, ça ne devrait pas être trop dur
à retrouver...
J'espère trouver ;-)
Bonjour,
Voici un bout de code que je suis entrain de pondre afin de créer une
lecture de settings et initialisation de ces fameux settings de
manière automatique.
#include <iostream>
#include <string>
#include <list>
using namespace std;
template <class T> class ItemSetting {
public:
ItemSetting (void) {
// cout << "ItemSetting::ItemSetting" << endl;
}
~ItemSetting (void) {
// cout << "ItemSetting::~ItemSetting" << endl;
}
};
class Settings {
public:
Settings (void) {
cout << "Settings::Settings" << endl;
}
~Settings (void) {
cout << "Settings::~Settings" << endl;
}
private:
ItemSetting <bool> boolItemSetting;
ItemSetting <int> intItemSetting;
ItemSetting <char> charItemSetting;
ItemSetting <double> doubleItemSetting;
};
int main (int argc, char **argv) {
cout << "Size of Setting : " << sizeof (Settings) << endl;
return 0;
}
Dans mon main, ou via le constructeur de Settings, j'aimerais savoir
si il est possible de faire une boucle sur tous les variables
"ItemSetting <XXX>" se trouvant dans la partie "private" et
d'initialiser toutes les variables.
[...]
Est-ce que quelqu'un aurait déjà songé à ce style de programmation ?
PS : Il ne s'agit que d'un essai, pour voir les possibilités de la
Meta-programmation.
Bonjour,
Voici un bout de code que je suis entrain de pondre afin de créer une
lecture de settings et initialisation de ces fameux settings de
manière automatique.
#include <iostream>
#include <string>
#include <list>
using namespace std;
template <class T> class ItemSetting {
public:
ItemSetting (void) {
// cout << "ItemSetting::ItemSetting" << endl;
}
~ItemSetting (void) {
// cout << "ItemSetting::~ItemSetting" << endl;
}
};
class Settings {
public:
Settings (void) {
cout << "Settings::Settings" << endl;
}
~Settings (void) {
cout << "Settings::~Settings" << endl;
}
private:
ItemSetting <bool> boolItemSetting;
ItemSetting <int> intItemSetting;
ItemSetting <char> charItemSetting;
ItemSetting <double> doubleItemSetting;
};
int main (int argc, char **argv) {
cout << "Size of Setting : " << sizeof (Settings) << endl;
return 0;
}
Dans mon main, ou via le constructeur de Settings, j'aimerais savoir
si il est possible de faire une boucle sur tous les variables
"ItemSetting <XXX>" se trouvant dans la partie "private" et
d'initialiser toutes les variables.
[...]
Est-ce que quelqu'un aurait déjà songé à ce style de programmation ?
PS : Il ne s'agit que d'un essai, pour voir les possibilités de la
Meta-programmation.
Bonjour,
Voici un bout de code que je suis entrain de pondre afin de créer une
lecture de settings et initialisation de ces fameux settings de
manière automatique.
#include <iostream>
#include <string>
#include <list>
using namespace std;
template <class T> class ItemSetting {
public:
ItemSetting (void) {
// cout << "ItemSetting::ItemSetting" << endl;
}
~ItemSetting (void) {
// cout << "ItemSetting::~ItemSetting" << endl;
}
};
class Settings {
public:
Settings (void) {
cout << "Settings::Settings" << endl;
}
~Settings (void) {
cout << "Settings::~Settings" << endl;
}
private:
ItemSetting <bool> boolItemSetting;
ItemSetting <int> intItemSetting;
ItemSetting <char> charItemSetting;
ItemSetting <double> doubleItemSetting;
};
int main (int argc, char **argv) {
cout << "Size of Setting : " << sizeof (Settings) << endl;
return 0;
}
Dans mon main, ou via le constructeur de Settings, j'aimerais savoir
si il est possible de faire une boucle sur tous les variables
"ItemSetting <XXX>" se trouvant dans la partie "private" et
d'initialiser toutes les variables.
[...]
Est-ce que quelqu'un aurait déjà songé à ce style de programmation ?
PS : Il ne s'agit que d'un essai, pour voir les possibilités de la
Meta-programmation.
Est-ce que quelqu'un aurait déjà songé à ce style de programmation ?
Oh que oui :-D !
Il y a une technique (dont j'ai pipé l'idée de base dans les factories de
COM-à-l'ancienne) et que j'ai pu utiliser avec succès : elle permet de
constituer une daisy-chain avec les objets en question au moment de leur
construction.
Bien sûr, une daisy-chain c'est pas top pratique, mais ça suffit largement
pour atteindre le but.
Qu'est-ce qu'une daisy-chain ?
L'idée est de déclarer un pointeur initialisé à NULL - ou valeur
équivalente pour les gens pointilleux ;-) - dans le container (et s'il n'y
en avait pas ce serait une globale). Et ensuite de passer ***l'adresse
de*** ce pointeur (ou une référence) en argument de construction à tous
les objets à lister.
L'astuce est que (du moins dans un contexte non parallèle !!!), le
pointeur est initialisé en premier, et ensuite les objets sont construits
un par un (on a une petite idée de l'ordre dans votre contexte, mais en
fait on s'en fiche).
Il suffit alors que le constructeur de l'objet, recevant un tel pointeur
passé par adresse, fasse la transformation consistant à enfiler l'objet
courant en tête de liste (optimal), l'objet contenant donc un pointeur
"next".
Lorsque tous les objets sont construits, ils sont tous enfilés sur cette
daisy-chain, et donc il suffit de la parcourir pour exécuter itérativement
toute forme de tâche de "prise de contact" plus sophistiquée avec le
container...
J'ai bien l'impression que cette technique va m'aider à réaliser ma classe
PS : Il ne s'agit que d'un essai, pour voir les possibilités de la
Meta-programmation.
La méta-programmation, c'est l'avenir et c'est toute ma vie ... Et vous
vous en faites quoi ?
J'essaie d'apprendre et de voir les possibilités de cette technique forte
Cordialement,
Cordialement,
--
/***************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
***************************************/
Est-ce que quelqu'un aurait déjà songé à ce style de programmation ?
Oh que oui :-D !
Il y a une technique (dont j'ai pipé l'idée de base dans les factories de
COM-à-l'ancienne) et que j'ai pu utiliser avec succès : elle permet de
constituer une daisy-chain avec les objets en question au moment de leur
construction.
Bien sûr, une daisy-chain c'est pas top pratique, mais ça suffit largement
pour atteindre le but.
Qu'est-ce qu'une daisy-chain ?
L'idée est de déclarer un pointeur initialisé à NULL - ou valeur
équivalente pour les gens pointilleux ;-) - dans le container (et s'il n'y
en avait pas ce serait une globale). Et ensuite de passer ***l'adresse
de*** ce pointeur (ou une référence) en argument de construction à tous
les objets à lister.
L'astuce est que (du moins dans un contexte non parallèle !!!), le
pointeur est initialisé en premier, et ensuite les objets sont construits
un par un (on a une petite idée de l'ordre dans votre contexte, mais en
fait on s'en fiche).
Il suffit alors que le constructeur de l'objet, recevant un tel pointeur
passé par adresse, fasse la transformation consistant à enfiler l'objet
courant en tête de liste (optimal), l'objet contenant donc un pointeur
"next".
Lorsque tous les objets sont construits, ils sont tous enfilés sur cette
daisy-chain, et donc il suffit de la parcourir pour exécuter itérativement
toute forme de tâche de "prise de contact" plus sophistiquée avec le
container...
J'ai bien l'impression que cette technique va m'aider à réaliser ma classe
PS : Il ne s'agit que d'un essai, pour voir les possibilités de la
Meta-programmation.
La méta-programmation, c'est l'avenir et c'est toute ma vie ... Et vous
vous en faites quoi ?
J'essaie d'apprendre et de voir les possibilités de cette technique forte
Cordialement,
Cordialement,
--
/***************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
***************************************/
Est-ce que quelqu'un aurait déjà songé à ce style de programmation ?
Oh que oui :-D !
Il y a une technique (dont j'ai pipé l'idée de base dans les factories de
COM-à-l'ancienne) et que j'ai pu utiliser avec succès : elle permet de
constituer une daisy-chain avec les objets en question au moment de leur
construction.
Bien sûr, une daisy-chain c'est pas top pratique, mais ça suffit largement
pour atteindre le but.
Qu'est-ce qu'une daisy-chain ?
L'idée est de déclarer un pointeur initialisé à NULL - ou valeur
équivalente pour les gens pointilleux ;-) - dans le container (et s'il n'y
en avait pas ce serait une globale). Et ensuite de passer ***l'adresse
de*** ce pointeur (ou une référence) en argument de construction à tous
les objets à lister.
L'astuce est que (du moins dans un contexte non parallèle !!!), le
pointeur est initialisé en premier, et ensuite les objets sont construits
un par un (on a une petite idée de l'ordre dans votre contexte, mais en
fait on s'en fiche).
Il suffit alors que le constructeur de l'objet, recevant un tel pointeur
passé par adresse, fasse la transformation consistant à enfiler l'objet
courant en tête de liste (optimal), l'objet contenant donc un pointeur
"next".
Lorsque tous les objets sont construits, ils sont tous enfilés sur cette
daisy-chain, et donc il suffit de la parcourir pour exécuter itérativement
toute forme de tâche de "prise de contact" plus sophistiquée avec le
container...
J'ai bien l'impression que cette technique va m'aider à réaliser ma classe
PS : Il ne s'agit que d'un essai, pour voir les possibilités de la
Meta-programmation.
La méta-programmation, c'est l'avenir et c'est toute ma vie ... Et vous
vous en faites quoi ?
J'essaie d'apprendre et de voir les possibilités de cette technique forte
Cordialement,
Cordialement,
--
/***************************************
* Patrick BRUNET
* E-mail: lien sur http://zener131.free.fr/ContactMe
***************************************/
Bonjour,
Voici un bout de code que je suis entrain de pondre afin de créer une
lecture de settings et initialisation de ces fameux settings de
manière automatique.
#include <iostream>
#include <string>
#include <list>
using namespace std;
template <class T> class ItemSetting {
public:
ItemSetting (void) {
// cout << "ItemSetting::ItemSetting" << endl;
}
~ItemSetting (void) {
// cout << "ItemSetting::~ItemSetting" << endl;
}
};
class Settings {
public:
Settings (void) {
cout << "Settings::Settings" << endl;
}
~Settings (void) {
cout << "Settings::~Settings" << endl;
}
private:
ItemSetting <bool> boolItemSetting;
ItemSetting <int> intItemSetting;
ItemSetting <char> charItemSetting;
ItemSetting <double> doubleItemSetting;
};
int main (int argc, char **argv) {
cout << "Size of Setting : " << sizeof (Settings) << endl;
return 0;
}
Dans mon main, ou via le constructeur de Settings, j'aimerais savoir
si il est possible de faire une boucle sur tous les variables
"ItemSetting <XXX>" se trouvant dans la partie "private" et
d'initialiser toutes les variables.
Je me dis que j'aurais pû créer un std::vector de tous les
ItemSettings et via un std::iterator les initialiser via une boucle.
Le problème est que l'on ne peut pas mettre un type template dans un
container de la STL.
En méta-programmation template, tout se fait à la compilation, alors que les
Bonjour,
Voici un bout de code que je suis entrain de pondre afin de créer une
lecture de settings et initialisation de ces fameux settings de
manière automatique.
#include <iostream>
#include <string>
#include <list>
using namespace std;
template <class T> class ItemSetting {
public:
ItemSetting (void) {
// cout << "ItemSetting::ItemSetting" << endl;
}
~ItemSetting (void) {
// cout << "ItemSetting::~ItemSetting" << endl;
}
};
class Settings {
public:
Settings (void) {
cout << "Settings::Settings" << endl;
}
~Settings (void) {
cout << "Settings::~Settings" << endl;
}
private:
ItemSetting <bool> boolItemSetting;
ItemSetting <int> intItemSetting;
ItemSetting <char> charItemSetting;
ItemSetting <double> doubleItemSetting;
};
int main (int argc, char **argv) {
cout << "Size of Setting : " << sizeof (Settings) << endl;
return 0;
}
Dans mon main, ou via le constructeur de Settings, j'aimerais savoir
si il est possible de faire une boucle sur tous les variables
"ItemSetting <XXX>" se trouvant dans la partie "private" et
d'initialiser toutes les variables.
Je me dis que j'aurais pû créer un std::vector de tous les
ItemSettings et via un std::iterator les initialiser via une boucle.
Le problème est que l'on ne peut pas mettre un type template dans un
container de la STL.
En méta-programmation template, tout se fait à la compilation, alors que les
Bonjour,
Voici un bout de code que je suis entrain de pondre afin de créer une
lecture de settings et initialisation de ces fameux settings de
manière automatique.
#include <iostream>
#include <string>
#include <list>
using namespace std;
template <class T> class ItemSetting {
public:
ItemSetting (void) {
// cout << "ItemSetting::ItemSetting" << endl;
}
~ItemSetting (void) {
// cout << "ItemSetting::~ItemSetting" << endl;
}
};
class Settings {
public:
Settings (void) {
cout << "Settings::Settings" << endl;
}
~Settings (void) {
cout << "Settings::~Settings" << endl;
}
private:
ItemSetting <bool> boolItemSetting;
ItemSetting <int> intItemSetting;
ItemSetting <char> charItemSetting;
ItemSetting <double> doubleItemSetting;
};
int main (int argc, char **argv) {
cout << "Size of Setting : " << sizeof (Settings) << endl;
return 0;
}
Dans mon main, ou via le constructeur de Settings, j'aimerais savoir
si il est possible de faire une boucle sur tous les variables
"ItemSetting <XXX>" se trouvant dans la partie "private" et
d'initialiser toutes les variables.
Je me dis que j'aurais pû créer un std::vector de tous les
ItemSettings et via un std::iterator les initialiser via une boucle.
Le problème est que l'on ne peut pas mettre un type template dans un
container de la STL.
En méta-programmation template, tout se fait à la compilation, alors que les
En méta-programmation template, tout se fait à la compilation, alors que
les conteneurs de la STL fonctionnent au run-time.
C'est difficile de te conseiller sans savoir ce que tu veux faire
exactement, mais peut-être que les typelists pourraient t'intéresser :
Regardes du côté de la librairie Loki.
Pourrais-tu me parler des typelists ?
Arnaud
En méta-programmation template, tout se fait à la compilation, alors que
les conteneurs de la STL fonctionnent au run-time.
C'est difficile de te conseiller sans savoir ce que tu veux faire
exactement, mais peut-être que les typelists pourraient t'intéresser :
Regardes du côté de la librairie Loki.
Pourrais-tu me parler des typelists ?
Arnaud
En méta-programmation template, tout se fait à la compilation, alors que
les conteneurs de la STL fonctionnent au run-time.
C'est difficile de te conseiller sans savoir ce que tu veux faire
exactement, mais peut-être que les typelists pourraient t'intéresser :
Regardes du côté de la librairie Loki.
Pourrais-tu me parler des typelists ?
Arnaud
Suite de ma classe Settings.
[...] (le code)
Donc, par exemple pour liste la valeur pour la variable "Port", je
suis obligé de faire :
int port = boost::any_cast <int> (mapProperties ["Port"]);
Mais je ne peux pas me permettre de faire cela, si je veux afficher
la liste des propriétés, ainsi que leur valeur.
Quelqu'un aurait-il une idée ?
Je cherche toujours,
Suite de ma classe Settings.
[...] (le code)
Donc, par exemple pour liste la valeur pour la variable "Port", je
suis obligé de faire :
int port = boost::any_cast <int> (mapProperties ["Port"]);
Mais je ne peux pas me permettre de faire cela, si je veux afficher
la liste des propriétés, ainsi que leur valeur.
Quelqu'un aurait-il une idée ?
Je cherche toujours,
Suite de ma classe Settings.
[...] (le code)
Donc, par exemple pour liste la valeur pour la variable "Port", je
suis obligé de faire :
int port = boost::any_cast <int> (mapProperties ["Port"]);
Mais je ne peux pas me permettre de faire cela, si je veux afficher
la liste des propriétés, ainsi que leur valeur.
Quelqu'un aurait-il une idée ?
Je cherche toujours,
