Discussion :

[lupus5]

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 :

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

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 :

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
 
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.

[ternel]

En avant propos, j'ai l'usage de mettre le const à droite du type qu'il qualifie (comme c'est le cas normalement).
Ca a l'avantage de regrouper ensemble le const et la référence. Ce qui tombe bien car on parle (par abus, certes) de référence constante.

float const& n'est pas nécessaire, car le float est de la même taille qu'une référence, et le compilateur fait tout seule la substitution.
La fonction CalculatePWMFreq n'est pas liée à un moteur particulier, elle pourrait être statique. D'ailleurs, j'aurai tendance à la nommer voltage_to_PWF.

De cette façon, ton constructeur pourrait s'écrire ainsi:

Code :

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

Motor::Motor(float voltage): PWM_Freq(voltage_to_PWF(voltage)) {}

Tu devrais probablement nommer la fonction SetPWM_Freq, qui est son fonctionnement, mais use_voltage qui est son usage, son rôle.
D'un point de vue code, cette fonction est très mal écrite, puisqu'elle n'affecte pas PWM_Freq.

Sinon, du point de vue constance, c'est correctement construit.
Les fonctions de lecture sont marquées const, et les arguments sont en références constantes.

J'aurai ajouté des usings, afin de dénoter plus efficacement que les fonctions prennent ou retournent des voltages ou des fréquences.

Code :

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

1
2
3
public:
    using voltage_type = float;
    using pwf_type = float;//pulse width frequency

[Iradrille]

Pour rajouter à ce que dit @leternel.

Les const, yen a jamais assez.

Ta fonction CalculatePWMFreq va utiliser des valeurs qui devraient être extraites (tension de sortie au strict minimum, probablement une fréquence aussi). Et cette fonction n'a rien à voir avec un moteur : c'est une simple fonction utilitaire.

Aussi je stockerais les 3 valeurs (tension demandée / nombre de cycles à 0 / nombre de cycles à 1) dans ta classe Moteur.

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
31
32
float const FREQ = 1'000'000.f; // fréquence µC : 1MHz
float const PWM_FREQ = 1'000.f; // fréquence PWM : 1KHz
float const PWM_RATIO = FREQ / PWM_FREQ;
float const VOUT = 5.f; // tension de sortie : 5V
 
float clamp(float value, float vMin = 0.f, float vMax = 1.f) {
    return std::min(vMax, std::max(vMin, value));
}
 
float pwm(float value) {
    return clamp(value / VOUT) * PWM_RATIO;
}
 
// peut etre une classe PWM si plusieurs choses l'utilisent.
class Motor {
    float m_value; // tension demandée
    int m_at1; // nb de cycles à 1 - float éventuellement
    int m_at0; // nb de cycles à 0 - float éventuellement
 
public:
    float value() const { return m_value; }
    int at1() const { return m_at1; }
    int at0() const { return m_at0; }
 
    // le grand débat des opérations cachées dans un setter :D
    void value(float v) {
        m_value = v;
        auto p = pwm(v);
        m_at1 = int(p);
        m_at0 = int(PWM_RATIO - p);
    }
};

[lupus5]

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 :

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
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 :

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
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 :

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
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 :

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

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 ?

Merci par avance, j'espère que j'abuse pas trop....

[Iradrille]

Les floats ça sert à rien de les passer par const ref. Les passer par copie est plus simple / rapide.
Ton cafouillage avec des pointeurs est inutile aussi : copie tes floats.

Si c'est pour une histoire de performance, copier tes float sera plus rapide; sinon la règle est simple :
- type primitif (ou objet de max 8 octets) -> copie.
- Le reste -> const ref.

Le compilateur me dit que max n'existe pas dans std....

Ils sont dans <algorithm>. Faut penser à l'inclure.

Et aussi pourquoi cette remarque ? // le grand débat des opérations cachées dans un setter ?

Quand on fait foo.setBar(); on s'attend à modifier l'attribut bar (et seulement celui là). Hors ici d'autres traitements sont fait.
Certains trouvent ça acceptable, d'autres non. C'est un débat qui revient de temps en temps ici.

[ternel]

D'ailleurs, je te recommande d'utiliser un site de référence du langage, tel que

• cplusplus.com
• cppreference.com

Le second est mon préféré, et les deux ne sont pas strictement équivalent dans leurs explications.
Par contre, ils sont d'accord (normalement)

Je t'invite notamment à apprendre ce qu'on peut trouver dans <algorithm>.
La syntaxe est un détail, j'y retourne souvent, mais ce sont de nombreuses fonctions utiles à connaitre.

[lupus5]

