template, héritage et opérateur surchargé

Version imprimable

13/10/2021, 00h06
Hitsugaya81

3 pièce(s) jointe(s)

template, héritage et opérateur surchargé

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
Pièce jointe 606515
Pièce jointe 606516
Pièce jointe 606517
13/10/2021, 07h07
foetus
Utilises la balise :tagcode: (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 :weird: :koi: :aie:

Citation:

Envoyé par Hitsugaya81

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

Envoyé par Hitsugaya81

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 :koi: ?
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 :aie: :aie: ... et qu'en + tu rajoutes des templates, des opérateurs, ... :roll:
13/10/2021, 10h47
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
13/10/2021, 12h30
foetus

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

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

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

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

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:

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

Citation:

varA = 12;

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

Citation:

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

13/10/2021, 22h59
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 ?

operator =
using ram_vars::operator=;est déjà un 1er point de correction, il me permet d'écrire :
Code:

1 2 3 _uint16_t varsA = _uint16_t(); // instanciation de la classe _uint16_t, classe héritant de ram_vars varA.alloc(); // allocation en ram externe de la place nécessaire et mémorisation de son adresse dans la ram externe varA = 12; // assignation d'une valeur
operator +=

Citation:

Envoyé par jo_link_noir

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 ?

c'est la ligne varsA += varB qui passe par la fonction template et non pas par la fonction "dédiée" si je puis dire
template <typename T> ram_vars &operator+=( const T val ) (ligne 86 dans la classe ram_vars)
au lieu de : ram_vars &operator+=( const ram_vars &val ) (ligne 23 dans la classe ram_vars aussi).

Et c'est là que je ne comprends pas. Pourquoi, en ayant déclarer dans la classe mère, une fonction attendant un paramètre ram_vars, le compilateur passe par la fonction utilisant un type non défini template

14/10/2021, 13h23
Hitsugaya81

OK. J'ai compris pourquoi. Ce n'est pas vraiment une erreur.
Dans la ligne varsA += varB, varsA et varsB sont de type _uint16_t qui n'est pas un type standard. C'est la classe _uint16_t qui hérite de ram_vars

Au lieu de passer par la fonction ram_vars &operator+=( const ram_vars &val ),
le compilateur fait (pour moi) un détour en utilisant la fonction :
template <typename T> ram_vars &operator+=( const T val ).

pourquoi : car la classe _uint16_t dispose d'une fonction supplémentaire qui est :
operator uint16_t() const ;.

cette fonction est nécessaire si je veux pourvoir écrire par exemple :
double varStandard = varsA;.

en gros, au lieu de faire : varsA = operator+=( ram_vars varsB ),
il passe par : varsA = operator+=( operator uint16_t varsB ).

comment puis-je obliger le compilateur à utiliser la fonction ram_vars &operator+=( const ram_vars &val )
14/10/2021, 20h19
dalfab
Bonjour,

Les deux operateurs += que tu définis sont:
Code:

1 2 ram_vars &operator+=( const ram_vars &val ); template <typename T> ram_vars &operator+=( const T val );
Quand tu fais: varA += varB;, il doit choisir la fonction qui effectue le moins de conversions.
Pour les 2, l'objet courant est déduit de la conversion _uint16_t& en ram_vars&, ensuite:
- La 1^ère doit convertir _uint16_t& en sa classe de base const ram_vars&, c'est trivial mais c'est une conversion.
- La 2^nde ne demande aucune conversion en prenant T === _uint16_t.
Il n'y a donc aucune ambiguïté, il faut prendre la seconde!
Si les fonctions étaient totalement équivalentes, il aurait choisi la non template, mais sinon le compilateur doit toujours choisir la "meilleure".

Quand tu as écrit T, tu pensais à des types particuliers, le compilateur ne peut pas deviner lesquels. Il faut le lui indiquer. Tu peux utiliser les concept (en C++20) ou std::enable_if<>. Par exemple pour te limiter aux types arithmétiques:
Code:

1 2 3 4 #include<type_traits> template<typename T,std::enable_if_t<std::is_arithmetic_v<T>,int> =0> ram_vars &operator+=( const T val ); // s'attend à int, long, double, ...