Discussion :

[Hitsugaya81]

Bonjour à tous.
J'ai une formation développeur qui remonte a 10 ans et j'ai des notions qui me manques sans doute sans pouvoir trop savoir quoi...
Je suis en train de me développer un gestionnaire de ram pour Arduino.
Pour ce faire j'ai une classe mère qui contient des opérateur surchargée dont les paramètres sont template.
Les classes filles permettent de forcée le typage lors de l'allocation et d'orienter le fonctionnement.
La classe mère se sert d'une classe statique pour lire et écrire dans la ram.

https://github.com/YannChansigaud/23LC512-SpiRamManager

Donc dans la classe mère j'ai :
Un constructeur qui ne fait rien
Des opérateurs surchargés =, +=, -= etc...

Dans la classe fille j'ai
Un constructeur qui défini le type de variable allouée

Cependant...

MaClass varsA = 5 ; me renvoi une erreur. Me semble pourtant qu'elle doit être prise en charge par l'opérateur surchargé
MaClass varsA += VarsA ; passe par le template au lieu de passer par un opérateur surchargé demandant un paramètre de type MaClasse

Je pense avoir cerner une bonne partie de l'héritage et des template
Mais il se peut que les 2 ensembles, me manque quelques points.

Auriez vous des tutos a me conseiller ?

La librairie :
https://github.com/YannChansigaud/23LC512-SpiRamManager

[foetus]