rebonjour,
Et encore merci pour vos réponses, elles me sont précieuses!!
J'ai lu un peu les get set are evils et je vois mieux le problème. J'ai également mis en bookmarks vos liens (leternel)
J'avais encore une petite question sur les class static. peut-on faire ceci:

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
Fichier cpp
//Motor object
Motor::Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed) //constructeur
{
	if (TestInput::DoTest(MinVoltage, MaxVoltage))
	{
		m_Min_Voltage = MinVoltage;
		m_Max_Voltage = MaxVoltage;
		m_Min_Speed = MinSpeed;
		m_Max_Speed = MaxSpeed;
	}
	else std::cout << "Erreur d'initialisation! " << '\n';
}
 
bool TestInput::DoTest(float const&MinValue, float const&MaxValue)
{
	if (MinValue >= 0 && MaxValue > 0)
	{
		return true;
	}
	else
	{
		std::cout << "Erreur d'initialisation! " << '\n';
		return false;
	}
}

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
Fichier h
struct Motor
{//définitions spécifique pour un moteur tout public
		float m_Max_Voltage;
		float m_Min_Voltage;
 
		int		m_Max_Speed;
		int		m_Min_Speed;
 
		Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed);//constructeur
};
 
static class TestInput
{
public:
static 	bool DoTest(float const&min, float const&max);
};

Je sais qu'il y a sûrement une class static définie pour faire cela mais c'est juste pour sa voir si c'est correct, sachant que la class testInput est visible de tous et le struct également. les principes d'encapsulation ne sont pas bien respectés mais peut-on faire mieux?

Merci encore et belle journée!

[ternel]

le static devant la déclaration de class est le même que devant la déclaration d'une variable.
C'est une erreur, car en C++, il vaut mieux utiliser un namespace anonyme.

Ton code serait plutot:

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
Fichier h
struct Motor
{//définitions spécifique pour un moteur tout public
		float m_Max_Voltage;
		float m_Min_Voltage;
 
		int		m_Max_Speed;
		int		m_Min_Speed;
 
		Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed);//constructeur
};
 
