[C++]domanda su polimorfismo in C++

[keiler]

Sto facendo un programma per un esame universitario di C++. Praticamente io crea una classe virtuale particel che ha come classi figlie electron e photon. Quel che ho fatto poi è creare un'altra classe interaction in cui definisco 2 metodi:
void interaction(photon)
void interaction(electron).

Ora io nel programma creo una lista di particel in cui ci vado ad aggiungere photon ed electron, poi creo un oggetto interact z e dò il comando
z.interaction(*i) , dove i è l'iteratore che va sulla lista di particel.
Facendo così il compilatore mi dà errore perchè non ho definito il metodo interaction per un particel, ma io pensavo che essendo una classe astratta il compilatore capisse che quel metodo si riferisce alla figlia e non alla madre.
è una cosa impossibile da fare oppure c'è qualche metodo che non sia fare 2 liste separate (di electron e photon).

Grazie in anticipo!

[keiler]

nessuno sa rispondermi?

[fero86]

la soluzione al problema é quella di "scambiare" nel metodo interaction il parametro photon o electron col parametro this. mi spiego meglio visto che questa é solo una frase scritta un po' a cavolo

anziché mettere due metodi interaction nella classe interact, uno per ogni possibile sottoclasse di particel, metti un unico metodo virtuale puro in particel e poi gli dai due implementazioni differenti, una in photon e una in electron. inoltre questo metodo interaction puó accettare come parametro, se necessario, un oggetto della classe interact. poi quando fai l'iterazione invochi tranquillamente il metodo interaction della classe particel visto che iterando ottieni oggetti particel.

recapitolando:
- particel contiene un metodo interaction virtuale puro;
- questo metodo ha un parametro che si riferisce ad un oggetto di tipo interact;
- photon ed electron implementano questo metodo;
- hai una collezione di oggetti particel di cui alcuni sono photon e altri sono electron;
- quando iteri sulla collezione tu vedi semplicemente oggetti particel di cui puoi invocare il metodo interaction passandogli un qualche oggetto interact.

[keiler]

si si questa era una possibile soluzione che mi era venuta in mente,però diciamo che per fare un programma più generale e diciamo più "giusto" dal punto di vista concettuale, vorrei che la classe interaction sia separata da particel, electron e photon. Cioè io faccio delle classi che rappresentano le particelle e un'altra classe che sta fuori che invece rappresenta le possibili interazioni tra queste particelle.

[fero86]

ma con la soluzione che ti ho detto io la classe interaction é separata dalle classi particel, electron e photon; é il metodo interaction che diventa un metodo di particel, electron e photon.

[keiler]

si infatti, quel che intendo dire è che vorrei che il metodo interaction stia nella classe interact, però mi ritrovo quest'ostacolo che ho descritto più sopra T__T

[fero86]

mi spiego meglio con un po' di codice:

class Interaction {
	// ...
};

class Particel {
public:
	virtual void Interact(Interaction&) = 0;
};

class Electron : public Particel {
public:
	virtual void Interact(Interaction&) {
		// ...
	}
};

class Photon : public Particel {
public:
	virtual void Interact(Interaction&) {
		// ...
	}
};


int main() {
	Interaction i;
	list<Particel> Particels;
	// ...
	for_each(Particels.begin(), Particels.end(), [] (Particel &p) {
		p.Interact(i);
	});
	return 0;
}

[fero86]

Originariamente inviato da keiler

si infatti, quel che intendo dire è che vorrei che il metodo interaction stia nella classe interact, però mi ritrovo quest'ostacolo che ho descritto più sopra T__T

ah ok, allora un momento che faccio una modifica al codice: é necessario introdurre un altro metodo (virtuale puro) che sta in Particel e che invoca Interaction::Interaction(*this).

[fero86]

codice aggiornato:

class Electron;
class Photon;

class Interaction {
public:
	void Interact(Electron&) {
		// ...
	}

	void Interact(Photon&) {
		// ...
	}
};

class Particel {
public:
	virtual void Interact(Interaction&) = 0;
};

class Electron : public Particel {
public:
	virtual void Interact(Interaction &i) {
		i.Interact(*this);
	}
};