Utilises la balise (le bouton #) et arrête de mettre des images temporaires.
Cela prend moins de temps à copier-coller du code que créer et héberger 1 image

MaClass varsA = 5 ; me renvoi une erreur. Me semble pourtant qu'elle doit être prise en charge par l'opérateur surchargé

En C++, l'assignation a [au moins] 2 significations :

• l'affection avec l'opérateur = ou peut-être +=
• l'initialisation avec le constructeur

MaClass varsA += VarsA ; passe par le template au lieu de passer par un opérateur surchargé demandant un paramètre de type MaClasse

C'est normal, tu ne comprends pas quoi ?
VarsA est de type entier, ton opérateur non template ne prend pas en paramètre des entiers.

Il y a éventuellement 1 solution avec l'opérateur operator int, mais comme tu galères avec les constructeurs et les types ... et qu'en + tu rajoutes des templates, des opérateurs, ...

[Hitsugaya81]

Désolé, j'ai fais tout ça depuis mon tél avec des images téléchargées depuis mes précédents post sur Facebook.
Mais a l'avenir j'utiliserai les balise code.

Concernant varsA et varsB
Ce ne sont pas des entiers uint16_t mais des _uint16_t (noter le _ underscore)
Et j'ai mal écrit : c'était varsA += varsB

_uint16_t hérité de ram_vars qui est une classe utilisant une ram externe en spi

[foetus]

Je me suis gouré , mais ton histoire d'opérateur virtuel m'a 1 peu titillé

Et effectivement, tu ne peux pas le faire de façon "simple". Il faut regarder sur les Internets, il y a différents façons de faire : proposer 1 opérateur par type, dynamic_cast, "multiple dispatch" (<- Thinking in C++, Bruce Eckel), ...

[Hitsugaya81]

voici le code source.
Téléchargeable ici : https://github.com/YannChansigaud/23LC512-SpiRamManager

Code ram_vars :

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
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
 
 
#ifndef ram_vars_h
#define ram_vars_h
 
class ram_vars {
  public:
    explicit ram_vars(){
 
    };
 
    ~ram_vars(){
      del();
    }
 
// =========================================================== VARS_A and VARS_B manipulation ===============
    ram_vars &operator=(  const ram_vars &val ){
      val.get();
      focus();
      write();
      return( *this );
    }
    ram_vars &operator+=(  const ram_vars &val ){
      Serial.println( "+= ram_vars" );
      val.get();
      focus();
      read();
      RAM.doMath( opCode_addition );
      write();
      return( *this );
    }
    ram_vars &operator-=(  const ram_vars &val ){
      val.get();
      focus();
      read();
      RAM.doMath( opCode_soustraction );
      write();
      return( *this );
    }
    ram_vars &operator*=(  const ram_vars &val ){
      val.get();
      focus();
      read();
      RAM.doMath( opCode_multiplication );
      write();
      return( *this );
    }
    ram_vars &operator/=(  const ram_vars &val ){
      val.get();
      focus();
      read();
      RAM.doMath( opCode_division );
      write();
      return( *this );
    }
    ram_vars &operator++(){
      focus();
      read();
      RAM.doMath( opCode_incrementation, 1 );
      write();
      return( *this );
    }
    ram_vars &operator--(){
      focus();
      read();
      RAM.doMath( opCode_decrementation, 1 );
      write();
      return( *this );
    }
    ram_vars &operator[]( const uint16_t index ){
      focus( index );
      return( *this );
    }
 
 
// =========================================================== VARS_A with std vars type manipulation ===============
 
    template <typename T>   ram_vars &operator=(   const T val ){
      focus();
      read();
      RAM.doMath( opCode_affectation, val );
      write();
      return( *this );
    }
 
    template <typename T>   ram_vars &operator+=(  const T val ){
      Serial.println( "+= template" );
      focus();
      read();
      RAM.doMath( opCode_addition, val );
      write();
      return( *this );
    }
 
    template <typename T>   ram_vars &operator-=(  const T val ){
      focus();
      read();
      RAM.doMath( opCode_soustraction, val );
      write();
      return( *this );
    }
 
    template <typename T>   ram_vars &operator*=(  const T val ){
      focus();
      read();
      RAM.doMath( opCode_multiplication, val );
      write();
      return( *this );
    }
 
    template <typename T>   ram_vars &operator/=(  const T val ){
      focus();
      read();
      RAM.doMath( opCode_division, val );
      write();
      return( *this );
    }
 
    void get(){
      focus();
      read();
    }
 
 
  protected:
    uint16_t add=0;
 
    void focus(){
      if( add ){
        RAM.focus( add );
      }
    }
    void focus( uint16_t index ){
      if( add ){
        RAM.focus( add, index );
      }
    }
    void read(){
      if( add ){
        RAM.read_partB();
      }
    }
    void write(){
      if( add ){
        RAM.write();
      }
    }
 
    bool alloc( uint8_t type, uint16_t q=0 ){
      if( add == 0 ){
        add = RAM.allocNewVar( type, q );
        return( add != 0 );
      }
      return( false );
    }
    void del(){
      focus( 0 );
      RAM.del();
      add = 0;
    }
};
 
#endif

Code _uint16_t, _uint32_t, _double... héritant de ram_vars :

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
 
#ifndef _uint16_t_h
#define _uint16_t_h
 
class _uint16_t : public ram_vars
{
  public:
    void alloc( uint16_t q=0 );
    operator uint16_t() const ;
};
 
#endif
 
 
#ifndef _uint32_t_h
#define _uint32_t_h
 
class _uint32_t : public ram_vars
{
  public:
    void alloc( uint16_t q=0 );
    operator uint32_t() const ;
};
 
#endif
 
 
#ifndef _double_h
#define _double_h
 
class _double : public ram_vars
{
  public:
    void alloc( uint16_t q=0 );
    operator double() const ;
};
 
#endif

Code utilisation :

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
 
  _uint16_t varA = _uint16_t();   // _uint16_t hérite de ram_vars
  _uint16_t varB = _uint16_t();
  _double  varC = _double();
 
  varA.alloc();                   // allocation de son espace en ram externe
  varB.alloc();
  varC.alloc();
 
  varA = 12;                      // erreur, essaye de convertir uint16_t en _uint16_t
  varB = 5;                        // pourquoi la surcharge d'opérateur = de la classe mère ram_vars avec template n'est pas utilisé ?
  varC = 5.7;
 
 
  varA /= 2;                      // serial.print = 6
  varA += varB;                 // ici c'est l'inverse : utilise la l'opérateur surchargé avec template alors que je lui passe un objet _uint16_t qui est donc un objet ram_vars

varA = 12;

le compilateur essaye de convertir uint16_t en _uint16_t
pourquoi il n'utilise pas l'opérateur surchargé = avec template ?

varA += varB

ici c'est l'inverse, je lui passe un objet _uint16_t mais il veut passer par l'opérateur surchargé = avec template alors qu'il a déjà un opérateur surchargé = avec _uint16_t...

[jo_link_noir]

operator= est une fonction spéciale: elle existe automatiquement. Par conséquent, la nouvelle implémentation cache celle de la classe parente et cette dernière ne pas être utilisée directement. Pour contourner cela, il faut ajouter using ram_vars::operator=; dans les classes fille.

Je n'ai pas compris pourquoi varsA += varB utiliserait =. Je ne vois pas non plus de surcharge avec _uint16_t. Quelle est l'erreur exacte ?