Cheres amies , chers amis du forum

Voici deux classes abstraite:

var_alea.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
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#ifndef __VAR_ALEA_H_
#define __VAR_ALEA_H_
 
#include <cmath>
#include <ctime>
#include <cmath>     
#include <ctime>
#include <cstdlib>
#include <numeric>
 
#define MAX(A,B) ( (A) > (B) ? (A):(B) )
#define MIN(A,B) ( (A) < (B) ? (A):(B) )
 
#define PI 3.14159265358979
#define DEUXPI 6.283185306
#define PI2 1.570796326794
 
class var_alea
{
public:
 
	var_alea() {};
    virtual ~var_alea() {}; 
    virtual double operator()() = 0;
 
protected: 
 
 
};
#endif
Processus.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
17
18
19
#include <list>
#include <utility>
#include <iostream>
#include "var_alea.h"
#include "Poisson.h"
 
using namespace std;
 
class Processus 
{
public :
		Processus (int size = 0) : m_valeurs ( size ) {};
		virtual list <pair <double , double > > operator ()() = 0;
		friend ostream & operator <<(ostream &o, const Processus &p);		
 
protected :
		list < pair <double , double > > m_valeurs ;
 
};
Processus.cpp

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
#include "Processus.h"
 
std::ostream& operator<<(std::ostream &o, const Processus &p)
{
	list < pair <double , double > >::const_iterator i;          //Une paire est une structure contenant deux éléments éventuellement de types différents. 
														         //La classe list fournit une structure générique de listes chaînées. 
	for(i = p.m_valeurs.begin() ; i != p.m_valeurs.end(); ++i)
		o << (*i).first << "\t" << (*i).second << std::endl;
	return o;
}
Avec ceci je dois creer une classe poisson_composé qui simule une loi de Poisson composé.

Pour cela je dispose d'une classe Poisson qui depend de var_alea.h

poisson.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
17
18
19
20
21
22
#ifndef POISSON_H
#define POISSON_H
 
#include "var_alea.h"
#include "Uniform.h"
 
class Poisson : public Processus
{	
	public:
		   Poisson (double lambda = 0) : m_lambda(lambda)
			{
			}
	       Poisson (const Poisson &);
	       double operator ()();
	       Poisson & operator =(const Poisson &);
	       friend Poisson operator +(const Poisson &, const Poisson &);
 
	private:
		double m_lambda;
};
 
#endif
et poisson_composé.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
17
#include "Processus.h"
 
class Poisson_Compose : public Processus 
{
public :
		Poisson_Compose ( var_alea &X, int n, double T=1, double lambda =1) : m_P(lambda),m_X(X), m_n(n), m_T(T), m_lambda(lambda)																					
			{
				 m_h=(T / pow(2.0, n));
			}
		list <pair <double , double > > operator ()();
 
protected :
		int m_n;
		Poisson m_P;
		var_alea &m_X;
		double m_h, m_T, m_lambda ;
};
Jusque là aucun probleme, cependant dans mon poisson_composé je dois boucle dans une List, a partir d'une variable Poisson que j'ai et declaré dans Proccesus.h sauf qu'il ne reconnait pas les arugment de processus:

Pocessus.cpp

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
#include "Poisson_Composé.h"
 
list < pair <double , double > >Poisson_Compose ::operator()() 
{
	m_valeurs.clear();                          // clear List
	pair <double , double > T;                  // création d'une paire
	m_valeurs.push_back(T = make_pair (0,0));   // initialisation de T
	m_P();
 
	list < pair <double , double > >::const_iterator i;
 
	for(i = m_P.m_valeurs.begin(); i != m_P.m_valeurs.end(); ++i)
	{
		T.first   = (*i).first;
		T.second += m_X();
		m_valeurs.push_back(T);
	}
};
J'ai surligné les variable non reconnu.

ce sont les instructions suivante qui ne sont pas reconnu:

for(i = m_P.m_valeurs.begin(); i != m_P.m_valeurs.end(); ++i)
m_valeurs n'apparrait pas apres le . dans le menu déroulant

Pourriez vous m'aider SVP

Merci