Bonjour a tous, je voudrais créer un type de variable a une taille defini.
L'avantage serait que la variable reviendrait a zéro toute seule si elle dépasse sa taille,
et inversement elle prendrait sa valeur maximale en passant en dessous de zéro.
Sans avoir a s'embêter avec des ifs ou des modulos.
Par exemple pour un type qui ne contiendrait que 8 chiffres ce code donnerait comme valeurs successives a ma variable 1, 5, 6, 2, 3, 7, 0, 4...etc
monType maVariable=0; //crée une variable allant de 0 a 7
void loop(){
maVariable++;//incremente la variable de 1
delay(50);
maVariable+=4;//incremente la variable de 4
delay(50);
}
De manière générale non - la mémoire minimum pour une variable c'est l'octet même s'il faut moins de place pour stocker la variable. Si vous avez plusieurs "petites" variables vous pouvez les grouper et utiliser une structure et des champs de bits avec cette notion de min/max
Pour la seconde question, oui vous pouvez "cacher" la complexité des modulos et/ou des if, créez une classe C++ où quand vous instanciez un objet vous donnez sa valeur min et max et éventuellement surchargez les opérateurs classiques pour définir le comportement que vous souhaitez
très intéressante cette structure de variables en bits.
j'ai joué avec et c'est vraiment bien.
une variable (déclarée en 3 bits) incrémentée au pas de 1 à chaque passage dans la loop passe de 7 à 0
ou de 0 à 7 si elle est décrémentée.
intéressante par exemple pour incrémenter/décrémenter un compteur.
mais supposons que je veuille mettre un affichage de l'heure ( réglage d'une alarme par BP, par exemple)
je peux déclarer une variable sur 4 bits qui passera de 31 à 0 et de 0 à 31
mais comme il n'y a que 24 heures...........
y a t'il un moyen pour limiter la possibilité d'incrémentation à 24 bien qu'avec 4 bits, je puisse compter jusqu'a 31.
je veux dire sans avoir recours à un test du genre si >23 alors =0
struct S {
// will usually occupy 2 bytes:
// 3 bits: value of b1
// 5 bits: unused
// 6 bits: value of b2
// 2 bits: value of b3
//unsigned char b1 : 5,:11;// 11 bits: unused
unsigned char b1 : 2;
//unsigned char :0; // start a new byte
unsigned char b2 : 4;
unsigned char :0; // start a new byte
unsigned char b3 : 2;
unsigned char b4 : 5 ;
}; S nombre;//={0,0,0,0};
void setup() {
Serial.begin(115200);
}
void loop() {
nombre.b1 --;
Serial.print("b1 = ");Serial.println(nombre.b1);
Serial.print("b2 = ");Serial.println(nombre.b2);
Serial.print("b3 = ");Serial.println(nombre.b3);
Serial.print("b4 = ");Serial.println(nombre.b4);
delay(1000);
}
Non c'est l'objet de mon second point, si vous voulez faire cela de manière "cachée" il faut créer une classe spéciale et surcharger les opérateurs classiques
@JML
je viens de tester, c'est quand même très lourd. puissant mais lourd...
dans le cas que j'évoquais, le + simple est quand même de comparer à 23 ( pour les heures)
en tout cas, merci pour les infos, je serai moins c.n ce soir