class Photon : public Particel {
public:
	virtual void Interact(Interaction &i) {
		i.Interact(*this);
	}
};


int main() {
	Interaction i;
	list<Particel> Particels;
	// ...
	for_each(Particels.begin(), Particels.end(), [] (Particel &p) {
		p.Interact(i);
	});
	return 0;
}

[keiler]

ok grazie mille, oggi pomeriggio appena vado a laboratorio lo provo.
Avrei un paio di dubbi se potresti spiegarmi che ci sono cose che non ho fatto durante il corso.

class Electron {
public:
	virtual void Interaction(Interaction &i) {
		i.Interaction(*this);
	}
};

in pratica qui defisci un metodo virtuale che può far qualcosa, a noi nel corso abbiamo sempre dichiarato metodi virtuali puri, quindi in pratica qui cosa succede? Come mai l'hai dichiarato virtuale?

Ultima domanda XD: In questo modo devo includere i file electron.h ed photon.h dentro interact.h e includere interact.h dentro particel.h giusto?


Grazie comunque di tutto,sei stato velocissimo a rispondere!

[fero86]

Originariamente inviato da keiler

in pratica qui defisci un metodo virtuale che può far qualcosa, a noi nel corso abbiamo sempre dichiarato metodi virtuali puri, quindi in pratica qui cosa succede? Come mai l'hai dichiarato virtuale?

un metodo virtuale é un metodo di cui si puó fare l'override; in questo caso é indifferente che quel metodo sia virtuale o meno visto che ne' Electron ne' Photon hanno sottoclassi, quindi se vuoi togliere virtual toglilo pure.

Ultima domanda XD: In questo modo devo includere i file electron.h ed photon.h dentro interact.h e includere interact.h dentro particel.h giusto?

la questione é un po' intricata perché a questo punto le varie classi si usano a vicenda e devi evitare le inclusioni circolari. se vuoi dividere le varie classi in altrettante coppie header/sorgente devi fare come segue.


file interact.h

#pragma once

class Electron;
class Photon;

class Interaction {
public:
	void Interact(Electron&);
	void Interact(Photon&);
};

file interact.cpp:

#include "interact.h"
#include "electron.h"
#include "photon.h"

void Interaction::Interact(Electron&) {
	// ...
}

void Interaction::Interact(Photon&) {
	// ...
}

file particel.h:

#pragma once

#include "interact.h"

class Particel {
public:
	virtual void Interact(Interaction&) = 0;
};

file electron.h:

#pragma once

#include "particel.h"

class Electron : public Particel {
public:
	void Interact(Interaction&);
};

file electron.cpp:

#include "electron.h"

void Electron::Interact(Interaction &i) {
	i.Interact(*this);
}

file main.cpp:

#include <list>
#include <algorithm>

#include "interact.h"
#include "particel.h"
#include "electron.h"
#include "photon.h"

int main() {
	Interaction i;
	list<Particel> Particels;
	// ...
	for_each(Particels.begin(), Particels.end(), [] (Particel &p) {
		p.Interact(i);
	});
	return 0;
}

i files photon.h e photon.cpp sono del tutto analoghi a electron.h ed electron.cpp, rispettivamente. i #pragma once all'inizio di ogni header servono ad evitare le inclusioni multiple (spero che il tuo compilatore supporti quel pragma).

