Discussion :

[tom31]

Bonjour
Malgré des recherches je n'arrive pas à comprendre cette structure

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
template <typename T>                                  //ligne 1
struct processus                                                 //ligne 2
{
typedef std::pair<double, T> state;                           //ligne 3                  
typedef std::list<state> result_type;                          //ligne 4
typedef typename result_type::iterator iter;                //ligne 5 
typedef typename result_type::const_iterator cst_iter;   //ligne 6 
processus(int size = 0) : value(size) {};                     //ligne 7 
virtual result_type operator()() = 0;                          //ligne 8 
result_type current() const { return value; };             //ligne 9 
template <typename S>                                          //ligne 10 
friend std::ostream& operator<<(std::ostream &o,           //ligne 11 
const processus<S> &p)                                          //ligne 12 
{
  o << 0;
  return o;
}
protected:
result_type value;
};

Ainsi voici ce que j'ai compris mais qui peut être faux et mes questions
ligne 3 : state a pour type un couple (double et suivant besoin int,char,float etc ...)
ligne 4 : result_type est une liste chainée du couple précédent mais pourquoi le compilateur n'accepte-t-il pas
typedef std::list<std::pair<double, T>> result_type;

Les autres lignes sont un peu le flou pour moi. Si d'aucun peut me donner des explications assez précises je l'en remercie par avance et cela me fera gagner du temps et m'évitera d'interpeler le forum.

Dernière précision : je suis complètement autodidacte en C++.

[r0d]

Bonjour,

ligne 3 : state a pour type un couple (double et suivant besoin int,char,float etc ...)

Ce n'est pas tout à fait exact. En fait, state est un type composé d'un double et d'un type variable (template).

pourquoi le compilateur n'accepte-t-il pas
typedef std::list<std::pair<double, T>> result_type;

Il me semble que la syntaxe exacte devrait être:

Code :

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

typedef std::list< std::pair< double, T > > result_type;

c'est à dire en mettant des espaces. Sinon, le compilateur peut croire que >> est un opérateur d'indirection de flux. Après, je crois que cette histoire d'espace n'est pas la même selon les compilateurs.

Quant au reste, ça va être long à expliquer
Si j'ai 5mn de libre je m'y colle.

[tom31]

Je vous remercie et effectivement si vous trouvez 5 minutes elles auront en ce qui me concerne un effet levier en me faisant gagner beaucoup de temps.
Je vous remercie, de nouveau, par avance.

[jblecanard]

Il me semble que la syntaxe exacte devrait être:

Code :

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

typedef std::list< std::pair< double, T > > result_type;

c'est à dire en mettant des espaces. Sinon, le compilateur peut croire que >> est un opérateur d'indirection de flux. Après, je crois que cette histoire d'espace n'est pas la même selon les compilateurs.

C'est tout à fait exact, GCC signale l'erreur et demande d'ajouter un espace. Visual Studio passe outre et compile.

[Emmanuel Deloget]

C'est tout à fait exact, GCC signale l'erreur et demande d'ajouter un espace. Visual Studio passe outre et compile.

Pour ce que j'en sais, VS2010, oui, parce qu'il intègre spécifiquement cette fonctionnalité du C++0x ; mais je ne pense pas que ce soit le cas pour les versions précédentes (il faudra que je teste ; je sais qu'au pire, on a un warning ; au mieux, une erreur de compilation).

[jblecanard]

Pour ce que j'en sais, VS2010, oui, parce qu'il intègre spécifiquement cette fonctionnalité du C++0x ; mais je ne pense pas que ce soit le cas pour les versions précédentes (il faudra que je teste ; je sais qu'au pire, on a un warning ; au mieux, une erreur de compilation).

J'ai testé sur un Visual Studio 2008, ça passe sans warning ni rien. D'ailleurs, les fonctionnalités C++0x ne sont disponibles que si demandées via une option spécifique il me semble.

[r0d]

Alors,

Code :

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

result_type value;

Cette ligne déclare une variable membre de type result_value, dont le nom est value.

Code :

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

1
2
typedef typename result_type::iterator iter;                //ligne 5 
typedef typename result_type::const_iterator cst_iter;   //ligne 6

Ces deux lignes déclarent des iterateurs. Ce sont des objets qui permettent de parcourir les objets stockés dans cet objet. Ici, ce sera sans doute pour parcourir value. Celui de la ligne 6 est un iterateur constant, c'est à dire que si on l'utilise, on ne pourra pas modifier l'objet sur lequel il pointe.

Code :

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

processus(int size = 0) : value(size) {};                     //ligne 7

Ça c'est un constructeur. Il définit à la fois un constructeur par défaut (si aucun paramètre ne lui est fourni, size sera 0) et un constructeur qui prend un paramètre: size.

Code :

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

virtual result_type operator()() = 0;

Ça c'est l'opérateur d'appel de fonction. En général, il sert pour permettre l'utilisation de cet objet en tant que foncteur. Parfois, c'est juste pour simplifier son utilisation.
Ici, cet opérateur est virtuel pur, ce qui signifie (entre autres) que:
1. cette classe ne peut pas être instanciée. En java, on dirait que c'est une interface.
2. les classes qui héritent de celle-ci devront obligatoirement implémenter cette fonction. C'est la raison pour laquelle on parle souvent de "programmation par contrat" lorsqu'on utilise des fonctions virutelles pures: on signe un contrat avec les classes qui vont hériter, contrat qui consiste en l'implémentation de ces fonctiones virtuelles pures.

Code :

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

result_type current() const { return value; };             //ligne 9

Ça c'est un simple accesseur. Il est déclaré constant car, et c'est logique, il n'est pas sensé modifier l'instance qui l'appelle. Attention cependant, cet accesseur renvoie une copie de l'objet value.

Code :

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

1
2
3
4
5
6
7
template <typename S>                                          //ligne 10 
friend std::ostream& operator<<(std::ostream &o,           //ligne 11 
const processus<S> &p)                                          //ligne 12 
{
  o << 0;
  return o;
}

Ça c'est l'opérateur d'indirection de flux. C'est le même opérateur qui est utilisé dans le code suivant par exemple:

Code :

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

std::cout << "hello word" << std::endl;

Par contre, l'implémentation de cet opérateur est étrange (le corps de la fonction), je ne la comprend pas.

[tom31]

Un sincère et reconnaissant

............ Merci ..............