namespace{ 
class TestInput
{
public:
static 	bool DoTest(float const&min, float const&max);
};

Cependant, cette classe pourrait aussi être définie dans le .cpp correspondant à ce .h
Le sens de ce static étant le contraire de extern.

en tant que paramètre de lien (il y a un mot spécifique, que j'ai oublié), static signifie "chaque unité de compilation possède son propre exemplaire, mais il y a des problèmes". le namespace anonyme, lui, signifie en résumé "chaque unité de compilation possède son propre exemplaire, mais sans les problèmes de static"
extern au contraire signifie "toutes les unités de compilation utilisent le même exemplaire, une seule d'entre elle le définit".
Et quand on ne précise pas (ce qui est a peu près toujours le cas), ca dépend de la chose, un type ou une fonction est déclarée extern.
Une variable non marquée extern est définie par sa "déclaration", ce qui contrevient avec la règle de la définition unique (ODR = One Definition Rule).

[ternel]

Sinon, pour répondre à ta question pratique, une fonction indépendante (fonction libre ou membre statique) qui:

• prend deux nombres nommés min et max
• vérifie que les deux sont positifs
• ecrit dans std::cout en cas d'erreur
• retourne le résultat de la vérification

N'est pas une bonne fonction, car elle mele plusieurs problèmes.
elle fait un controle, c'est bassement technique.
elle affiche un message dans cout, c'est donc une fonction écrite par le code dit "métier".
La pertinance du test par rapport au nom de la fonction est à vérifier.

Il y a en fait deux fonctions, de niveaux différentes:

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
 
typedef float voltage_type;
 
inline bool vérification_voltage(voltage_type v) {
    return v>=0;
}
 
inline bool test_input(voltage_type min, voltage_type max) {
    return vérification_voltage(min) && vérification_voltage(max) && min < max;
}
 
inline bool check_input(voltage_type min, voltage_type max) {
    bool res = test_input(min, max);
    if (!res) std::cout << "Erreur d'initialisation! " << std::endl;
    return res;
}

Pour qu'un constructeur soit bien écrit, il doit lever une exception si les paramètres ne sont pas bons.
Par exemple, j'écrirai ainsi:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//Fichier h
struct Motor {//définitions spécifique pour un moteur tout public
private:
	float m_Max_Voltage;
	float m_Min_Voltage;
 
	int m_Max_Speed;
	int m_Min_Speed;
 public:
	Motor(float MinVoltage, float maxVoltage, int MinSpeed, int MaxSpeed);//constructeur
private:
	template <typename T>
	bool DoTest(T min, T max) {return (MinValue >= 0 && MaxValue > 0 et MinValue >= MaxValue );}
};

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Fichier cpp
#include <stdexcept>
//Motor object
Motor::Motor(float MinVoltage, float MaxVoltage, int MinSpeed, int MaxSpeed):
	m_Min_Voltage(MinVoltage),
	m_Max_Voltage(MaxVoltage),
	m_Min_Speed(MinSpeed),
	m_Max_Speed(MaxSpeed)
{
	if (!DoTest(MinVoltage, MaxVoltage)) throw std::range_error("voltage error");
	if (!DoTest(MinSpeed, MaxSpeed)) throw std::range_error("voltage error");
}

[lupus5]

C'est que j'utilise cette fonction dans une autre class :
et qu'il me fait des erreurs...
mon code: *.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
31
32
33
34
35
36
37
38
39
40
41
class Analogic_Voltage
{
static	int			s_NextIDInstance;
 
		float		m_Max_Voltage;
		float		m_Min_Voltage;
 
		float	m_New_PWMRatio;//New PWM Frequency 
		float	m_New_Voltage;//New needed Voltage
		float	m_Actual_PWMRatio;//Actual PWM Frequency
		float   m_Actual_Voltage;//Actual PWM Voltage
 
public:
static	int		Get_NextIDInst();//get instance ID number
 
		Analogic_Voltage(float const &InitPWM_Ratio, float MinVoltage, float MaxVoltage);//constructeur
 
		bool	Chg_Voltage(float const NewVoltage);
		bool	Chg_MINMAXVolt(float const MIN, float const MAX);
 
		float	Get_Voltage() const;
		float	Get_PWMRatio() const;
};
struct Motor
{//définitions spécifique pour un moteur tout public
		float m_Max_Voltage;
		float m_Min_Voltage;
 
		int		m_Max_Speed;
		int		m_Min_Speed;
 
		Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed);//constructeur
};
namespace
{
	class TestInput
	{
	public:
		static 	bool DoTest(float const&min, float const&max);
	};
}

mon code: *.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
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
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include "stdafx.h"
#include "AnalogicVoltage.h"
#include <iostream>
#include <iomanip>
//static
int Analogic_Voltage::s_NextIDInstance = 1;
int Analogic_Voltage::Get_NextIDInst()
{ 
	std::cout << "Next ID instance: " << Analogic_Voltage::s_NextIDInstance << '\n';
	return s_NextIDInstance;
}
//static end
bool Analogic_Voltage::Chg_Voltage(float const New_Voltage)
{
	if (m_Min_Voltage < New_Voltage && New_Voltage < m_Max_Voltage)
	{
		std::cout << "Voltage to set: " << New_Voltage << '\n';
		std::cout << "Voltage Min.: " << m_Min_Voltage << '\n';
		std::cout << "Voltage Max.: " << m_Max_Voltage << '\n';
		m_New_PWMRatio = (New_Voltage / m_Max_Voltage);
		m_Actual_Voltage = New_Voltage;
		m_Actual_PWMRatio = m_New_PWMRatio;
		Get_Voltage();
		Get_PWMRatio();
		return true;//fake calculation
	}
	else
	{
		std::cout << "Error in PWM calculation " << "Result PWMCalc : " << (New_Voltage / m_Max_Voltage) << '\n';
		return false;
	}
}
bool Analogic_Voltage::Chg_MINMAXVolt(float const MIN, float const MAX)
{
	m_Min_Voltage = MIN;
	m_Max_Voltage = MAX;
	std::cout << "Voltage Min.: " << m_Min_Voltage << '\n';
	std::cout << "Voltage Max.: " << m_Max_Voltage << '\n';
	return true;
}
Analogic_Voltage::Analogic_Voltage(float const &InitPWMRatio, float MinVoltage, float MaxVoltage)//constructeur
{
	if (TestInput::DoTest(MinVoltage, MaxVoltage))
	{
		m_Min_Voltage = MinVoltage;
		std::cout << "Actual Min Voltage: " << m_Min_Voltage << '\n';
		m_Max_Voltage = MaxVoltage;
		std::cout << "Actual Max Voltage: " << m_Max_Voltage << '\n';
		Chg_Voltage(InitPWMRatio);
		s_NextIDInstance++;
	}
	else std::cout << "Erreur d'initialisation! " << '\n';
}
float Analogic_Voltage::Get_Voltage() const
{
	std::cout << "Actual Voltage :" << std::setprecision(3) << m_Actual_Voltage << '\n';
	return m_Actual_Voltage;
}
float Analogic_Voltage::Get_PWMRatio() const
{
	std::cout << "Actual PWM Ratio:" << std::setprecision(3) << m_Actual_PWMRatio << '\n';
	return m_Actual_PWMRatio;
}
//Motor object
Motor::Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed) //constructeur
{
	if (TestInput::DoTest(MinVoltage, MaxVoltage))
	{
		m_Min_Voltage = MinVoltage;
		m_Max_Voltage = MaxVoltage;
		m_Min_Speed = MinSpeed;
		m_Max_Speed = MaxSpeed;
	}
	else std::cout << "Erreur d'initialisation! " << '\n';
}
bool TestInput::DoTest(float const&MinValue, float const&MaxValue)
{
	if (MinValue >= 0 && MaxValue > 0)
	{
		return true;
	}
	else
	{
		std::cout << "Erreur d'initialisation! " << '\n';
		return false;
	}
}