PS: ora modifico il mio codice precedente, conteneva errori (l'ho postato senza testarlo). spero che il codice di questo post sia giusto.

[keiler]

ok perfetto! Adesso mi è tutto più chiaro! Grazie ancora dell'aiuto, sei stato un grande

[cionci]

Ma Interaction può essere fra Photon-Electron, Photon-Photon, Electron-Electron ?
Ci sono altre classi derivate da Particel ? Esisteranno mai ?
Quante particelle possono partecipare ad una Interaction ?

[cionci]

Originariamente inviato da fero86

file main.cpp:

#include <list>
#include <algorithm>

#include "interact.h"
#include "particel.h"
#include "electron.h"
#include "photon.h"

int main() {
	Interaction i;
	list<Particel> Particels;
	// ...
	for_each(Particels.begin(), Particels.end(), [] (Particel &p) {
		p.Interact(i);
	});
	return 0;
}

Non dovrebbe essere un Particel * ?

[keiler]

Originariamente inviato da cionci

Ma Interaction può essere fra Photon-Electron, Photon-Photon, Electron-Electron ?
Ci sono altre classi derivate da Particel ? Esisteranno mai ?
Quante particelle possono partecipare ad una Interaction ?

no no, ogni particella interagisce per conto suo diciamo. In pratica ogni particella ha una probabilità di reagire (nel caso dell'elettrone, emette un fotone, quindi crea un fotone e lo aggiunge alla lista, nel caso di un fotone invece può decadere in 2 elettroni quindi si distrugge il fotone e si creano 2 elettroni, ma comunque ogni particella interagisce da sola).

nel programma ci ha chiesto solo photon ed electron, ho impostato così il programma per renderlo più generale, che quindi se ci fossero altre particelle da aggiungere sarebbe più semplice.

[cionci]

Spiegami meglio come vorresti usare Interaction...

[banryu79]

[parzialmente OT]

no no, ogni particella interagisce per conto suo diciamo. In pratica ogni particella ha una probabilità di reagire (nel caso dell'elettrone, emette un fotone, quindi crea un fotone e lo aggiunge alla lista, nel caso di un fotone invece può decadere in 2 elettroni quindi si distrugge il fotone e si creano 2 elettroni, ma comunque ogni particella interagisce da sola).

Si dice interazione una situazione in cui due o più oggetti (agenti o sistemi) agiscono uno sull'altro. Quindi nel tuo caso più che di una classe denominata Interaction parlerei di una Action/Reaction (o ParticleAction/ParticleReaction).
Ovviamente sto sottolineando una quisquilia, però se vedo che una classe si chiama Interaction senza sapere altro mi baso solo sul suo nome per cominciare a immaginare a cosa possa servire, e in questo caso mi pare sia facile incappare in fraintendimenti.
Ciao.

(P.S.: sia chiaro che questo intervento non è dettato da pignoleria ma dalla semplice considerazione/osservazione che dare un nome più coerente possibile alle classi/entità di cui si sta parlando mentre si esamina un sistema è utile alla disamina dello stesso e a parlare dello stesso in termini meno fraintendibili e più chiari).

[fero86]

Originariamente inviato da cionci

Non dovrebbe essere un Particel * ?

per come ho scritto io quegli stralci di codice la classe Particel puó essere assegnata e copiata, quindi non credo che ci siano problemi nell'istanziare std::list<Particel> anziché std::list<Particel*>
naturalmente andando avanti con la stesura del codice puó darsi che le cose cambino. ad ogni modo il container e l'iterazione erano soltanto esemplificativi.

[cionci]

Originariamente inviato da fero86

per come ho scritto io quegli stralci di codice la classe Particel puó essere assegnata e copiata, quindi non credo che ci siano problemi nell'istanziare std::list<Particel> anziché std::list<Particel*>
naturalmente andando avanti con la stesura del codice puó darsi che le cose cambino. ad ogni modo il container e l'iterazione erano soltanto esemplificativi.

Non puoi usare Particel lì perché è un tipo astratto

[keiler]

visto che siete curiosi vi spiego in cosa consiste l'esercizio ^^
è una simulazione di una cascata elettronica.
In pratica un elettrone con una cerca energia quando attraversa un materiale perde energia in due modi: tramite energia di ionizazzione (circa costante ogni tratto X0) e tramite irraggiamento: quindi con l'emissione di un fotone.
A sua volta il fotone se è abbastanza energetico può decadere in una coppia elettrone- positrone, che però noi trattiamo come 2 elettroni visto che si comportano allo stesso modo in questo caso, oppure può essere assorbito dal materiale se la sua energia è sotto 1 Mev.
Quindi l'utente decide l'energia iniziale dell'elettrone ed il materiale (da qui dipende X0 e l'energia persa tramite ionizazzione). A questo punto si decide un passo dx < di X0 e si fa la simulazione e si misura l'energia persa (che dovrebbe ridare il valore iniziale) e la lunghezza percorsa dalle particelle.

Per questo la classe si chiama interact perchè sarebbe l'interazione delle particelle col materiale ^^