Demande d'avis de professionnels concernant les const.
Bonjour,
Voici le code que j'ai écrit, pour pratiquer... mais en le regardant je me demande deux trois choses. Mais d'abord le code:
Code:
1
2
3
4
5
6
7
8
9
10
| Fichier h
class Motor
{
float PWM_Freq;//Pulse Width Frequency
float CalculatePWMFreq(const float &Value) const;//Calculate the pwm frequency versus voltage
public:
Motor(const float &InitPWM_Freq);//constructeur
bool SetPWM_Freq(const float &ValueVDOUT);
float GetPWM_Freq() const;
}; |
Code:
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
|
fichier cpp
#include "stdafx.h"
#include "Fichier.h"
#include <iostream>
bool Motor::SetPWM_Freq(const float &Value)
{
float result = CalculatePWMFreq(Value);
return true
}
float Motor::GetPWM_Freq() const
{
return PWM_Freq;
}
Motor::Motor(const float &Value)
{
SetPWM_Freq(Value);
}
float Motor::CalculatePWMFreq(const float &VoutNeeded) const
{
float result = (VoutNeeded * 0.5 * 1000);
std::cout << result << std::endl;
return result;//fake calculation
} |
Voilà, est-ce que phylosophiquement c++ parlant ce code vous semble propre?
Parce qu'avec tout ces const on protége le code mais n'y en-a-t-il pas trop?
Merci par avance pour vos interventions.
Modif. selon remarques et précisions
Bonjour,
Merci pour vos réponses! J'ai beaucoup bossé ce matin pour comprendre ce que vous disiez.
Je précise que ceci n'est qu'un exemple pour me faire une idée et pas une vrai application, bien que je vais sans doute m'en inspirer pour une réalisation future.
Aussi je désirai aller un peu plus loin dans mon travail.
J'ai donc modifié le code pour pouvoir travailler avec une sortie analogique ''virtuel'' et pouvoir définir ce que je veux dessus. Par exemple un moteur ou créer un potentiomètre digital ou autre... ici j'ai choisi un moteur en résumé.
Ce moteur à des valeurs en dures de base, à savoir une tension max (et aussi une min comme ca on est dans les deux limites) et je voulais pouvoir définir mes limites de sorties analogiques avec ces valeurs de moteur.
J'ai donc coder le truc suivant, en essayant d'utiliser des pointeurs pour pointer sur l'objet sortie analogique. Voici:
Code:
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
| Fichier AnalogicVoltage.h
class Analogic_Voltage
{
float m_Max_Voltage;
float m_Min_Voltage;
float New_PWMRatio;//New needed PWM Frequency
float Actual_PWMRatio;//Actual PWM Frequency
float Actual_Voltage;//Actual PWM Voltage
public:
Analogic_Voltage(float const &InitPWM_Freq, float *MinVoltage, float *MaxVoltage);//constructeur
bool Change_Voltage(float const&PWMRatio);
bool ChangeMINMAX(float const&MIN, float const&MAX);
float Get_Voltage() const;
float Get_PWMRatio() const;
};
static struct Motor
{//définitions spécifique pour un moteur
float *pointeurMax;
float *pointeurMin;
float m_Max_Voltage;
float m_Min_Voltage;
}; |
Code:
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
| fichier AnalogicVoltage.cpp
#include "stdafx.h"
#include "AnalogicVoltage.h"
#include <iostream>
bool Analogic_Voltage::Change_Voltage(float const &NewPWMRatio)
{
float VoltageCalc = (NewPWMRatio * 0.005);
std::cout << "Voltage to set:" << std::endl;
std::cout << VoltageCalc << std::endl;
std::cout << "Voltage Min.:" << std::endl;
std::cout << m_Min_Voltage << std::endl;
std::cout << "Voltage Max.:" << std::endl;
std::cout << m_Max_Voltage << std::endl;
if (m_Min_Voltage < VoltageCalc && VoltageCalc < m_Max_Voltage)
{
Actual_Voltage = VoltageCalc;
Actual_PWMRatio = NewPWMRatio;
Get_Voltage();
Get_PWMRatio();
return true;//fake calculation
}
else
{
std::cout << "Error in Voltage calculation" << std::endl;
std::cout << "Result Voltage :" << std::endl;
std::cout << VoltageCalc << std::endl;
return false;
}
}
bool Analogic_Voltage::ChangeMINMAX(float const &MIN, float const &MAX)
{
m_Min_Voltage = MIN;
m_Max_Voltage = MAX;
std::cout << "Voltage Min.:" << std::endl;
std::cout << m_Min_Voltage << std::endl;
std::cout << "Voltage Max.:" << std::endl;
std::cout << m_Max_Voltage << std::endl;
return true;
}
Analogic_Voltage::Analogic_Voltage(float const &m_InitPWMRatio, float *m_MinVoltage, float *m_MaxVoltage)
{
m_Min_Voltage = *m_MinVoltage;
std::cout << m_Min_Voltage << std::endl;
m_Max_Voltage = *m_MaxVoltage;
std::cout << m_Max_Voltage << std::endl;
Change_Voltage(m_InitPWMRatio);
}
float Analogic_Voltage::Get_Voltage() const
{
std::cout << "Actual Voltage :" << std::endl;
std::cout << Actual_Voltage << std::endl;
return Actual_Voltage;
}
float Analogic_Voltage::Get_PWMRatio() const
{
std::cout << "Actual PWM Ratio:" << std::endl;
std::cout << Actual_PWMRatio << std::endl;
return Actual_PWMRatio;
} |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| Fichier Main
#include "stdafx.h"
#include "AnalogicVoltage.h"
#include <iostream>
void main()
{
using namespace std;
float value;
Motor Moteur1;
Moteur1.m_Max_Voltage = 12; //on définit les valeurs
Moteur1.m_Min_Voltage = 1;
Moteur1.pointeurMin = &Moteur1.m_Min_Voltage;//on pointe sur les valeurs
Moteur1.pointeurMax = &Moteur1.m_Max_Voltage;
Analogic_Voltage AN_Output1(200, Moteur1.pointeurMin, Moteur1.pointeurMax);//on passe les paramètres de la structure pour la sortie analogique 1
//AN_Output1.ChangeMINMAX(0, 12);
cout << "Entrez une valeur de frequence d'initialisation: [kHz]" << endl;
std::cin >> value;
AN_Output1.Change_Voltage(value);
system("pause");
} |
Pendant mes tests de ce matin j'ai aussi implémenté une fonction pour changer le minmax de tension dans la sortie analogique mais je l'utilise plus maintenant vu que j'ai une structure moteur pour ca.
J'ai aussi deux questions pour 'Iradrille'.
Dans le code
Code:
1
2
3
| float clamp(float value, float vMin = 0.f, float vMax = 1.f) {
return std::min(vMax, std::max(vMin, value));
} |
Le compilateur me dit que max n'existe pas dans std....
Et aussi pourquoi cette remarque ? // le grand débat des opérations cachées dans un setter :D ?
Merci par avance, j'espère que j'abuse pas trop....
