Bonjour,
Je définis une classe qui me permet de générer des formes d'ondes ( extraits
code en fin de message(toutes critiques bienvenues ;-) ))
Dans cette classe, j'ai quelques fonctions,
de type
void F0 (double);
Je veux faire un tableau de pointeurs de fonctions mais je rencontre
quelques difficultés.
J'essaie de faire un
typedef void (*fptronde) (double);
puis je fais des
fonction[0]=&onde::F0;
Mais ça ne compile pas... error C2440: '=' : impossible de convertir de
'void (__thiscall onde::* )(double)' en 'onde::fptronde'
Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
suis-je obligé de passer par un type que je n'utilise qu'une fois?
Les données étant dupliquées pour chaque instance de la classe, que dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Bonjour,
Je définis une classe qui me permet de générer des formes d'ondes ( extraits
code en fin de message(toutes critiques bienvenues ;-) ))
Dans cette classe, j'ai quelques fonctions,
de type
void F0 (double);
Je veux faire un tableau de pointeurs de fonctions mais je rencontre
quelques difficultés.
J'essaie de faire un
typedef void (*fptronde) (double);
puis je fais des
fonction[0]=&onde::F0;
Mais ça ne compile pas... error C2440: '=' : impossible de convertir de
'void (__thiscall onde::* )(double)' en 'onde::fptronde'
Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
suis-je obligé de passer par un type que je n'utilise qu'une fois?
Les données étant dupliquées pour chaque instance de la classe, que dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Bonjour,
Je définis une classe qui me permet de générer des formes d'ondes ( extraits
code en fin de message(toutes critiques bienvenues ;-) ))
Dans cette classe, j'ai quelques fonctions,
de type
void F0 (double);
Je veux faire un tableau de pointeurs de fonctions mais je rencontre
quelques difficultés.
J'essaie de faire un
typedef void (*fptronde) (double);
puis je fais des
fonction[0]=&onde::F0;
Mais ça ne compile pas... error C2440: '=' : impossible de convertir de
'void (__thiscall onde::* )(double)' en 'onde::fptronde'
Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
suis-je obligé de passer par un type que je n'utilise qu'une fois?
Les données étant dupliquées pour chaque instance de la classe, que dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Bonjour,
Je définis une classe qui me permet de générer des formes d'ondes
(extraits
code en fin de message(toutes critiques bienvenues ;-) ))
Dans cette classe, j'ai quelques fonctions,
de type
void F0 (double);
Je veux faire un tableau de pointeurs de fonctions mais je rencontre
quelques difficultés.
J'essaie de faire un
typedef void (*fptronde) (double);
puis je fais des
fonction[0]=&onde::F0;
Mais ça ne compile pas... error C2440: '=' : impossible de convertir de
'void (__thiscall onde::* )(double)' en 'onde::fptronde'
Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
suis-je obligé de passer par un type que je n'utilise qu'une fois?
Les données étant dupliquées pour chaque instance de la classe, que
dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Merci.
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff; //Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
typedef void (*fptronde) (double);
fptronde fonction [5];
void sinusoide(double);
void carree (double);
void triangulaire (double);
void montante (double);
void descendante (double);
public:
int type; //type de générateur d'onde
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
void onde::sinusoide(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
type=0;
fonction[0]=&onde::sinusoide;
fonction[1]=&onde::carree;
fonction[2]=&onde::triangulaire;
fonction[3]=&onde::montante;
fonction[4]=&onde::descendante;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
(*(fonction[type]))(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Bonjour,
Je définis une classe qui me permet de générer des formes d'ondes
(extraits
code en fin de message(toutes critiques bienvenues ;-) ))
Dans cette classe, j'ai quelques fonctions,
de type
void F0 (double);
Je veux faire un tableau de pointeurs de fonctions mais je rencontre
quelques difficultés.
J'essaie de faire un
typedef void (*fptronde) (double);
puis je fais des
fonction[0]=&onde::F0;
Mais ça ne compile pas... error C2440: '=' : impossible de convertir de
'void (__thiscall onde::* )(double)' en 'onde::fptronde'
Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
suis-je obligé de passer par un type que je n'utilise qu'une fois?
Les données étant dupliquées pour chaque instance de la classe, que
dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Merci.
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff; //Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
typedef void (*fptronde) (double);
fptronde fonction [5];
void sinusoide(double);
void carree (double);
void triangulaire (double);
void montante (double);
void descendante (double);
public:
int type; //type de générateur d'onde
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
void onde::sinusoide(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
type=0;
fonction[0]=&onde::sinusoide;
fonction[1]=&onde::carree;
fonction[2]=&onde::triangulaire;
fonction[3]=&onde::montante;
fonction[4]=&onde::descendante;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
(*(fonction[type]))(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Bonjour,
Je définis une classe qui me permet de générer des formes d'ondes
(extraits
code en fin de message(toutes critiques bienvenues ;-) ))
Dans cette classe, j'ai quelques fonctions,
de type
void F0 (double);
Je veux faire un tableau de pointeurs de fonctions mais je rencontre
quelques difficultés.
J'essaie de faire un
typedef void (*fptronde) (double);
puis je fais des
fonction[0]=&onde::F0;
Mais ça ne compile pas... error C2440: '=' : impossible de convertir de
'void (__thiscall onde::* )(double)' en 'onde::fptronde'
Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
suis-je obligé de passer par un type que je n'utilise qu'une fois?
Les données étant dupliquées pour chaque instance de la classe, que
dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Merci.
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff; //Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
typedef void (*fptronde) (double);
fptronde fonction [5];
void sinusoide(double);
void carree (double);
void triangulaire (double);
void montante (double);
void descendante (double);
public:
int type; //type de générateur d'onde
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
void onde::sinusoide(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
type=0;
fonction[0]=&onde::sinusoide;
fonction[1]=&onde::carree;
fonction[2]=&onde::triangulaire;
fonction[3]=&onde::montante;
fonction[4]=&onde::descendante;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
(*(fonction[type]))(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
cyrcocq wrote:Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
typedef void (onde::*fptronde) (double);
Car un pointeur vers une fonction membre n'est pas la même chose qu'un
pointeur vers une fonction "ordinaire".suis-je obligé de passer par un type que je n'utilise qu'une fois?
Pas compris.
En fait, je voulais dire: dois-je vraiment définir un type sachant qu'il n'y
Les données étant dupliquées pour chaque instance de la classe, que
dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Attention, il s'agit d'une définition de type "pointeur vers fonction
membre de la classe onde". Tu n'a pas d'instance de ce pointeur de
fonction mais un tableau de pointeurs vers fonctions membres qui
s'appelle fonction.
Mais? ce tableau de pointeur est bien instancié à chaque création d'un de
Tu peux laisser comme cela, par contre, tu manipules des données de
types pointeur sur qqchose, donc pense à faire un constructeur par
copie, à surcharger l'opérateur d'affectation.
A+
Le targeur.
cyrcocq wrote:
Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
typedef void (onde::*fptronde) (double);
Car un pointeur vers une fonction membre n'est pas la même chose qu'un
pointeur vers une fonction "ordinaire".
suis-je obligé de passer par un type que je n'utilise qu'une fois?
Pas compris.
En fait, je voulais dire: dois-je vraiment définir un type sachant qu'il n'y
Les données étant dupliquées pour chaque instance de la classe, que
dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Attention, il s'agit d'une définition de type "pointeur vers fonction
membre de la classe onde". Tu n'a pas d'instance de ce pointeur de
fonction mais un tableau de pointeurs vers fonctions membres qui
s'appelle fonction.
Mais? ce tableau de pointeur est bien instancié à chaque création d'un de
Tu peux laisser comme cela, par contre, tu manipules des données de
types pointeur sur qqchose, donc pense à faire un constructeur par
copie, à surcharger l'opérateur d'affectation.
A+
Le targeur.
cyrcocq wrote:Allors 3 questions:
comment dois-je définir mon type de pointeur sur fonction???
typedef void (onde::*fptronde) (double);
Car un pointeur vers une fonction membre n'est pas la même chose qu'un
pointeur vers une fonction "ordinaire".suis-je obligé de passer par un type que je n'utilise qu'une fois?
Pas compris.
En fait, je voulais dire: dois-je vraiment définir un type sachant qu'il n'y
Les données étant dupliquées pour chaque instance de la classe, que
dois-je
faire pour n'avoir qu'une instance de ce pointeur de fonction?
Attention, il s'agit d'une définition de type "pointeur vers fonction
membre de la classe onde". Tu n'a pas d'instance de ce pointeur de
fonction mais un tableau de pointeurs vers fonctions membres qui
s'appelle fonction.
Mais? ce tableau de pointeur est bien instancié à chaque création d'un de
Tu peux laisser comme cela, par contre, tu manipules des données de
types pointeur sur qqchose, donc pense à faire un constructeur par
copie, à surcharger l'opérateur d'affectation.
A+
Le targeur.
Bonjour,
Ton code ressemble beaucoup à ce que l'on ferait avec du C. Tu ne profite
pas des avantages que peuvent t'offrir l'objet et le C++.
Je ne pense pas que dans ton cas le pointeur de fonction te soit utile. Un
exemble de code pourrait être le suivant :
Une classe onde générique :
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff; //Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
// Une fonction virtuelle pure car tu as besoin d'une forme pour ton
onde mais tu es incapable de la définir à ce niveau
virtual void forme(double) = 0;
public:
// Le type d'onde ne sert à rien
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
// Ici tu utilises ta forme d'onde
forme(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Tu spécialise ensuite tes ondes, pour une sinusoide tu auras la classe
suivante :
class sinusoide : public onde
{
private:
// La fonction pour la forme de la sinusoide
virtual void forme(double);
public:
sinusoide();
(...)
}
void sinusoide::forme(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
Voila. Ca réponde pas vraiment à la question mais ca me semble plus
logique ainsi.
Sinon si tu souhaite utiliser le pointeur de fonction il faut mettre :
typedef void (onde::*fptronde) (double);
Pascal
Bonjour,
Ton code ressemble beaucoup à ce que l'on ferait avec du C. Tu ne profite
pas des avantages que peuvent t'offrir l'objet et le C++.
Je ne pense pas que dans ton cas le pointeur de fonction te soit utile. Un
exemble de code pourrait être le suivant :
Une classe onde générique :
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff; //Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
// Une fonction virtuelle pure car tu as besoin d'une forme pour ton
onde mais tu es incapable de la définir à ce niveau
virtual void forme(double) = 0;
public:
// Le type d'onde ne sert à rien
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
// Ici tu utilises ta forme d'onde
forme(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Tu spécialise ensuite tes ondes, pour une sinusoide tu auras la classe
suivante :
class sinusoide : public onde
{
private:
// La fonction pour la forme de la sinusoide
virtual void forme(double);
public:
sinusoide();
(...)
}
void sinusoide::forme(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
Voila. Ca réponde pas vraiment à la question mais ca me semble plus
logique ainsi.
Sinon si tu souhaite utiliser le pointeur de fonction il faut mettre :
typedef void (onde::*fptronde) (double);
Pascal
Bonjour,
Ton code ressemble beaucoup à ce que l'on ferait avec du C. Tu ne profite
pas des avantages que peuvent t'offrir l'objet et le C++.
Je ne pense pas que dans ton cas le pointeur de fonction te soit utile. Un
exemble de code pourrait être le suivant :
Une classe onde générique :
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff; //Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
// Une fonction virtuelle pure car tu as besoin d'une forme pour ton
onde mais tu es incapable de la définir à ce niveau
virtual void forme(double) = 0;
public:
// Le type d'onde ne sert à rien
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
// Ici tu utilises ta forme d'onde
forme(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Tu spécialise ensuite tes ondes, pour une sinusoide tu auras la classe
suivante :
class sinusoide : public onde
{
private:
// La fonction pour la forme de la sinusoide
virtual void forme(double);
public:
sinusoide();
(...)
}
void sinusoide::forme(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
Voila. Ca réponde pas vraiment à la question mais ca me semble plus
logique ainsi.
Sinon si tu souhaite utiliser le pointeur de fonction il faut mettre :
typedef void (onde::*fptronde) (double);
Pascal
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
"Pascal Pizeine" a écritBonjour,
Ton code ressemble beaucoup à ce que l'on ferait avec du C. Tu ne profite
pas des avantages que peuvent t'offrir l'objet et le C++.
C'est vrai, mais, je débute en C++ et encore plus en objet!
Il m'est difficile de concevoir en objet pour l'instant...
Mais je lis, je teste, j'apprends... J'y arriverais!!!Je ne pense pas que dans ton cas le pointeur de fonction te soit utile.
Un exemble de code pourrait être le suivant :
Une classe onde générique :
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff;
//Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
// Une fonction virtuelle pure car tu as besoin d'une forme pour ton
onde mais tu es incapable de la définir à ce niveau
virtual void forme(double) = 0;
public:
// Le type d'onde ne sert à rien
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
// Ici tu utilises ta forme d'onde
forme(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Tu spécialise ensuite tes ondes, pour une sinusoide tu auras la classe
suivante :
class sinusoide : public onde
{
private:
// La fonction pour la forme de la sinusoide
virtual void forme(double);
public:
sinusoide();
(...)
}
void sinusoide::forme(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
Voila. Ca réponde pas vraiment à la question mais ca me semble plus
logique ainsi.
Je vois bien l'esprit. Effectivement ca colle bien aux notions de la POO
que j'ai pu glanner.
Mais j'ai un doute sur la méthode d'utilisation.
En effet, dans l'utilisation que je compte faire de mon "objet", la forme
d'onde est sensée pouvoir évoluer.
En gros, j'ai un ensemble de générateurs d'ondes (éventuellement avec des
interconnections) et je peux changer la forme d'onde émise par chacun de
ces générateurs sans changer leurs interconncections...
Qu'en penses tu?
Sinon si tu souhaite utiliser le pointeur de fonction il faut mettre :
typedef void (onde::*fptronde) (double);
Pascal
"Pascal Pizeine" <pascal.pizeine@milesys.fr> a écrit
Bonjour,
Ton code ressemble beaucoup à ce que l'on ferait avec du C. Tu ne profite
pas des avantages que peuvent t'offrir l'objet et le C++.
C'est vrai, mais, je débute en C++ et encore plus en objet!
Il m'est difficile de concevoir en objet pour l'instant...
Mais je lis, je teste, j'apprends... J'y arriverais!!!
Je ne pense pas que dans ton cas le pointeur de fonction te soit utile.
Un exemble de code pourrait être le suivant :
Une classe onde générique :
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff;
//Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
// Une fonction virtuelle pure car tu as besoin d'une forme pour ton
onde mais tu es incapable de la définir à ce niveau
virtual void forme(double) = 0;
public:
// Le type d'onde ne sert à rien
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
// Ici tu utilises ta forme d'onde
forme(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Tu spécialise ensuite tes ondes, pour une sinusoide tu auras la classe
suivante :
class sinusoide : public onde
{
private:
// La fonction pour la forme de la sinusoide
virtual void forme(double);
public:
sinusoide();
(...)
}
void sinusoide::forme(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
Voila. Ca réponde pas vraiment à la question mais ca me semble plus
logique ainsi.
Je vois bien l'esprit. Effectivement ca colle bien aux notions de la POO
que j'ai pu glanner.
Mais j'ai un doute sur la méthode d'utilisation.
En effet, dans l'utilisation que je compte faire de mon "objet", la forme
d'onde est sensée pouvoir évoluer.
En gros, j'ai un ensemble de générateurs d'ondes (éventuellement avec des
interconnections) et je peux changer la forme d'onde émise par chacun de
ces générateurs sans changer leurs interconncections...
Qu'en penses tu?
Sinon si tu souhaite utiliser le pointeur de fonction il faut mettre :
typedef void (onde::*fptronde) (double);
Pascal
"Pascal Pizeine" a écritBonjour,
Ton code ressemble beaucoup à ce que l'on ferait avec du C. Tu ne profite
pas des avantages que peuvent t'offrir l'objet et le C++.
C'est vrai, mais, je débute en C++ et encore plus en objet!
Il m'est difficile de concevoir en objet pour l'instant...
Mais je lis, je teste, j'apprends... J'y arriverais!!!Je ne pense pas que dans ton cas le pointeur de fonction te soit utile.
Un exemble de code pourrait être le suivant :
Une classe onde générique :
class onde
{
private:
double Amp, *PAmp, Freq, *PFreq, Deph, *PDeph, Off, *POff;
//Amplitude
Frequence déphasage offset (numériques fixes) et pointeurs associés.
// Une fonction virtuelle pure car tu as besoin d'une forme pour ton
onde mais tu es incapable de la définir à ce niveau
virtual void forme(double) = 0;
public:
// Le type d'onde ne sert à rien
double sortie;
bool zero;
onde();
double CalcSortie(double);
void SetAmplitude(double);
void LieAmplitude(double&);
void SetFrequence(double);
void LieFrequence(double&);
void SetDephasage(double);
void LieDephasage(double&);
void SetOffset(double);
void LieOffset(double&);
};
onde::onde()
{
Amp=FreqÞph=Off=0;
PAmp=&Amp;
PFreq=&Freq;
PDeph=&Deph;
POff=&Off;
}
double onde::CalcSortie(double t)
{
double temp=*PFreq * t;
// Ici tu utilises ta forme d'onde
forme(t);
}
void onde::SetAmplitude(double A)
{
Amp=A;
PAmp=&Amp;
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Tu spécialise ensuite tes ondes, pour une sinusoide tu auras la classe
suivante :
class sinusoide : public onde
{
private:
// La fonction pour la forme de la sinusoide
virtual void forme(double);
public:
sinusoide();
(...)
}
void sinusoide::forme(double t)
{
sortie= *PAmp * sin( *PFreq * t + *PDeph ) + *POff;
}
(...)
Voila. Ca réponde pas vraiment à la question mais ca me semble plus
logique ainsi.
Je vois bien l'esprit. Effectivement ca colle bien aux notions de la POO
que j'ai pu glanner.
Mais j'ai un doute sur la méthode d'utilisation.
En effet, dans l'utilisation que je compte faire de mon "objet", la forme
d'onde est sensée pouvoir évoluer.
En gros, j'ai un ensemble de générateurs d'ondes (éventuellement avec des
interconnections) et je peux changer la forme d'onde émise par chacun de
ces générateurs sans changer leurs interconncections...
Qu'en penses tu?
Sinon si tu souhaite utiliser le pointeur de fonction il faut mettre :
typedef void (onde::*fptronde) (double);
Pascal
"cyrcocq" a écrit dans le message de news:
43329842$0$301$}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Qu'est censée faire cette méthode ?
"cyrcocq" <cyrcocq@...> a écrit dans le message de news:
43329842$0$301$7a628cd7@news.club-internet.fr...
}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Qu'est censée faire cette méthode ?
"cyrcocq" a écrit dans le message de news:
43329842$0$301$}
void onde::LieAmplitude(double &A)
{
PAmp=&A;
}
(...)
Qu'est censée faire cette méthode ?
En gros, j'ai un ensemble de générateurs d'ondes (éventuellement avec des
interconnections) et je peux changer la forme d'onde émise par chacun de
ces générateurs sans changer leurs interconncections...
Qu'en penses tu?
Tu pourrais avoir un objet générateur d'onde dont l'un des membre serait
une onde. Si tu changes de forme d'onde tu modifie cette variable.
En gros, j'ai un ensemble de générateurs d'ondes (éventuellement avec des
interconnections) et je peux changer la forme d'onde émise par chacun de
ces générateurs sans changer leurs interconncections...
Qu'en penses tu?
Tu pourrais avoir un objet générateur d'onde dont l'un des membre serait
une onde. Si tu changes de forme d'onde tu modifie cette variable.
En gros, j'ai un ensemble de générateurs d'ondes (éventuellement avec des
interconnections) et je peux changer la forme d'onde émise par chacun de
ces générateurs sans changer leurs interconncections...
Qu'en penses tu?
Tu pourrais avoir un objet générateur d'onde dont l'un des membre serait
une onde. Si tu changes de forme d'onde tu modifie cette variable.
"Targeur fou" a écritcyrcocq wrote:
En fait, je voulais dire: dois-je vraiment définir un type sachant qu'il
n'y aura qu'un membre de la classe qui se servira de ce type?
typedef void (onde::*fptronde) (double);
fptronde fonction [5];
Attention, il s'agit d'une définition de type "pointeur vers fonction
membre de la classe onde". Tu n'a pas d'instance de ce pointeur de
fonction mais un tableau de pointeurs vers fonctions membres qui
s'appelle fonction.
Mais? ce tableau de pointeur est bien instancié à chaque création d'un de
mes objets?
En cherchant un peu je me suis dit que je devais modifier comme ça:
static fptronde fonction [5];
Ai je raison?
De toutes façons, dans un cas comme dans l'autre, je n'arrive pas à
effectuer mon appel!!!
fonction[type] (t);
error C2064: le terme ne correspond pas à une fonction
J'ai essayé je ne sais combien de syntaxes avec des "this" et des "onde",
avec des "::" et des "." et des "->"
Ca ne veut rien savoir!
"Targeur fou" <rtroadec@yahoo.fr> a écrit
cyrcocq wrote:
En fait, je voulais dire: dois-je vraiment définir un type sachant qu'il
n'y aura qu'un membre de la classe qui se servira de ce type?
typedef void (onde::*fptronde) (double);
fptronde fonction [5];
Attention, il s'agit d'une définition de type "pointeur vers fonction
membre de la classe onde". Tu n'a pas d'instance de ce pointeur de
fonction mais un tableau de pointeurs vers fonctions membres qui
s'appelle fonction.
Mais? ce tableau de pointeur est bien instancié à chaque création d'un de
mes objets?
En cherchant un peu je me suis dit que je devais modifier comme ça:
static fptronde fonction [5];
Ai je raison?
De toutes façons, dans un cas comme dans l'autre, je n'arrive pas à
effectuer mon appel!!!
fonction[type] (t);
error C2064: le terme ne correspond pas à une fonction
J'ai essayé je ne sais combien de syntaxes avec des "this" et des "onde",
avec des "::" et des "." et des "->"
Ca ne veut rien savoir!
"Targeur fou" a écritcyrcocq wrote:
En fait, je voulais dire: dois-je vraiment définir un type sachant qu'il
n'y aura qu'un membre de la classe qui se servira de ce type?
typedef void (onde::*fptronde) (double);
fptronde fonction [5];
Attention, il s'agit d'une définition de type "pointeur vers fonction
membre de la classe onde". Tu n'a pas d'instance de ce pointeur de
fonction mais un tableau de pointeurs vers fonctions membres qui
s'appelle fonction.
Mais? ce tableau de pointeur est bien instancié à chaque création d'un de
mes objets?
En cherchant un peu je me suis dit que je devais modifier comme ça:
static fptronde fonction [5];
Ai je raison?
De toutes façons, dans un cas comme dans l'autre, je n'arrive pas à
effectuer mon appel!!!
fonction[type] (t);
error C2064: le terme ne correspond pas à une fonction
J'ai essayé je ne sais combien de syntaxes avec des "this" et des "onde",
avec des "::" et des "." et des "->"
Ca ne veut rien savoir!
Toujours pas d'amélioration... J'ai pas trouvé une site sur lequel je
pourrais trouver la réponse à mon probléme. Là, j'ai vraiment besoin d'un
coup de main!
Toujours pas d'amélioration... J'ai pas trouvé une site sur lequel je
pourrais trouver la réponse à mon probléme. Là, j'ai vraiment besoin d'un
coup de main!
Toujours pas d'amélioration... J'ai pas trouvé une site sur lequel je
pourrais trouver la réponse à mon probléme. Là, j'ai vraiment besoin d'un
coup de main!