C++ : heriter plusieurs fois de la même classe ...

[destroyedlolo]

Bonjour et bonne année,

Question sans doute bête mais bon ...

J'ai une classe keepInRTC dont le but est de sauvegarder zone mémoire dans la mémoire RTC d'un ESP8266 et qui ressemble à ca :

class keepInRTC {
		uint32_t *what;
		uint32_t size;
		uint32_t offset;

	protected:
		keepInRTC( Context &ctx, uint32_t *w, uint32_t s ) : what(w), size(s) {
		/* ->	ctx : context managing the RTC memory
		 * 		w : which data to save
		 * 		s : size of the data to save
		 */
			this->offset = ctx.reserveData( s );

			if(ctx.isValid())	// previous data can be retrieved
				ESP.rtcUserMemoryRead(this->offset, this->what, this->size);
		}

	public:
		void save( void ){
			ESP.rtcUserMemoryWrite( this->offset, this->what, this->size );
		}
	};

J'ai une seconde classe Repeater qui l'utilise pour sauvegarder ses propres données,

class Repeater : public Context::keepInRTC {
	unsigned long int next;	// next run
	unsigned long int interval;
	Context &context;

public:
	virtual void action( void ) = 0;	// Which action to launch

	Repeater( Context &ctx, unsigned long int aint, bool now=false) : Context::keepInRTC( ctx, (uint32_t *)&next, sizeof(next) ), interval( aint ), context( ctx ) {
	/* <- aint : interval b/w launches (ms)
	 * 	now : if the action has to be launched now
	 */
		if(!ctx.isValid()){	// 1st run, default values
			if(!now)
				this->next = context.getTime() + interval;
			else
				this->next = 0;
			this->save();
		}
	}

	void loop( void ){
		if( context.getTime() > this->next ){
			this->action();
			this->next = context.getTime() + interval;
			this->save();
		}
	}

	unsigned long int remain(void){
	/* Return the duration before the next activation
	 * in mS
	 */
		if(context.getTime() > this->next)
			return 0;
		else
			return( this->next - context.getTime() );
	}
};

Et j'ai une 3e qui hérite de Repeater mais qui doit aussi sauvegarder ses propres données. Ce qui donne

class Auxiliaires : public Repeater, public Context::keepInRTC {
	struct {
		unsigned long int wait4stab;	// Wait for the capacitor to load
	} tokeep;	// data to be kept

public:
	Auxiliaires( Context &ctx ) : 
		Repeater( ctx, (INTERVAL_AUX-10) * 1e3, true ),
		Context::keepInRTC( ctx, (uint32_t *)&tokeep, sizeof(tokeep) ),
		context( ctx ), 
		gpio( context.getOWBus(), DSADDR ){
			if( !ctx.isValid() )	// Default value
				tokeep.wait4stab = DELAY_AUX;
		}
};

Sauf que GCC me renvoie le warning suivant :