mon code: main

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
// Test_New.cpp : Defines the entry point for the console application.
#include "stdafx.h"
#include "AnalogicVoltage.h"
#include <iostream>
 
void main()
{
	using namespace std;
	float value;
 
	Motor Moteur1(0,12,0,2500);
	Analogic_Voltage AN_Output1(2, Moteur1.m_Min_Voltage, Moteur1.m_Max_Voltage);//on passe les paramètres de la structure pour la sortie analogique 1
	cout << "Entrez une valeur de Tension voulue: [V]" << endl;
	std::cin >> value;
	AN_Output1.Chg_Voltage(value);
	Analogic_Voltage::Get_NextIDInst();
	system("pause");
}

J'aimerai l'utiliser (cette fonction) dans avec l'objet analogic_Voltage aussi.... et je dois avoir accès au min / max dans le main....

Code :

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

Analogic_Voltage AN_Output1(2, Moteur1.m_Min_Voltage, Moteur1.m_Max_Voltage);//on passe les paramètres de la structure pour la sortie analogique 1

Voilà...c compliqué.... j'y réfléchis après mangé.... merci encore!

Voilà ma solution....
dans *.h

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
struct Motor
{//définitions spécifique pour un moteur tout public
		float m_Max_Voltage;
		float m_Min_Voltage;
 
		int		m_Max_Speed;
		int		m_Min_Speed;
 
		Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed);//constructeur
};
template <typename Type>
inline static 	bool ChkUserInput(Type const&MinValue, Type const&MaxValue){ return (MinValue >= 0 && MaxValue > 0); }

dans *.cpp

Code :

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

1
2
3
4
5
6
//Motor object
Motor::Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed) : m_Min_Voltage(MinVoltage), m_Max_Voltage(MaxVoltage), m_Min_Speed(MinSpeed), m_Max_Speed(MaxSpeed)  //constructeur
{
	if (!ChkUserInput(m_Min_Voltage, m_Max_Voltage)) throw std::range_error("Erreur d'initialisation voltage!\n ");
	if (!ChkUserInput(m_Min_Speed, m_Max_Speed)) throw std::range_error("Erreur d'initialisation vitesse!\n ");
}

comme ca c'est une fonction statique que tout le monde peu appeler.... mais côté encapsulation c'est vraiment pas la joie....

Dans le fichier *.h

Code :

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

1
2
3
4
5
6
7
namespace GenSpace
{
	template <typename Type>
	inline static 	bool ChkUserInput(Type const&MinValue, Type const&MaxValue){ return (MinValue >= 0 && MaxValue > 0); }
	template <typename Type>
	inline static   bool ChkNbrInLim(Type const&ValueLimDown, Type const&ValueLimUp, Type const&ValueToEval){ return (ValueLimDown< ValueToEval && ValueToEval<ValueLimUp); }
}

et dans le cpp pour appeler la fonction:

Code :

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

1
2
3
4
5
Motor::Motor(float const&MinVoltage, float const&MaxVoltage, int const&MinSpeed, int const&MaxSpeed) : m_Min_Voltage(MinVoltage), m_Max_Voltage(MaxVoltage), m_Min_Speed(MinSpeed), m_Max_Speed(MaxSpeed)  //constructeur
{
	if (!GenSpace::ChkUserInput(m_Min_Voltage, m_Max_Voltage)) throw std::range_error("Erreur d'initialisation voltage!\n ");
	if (!GenSpace::ChkUserInput(m_Min_Speed, m_Max_Speed)) throw std::range_error("Erreur d'initialisation vitesse!\n ");
}

De plus on empêche la fonction d'être utilisée depuis n'importe où avec le namespace.

Juste??
Merci par avance.