>> je crois que ça ne marche qu'avec les chiffres et les nombres, pas avec les caractères
Je ne comprends pas ta question. Un caractère est un nombre, donc pas de souci avec ça. Si tu parles d'une chaîne de caractère, le problème ne se pose pas non plus.

Bonjour.

Quelques remarques:
- Pourrais-tu améliorer la description de ton projet ? Que fait ton programme ? Qu'est-ce qu'un EJP ? Y a-t-il des contraintes particulières pour le faire fonctionner ? etc... (En l'état, c'est très très maigre, et c'est dommage parce que ça à l'air intéressant).
- Ce n'est pas du code .Net (à modifier).
- Pourquoi y a-t-il autant de variables globales ? (Je dirais même: pourquoi y a-t-il des variables globales ?)
- À quoi sert la boucle infinie en fin de programme ?
- Le main standard (et propre) est: "int main(void)" (+ un return 0) et non "void main(void)".

Soit dit en passant, il est possible d'obtenir ce comportement en utilisant:
- std::list<boost::any> (tout types)
ou
- std::list<boost::variant> (types sélectionnés)

Mais il est vrai qu'il faut ajouter une dépendance supplémentaire. Je le signale juste pour ceux qui incluraient déjà la bibliothèque boost dans leurs projets.

Bonjour.

Le code est parfaitement portable (à part le system("pause"), mais ce n'est pas grave du tout). D'une manière générale, tant qu'on utilise pas des appels systèmes, les chances de rester portable sont grandes :)

Je te propose une version utilisant purement la STL. Il y a donc un peu moins de code:

#include <iostream>
#include <list>

class GenericNode
{
public:
  virtual const std::string& type() const = 0;
  virtual void print(std::ostream& out) const = 0;
  virtual ~GenericNode()
  {
  }
};

template <typename T>
class Node : public GenericNode
{
public:
  Node(const std::string& type, T value)
    : type_(type), value_(value)
  {
  }

  virtual const std::string& type() const
  {
    return type_;
  }

  T value() const
  {
    return value_;
  }

  virtual void print(std::ostream& out) const
  {
    out << "value_ = " << value_ << ", type = " << type_;
  }

  virtual ~Node()
  {
  }

private:
  const std::string type_;
  T value_;
};

std::ostream& operator<<(std::ostream& out, const GenericNode* node)
{
  node->print(out);
  return out;
}

#define NODE(Type,Value) new Node<Type>(#Type, Value)

int main()
{
  typedef std::list<GenericNode*> list_type;
  typedef typename list_type::const_iterator list_iter;

  list_type list;
  list.push_back(new Node<int>("int", 30));
  list.push_back(new Node<double>("double", 30.5));
  list.push_back(new Node<std::string>("std::string", "String example"));

  list.push_back(NODE(std::string, "Simplifed by macro"));

  int i = 1;
  for (list_iter it = list.begin(); it != list.end(); ++it, ++i)
    std::cout << i << ": " << *it << std::endl;

  std::cout << "List size: " << list.size() << std::endl
            << "First type: " << list.front()->type()
            << ", First value: " << static_cast<Node<int>*>(list.front())->value() << std::endl;

  return 0;
}

@buno: En C, point besoin de cast (quelque soit le compilateur). La seule raison pour laquelle tu pourrais avoir besoin d'un cast, c'est si tu utilises un compilateur C++ pour faire du C.

Merci de surveiller un minimum ton orthographe, c'est presque illisible (Évite le langage sms, met une majuscule en début de phrase, ne finit pas tes phrases par "4 petits points", il manque des accents sur la plupart des mots, + mots mal orthographiés). Tout le monde fait des fautes (moi le premier), mais un minimum d'effort est tout de même demandé.

>> j'ai rien dis de méchant....
Je te cite: "au lieu deparlerde cette méthode essayer de donnerdes commentaires constructifs ....". C'est un commentaire déplacé, qui plus est en t'adressant à des admins.

>>est ce que vs etes à la hauteur de le modifier" est un comm constructif
Tu n'as toujours pas compris sa remarque. D'une part il a dit précisement: "Serais-tu capable de le modifier ?" (ce n'est pas pareil). Il sous-entend que le fichier généré n'était pas de toi (ce qui est vrai), et que le poster n'avait pas d'intérêt. Pour traduire sa phrase: "T'amuserais-tu a modifier ce fichier directement ? A en comprendre les moindre détails et écrire ce fichier directement au lieu de le générer ?"
En d'autres termes: Pour poster ce genre de fichier, il faut l'avoir écrit soi-même, sinon on poste le fichier qui a permis sa génération. Et ça, c'est une remarque pertinente qui est parfaitement constructive.

>> pour la modification de ce code je suis bien sur capable de le modifier.....
Ce n'est pas ce qui est reproché. Ce qui ne vas pas, c'est de mettre en exemple la génération d'un code au lieu du code lui-même.
C'est comme si je te mettais le copier coller d'un exécutable en disant que je peux toujours modifier la source...

>> jeter alors uncoup d'oeil sur le fichier lex et au lieu deparlerde cette méthode essayer de donnerdes commentaires constructifs ....
Les commentaires données sont constructifs et font partis d'une démarche de discussion de ton projet. C'est devenir agressif dans tes propos et ne pas supporter la critique qui n'est pas très constructif.
Merci de remplacer le code généré (inutile de le présenter), par le code flex, je supprimerais la source d'ici 24 heures si ce n'est pas fait.

Il serait préférable, quitte à "montrer" absolument un échantillon de code, de mettre le contenu du flex ou du bison mais pas du fichier généré...
De plus, si on prend la "vraie" source (le *.lex), c'est très très léger pour une source.

Je t'invite à générer au moins:
- Le lexer (via flex, ça c'est fait)
- Le parser (via bison)
- La liaison bison-flex
- Le driver

Au lieu de poster plein de petites sources inachevées, poste plutôt un gros projet bien fini.

En C, on soustrait par '0' pour convertir un char en nombre (à condition que le char soit bien entre 0 et 9).
Ex:
char c = '5';
int i = c - '0'; // i vaudra 5

Attention, on a ici affaire à un chiffrement et non à un "cryptage". Voir la différence: http://www.cppfrance.com/forum/sujet-CS-CORRECTION-TITRE-THEME-FORUM_1387875.aspx

@lefauve42: Ce sont de très bonnes remarques. Néanmoins, je parlais d'un usage assez particulier. Généralement, je convertis mes caractères spéciaux en HTML quasi immédiatement, et si l'encodage change plus tard, vu que j'ai déjà tout en code html, je ne me pose plus la question.
Il existe bien entendu toujours le risque de transformer le fichier en prenant une version dont l'encodage a changé, auquel cas, il y aura effectivement un souci.
Ma méthode n'est pas infaillible à 100% (à moins de toujours utiliser le code html, mais donc plus besoin de convertisseur) et ta remarque reste très pertinente.

>> Moralite : quelle que soit la methode choisie, ca ne dispense pas de verifier la configuration du serveur et le format d'encodage de vos fichiers :o)
Tout à fait ! C'est une très bonne conclusion :)