sketch/Auxiliaires.h:16:7: warning: direct base 'Context::keepInRTC' inaccessible in 'Auxiliaires' due to ambiguity [enabled by default]
class Auxiliaires : public Repeater, public Context::keepInRTC {

Et du coup, j'ai peur qu'il ne face pas ce que je cherche a faire, c'est à dire avoir à la fois le contenu du Repeater et celui de Auxiliaires.

Une idée ?

Merci

Laurent
-----

[destroyedlolo]

Bon ben ... il m'est impossible d'appeler une des méthodes de keepInRTC ...
Donc du coup, ce n'est plus qu'un simple warning, c'est une grosse erreur empêchant la compilation

[pm42]

Déjà, j'ai du mal à comprendre pourquoi Auxiliaires doit hériter de KeepInRtc en plus de Repeater.

Dans ce cas là, chaque classe surcharge la méthode save et dedans fait son traitement propre et appelle celle du dessus, avant ou après suivant le cas.
Et on fait la même chose pour load.

Dans les rares cas où on a vraiment besoin d'hériter d'une classe de base plusieurs fois, soit on en fait une classe abstraite soit on fait de l'héritage virtuel : https://www.ljll.math.upmc.fr/coursc...Sect08-E3.html

Ce qu'il faut éviter en général vu les emmerdes...

Enfin, c'est bizarre de nommer tes classes en mélangeant français et anglais (Repeater et Auxiliaires notamment)

[destroyedlolo]

Merci de te pencher sur mon pb

Déjà, j'ai du mal à comprendre pourquoi Auxiliaires doit hériter de KeepInRtc en plus de Repeater.

Sur les ESP, la mémoire n'est pas conservée lorsqu'on place la puce en DeepSleep, sauf ce qu'on met explicitement en mémoire dite RTC.
KeepInRtc a pour but de sauvegarder dans le RTC le contenu des objets dont il hérite donc :

• lorsque qu'il est hérité par Repeater, il sauvegarde Repeater::next
• lorsqu'il est hérité par Auxiliaires, il devrait sauvegarder la structure Auxiliaires::tokeep

Auxiliaires hérite des 2 car ses tâches ont besoin d'être répétées (donc besoin de sauvegarder les données propres Repeater) et de sauvegarder ses propres données.

Dans les rares cas où on a vraiment besoin d'hériter d'une classe de base plusieurs fois, soit on en fait une classe abstraite soit on fait de l'héritage virtuel : https://www.ljll.math.upmc.fr/coursc...Sect08-E3.html

Le problème est que si je fais un héritage virtuel, je ne vais in fine ne sauvegarder que le dernier contenu (donc j'imagine Auxiliaires::tokeep) et perdre les informations de Repeater.

Enfin, c'est bizarre de nommer tes classes en mélangeant français et anglais (Repeater et Auxiliaires notamment

Ce qui est en anglais est réutilisable dans d'autres projets, alors que le francais n'est que ce qui est spécifique à mon projet.
Mais je renome le tokeep en aconserver pour etre un minimum cohérent.

[A voir en vidéo sur Futura]

[pm42]

Tout ce que tu décris me semble rentrer dans ma réponse.

[destroyedlolo]

Oui, mais du coup, il faut connaitre l'implementation de la sauvegarde des autres objets.
Mais bon, en réfléchissant un peu j'ai trouvé : plutot que d'hériter une nouvelle fois de KeepInRtc, j'ai créer un objet supplémentaire dans Auxiliaires et ca marche.

Bonne soirée.

[pm42]

Oui, mais du coup, il faut connaitre l'implementation de la sauvegarde des autres objets.

Pas forcément. Tout dépend du protocole de sauvegarde : si tu peux appeler plusieurs fois, tu appeler <Superclasse>::save.
Sinon, tu crée un objet auxiliaire que tu dérives et remplit incrémentalement dans chaque sous classe.
Ou bien, chaque classe crée incrémentalement sa sauvegarde dans une structure adapté via le pattern Memento et tu sauves le dit Memento.

[destroyedlolo]

Pas forcément. Tout dépend du protocole de sauvegarde : si tu peux appeler plusieurs fois, tu appeler <Superclasse>::save.

Ca, ca ne marcherait pas car la sauvegarde n'est pas hardcodé dans la fonction, c'est la classe qui hérite qui fournis ces infos dans le constructeur de keepInRTC et sauvegardé dans des champs "locaux".

Sinon, tu crée un objet auxiliaire que tu dérives et remplit incrémentalement dans chaque sous classe.

Oui, ca ca pourrait fonctionné.

Ou bien, chaque classe crée incrémentalement sa sauvegarde dans une structure adapté via le pattern Memento et tu sauves le dit Memento.

Par contre, c'est quoi le "pattern Memento" ?

[pm42]

Par contre, c'est quoi le "pattern Memento" ?

Un mécanisme général pour gérer les sauvegardes/restaurations quelque soit le format de la classe de départ. Et qui peut être instancié pour différent formats de sauvegarde.
En gros, ta classe implémente un save(Memento& memento) et elle écrit ses données dedans en appelant des méthodes qui couvrent les types de base et éventuellement des collections, etc. Le memento peut sauver en mémoire, dans une base de données, dans du XML suivant son type réel...

Tu as plus d'infos ici : https://fr.wikibooks.org/wiki/Patron...eption/Mémento
https://en.wikipedia.org/wiki/Memento_pattern

Globalement, si tu ne connais pas les patterns courant, jette un oeil là : https://fr.wikipedia.org/wiki/Patron_de_conception
C'est très intéressant.

[destroyedlolo]

Merci, je vais regardé avec attention.

[CM63]

Bonjour,

Dans ce cas il ne faut pas faire de l'héritage mais de l'agrégation.