Tu vois, calculer tous les itinéraires, ça n'est pas si long.
Et pourtant, il y en a plein.
Je n'aurais pas dit plein. Ça reste très raisonnable.
1°) Je passe sur le :
static Voie **sVoies;
Je comprends (enfin, je crois), mais ça se complique.
Un pointeur de pointeur…
Oui, je maintiens une table de pointeurs, des Voie* où chaque objet Voie, ou dérivé de Voie vient inscrire son pointeur à l'index de son identifiant. De cette manière, je peux retrouver un objet Voie par son identifiant. Comme je ne sais pas à priori combien d'éléments de voie je vais avoir. Je pars sur 256 et une fois que j'ai tout, je retaille le tableau au nombre d'élément effectif.
2°) je ne comprends pas pourquoi tu dois avoir un creeCheminVers (…) et un tousLesCheminsVers(…) dans chaque classe.
Quand on hérite, on n'hérite pas de tout ?
J'ai laissé creeCheminVers et ajouté tousLesCheminsVers à côté mais à terme, creeCheminVers disparaîtra car tousLesCheminsVers fait mieux.
3°) Là, je décroche :
static const byte taille() {
return ((sNombre >> 3) + ((sNombre & 7) != 0));
Je comprends (grosso-modo) la syntaxe, mais pourquoi tu fais ça ?
Ok. Comme je l'ai dit, je gère un vecteur de bits. Là je calcule la taille en nombre d'octets du tableau nécessaire au stockage de ce vecteur. sNombre est le nombre de bits nécessaires, sNombre >> 3 correspond à une division par 8 (2^3 = 8)et donc au nombre d'octets. Mais c'est une division entière. Si sNombre n'est pas divisible par 8 j'ai un reste et j'ai besoin d'un octet de plus. sNombre & 7 est le reste de la division. Si il est différent de 0, je dois avoir un octet de plus et c'est çe que je calcule puisque le != 0 me renvoie 1 si il y a un reste et 0 sinon.
4°) Et ailleurs, encore mieux (mais je ne comprends plus la syntaxe) :
void EnsembleDeVoies::ajouteVoie(byte identifiant)
{
mEnsemble[identifiant >> 3] |= 1 << (identifiant & 7);
}
Pareil. Je veux mettre à 1 le bit de rang identifiant. Je divise identifiant par 8 pour avoir l'octet puis sur cet octet je fais un ou avec un 1 décalé du reste.
void EnsembleDeVoies::enleveVoie(byte identifiant)
{
mEnsemble[identifiant >> 3] &= ~(1 << (identifiant & 7));
}
bool EnsembleDeVoies::contientVoie(byte identifiant)
{
return (mEnsemble[identifiant >> 3] & 1 << (identifiant & 7)) != 0;
}
Et là auss, je mets le bit a 0 et je le teste.
5°) Tu as marqué un commentaire, c'est vrai, mais pour comprendre, là, c'est costaud :
/* Si sVoies n'est pas alloue, alloue arbitrairement 256 emplacements */
if (sVoies == NULL) {
sVoies = (Voie **)malloc(sTailleTableau * sizeof(Voie **));
}
malloc alloue une zone mémoire comptée en nombre d'octets. Ici je veux allouer sTailleTableau pointeurs. Un pointeur a une taille de sizeof(Voie **) octets. Je caste le resultat qui est un void * en Voie **
Et, la plus drôle pour la fin : le loop() est ... vide !
Tout est fait dans setup :-)