C/C++ - Aiuto esercizio c++

Forum - C/C++ - Aiuto esercizio c++

naruto98 (Normal User)
Newbie

Messaggi: 4
Iscritto: 26/01/2019

Postato alle 18:14
Sabato, 26/01/2019

Salve a tutti, ho un problema con la seguente richiesta in un esercizio:
Si considerino le seguenti classi relative ai personaggi di un videogioco. Si scrivano le classi
necessarie (Abstract Factory) a fare in modo che ad uno AssaultTrooper possa essere associato solo
un AssaultRifle ed una Stamina, mentre ad uno Sniper siano associate solo SniperRifle e HoldBreath.

Codice sorgente - presumibilmente C++

class Weapon {
public:
virtual ~Weapon() = 0;
};
 
class AssaultRifle : public Weapon {
};
 
class SniperRfile : public Weapon {
};
 
class PhysicalFeature {
public:
virtual ~PhysicalFeature() = 0;
};
 
class Stamina : public PhysicalFeature {
};
 
class HoldBreath : public PhysicalFeature {
};
 
class Character {
public:
virtual ~Character() = 0;
void setPhysical(PhysicalFeature * aPF) {
pf = aPF;
}
void setWeapon(Weapon* aW) {
 w = aW;
}
 
protected:
PhysicalFeature * pf;
Weapon* w;
};
 
class AssaultTrooper : public Character {
public:
AssaultTrooper (int s) : strength (s) {};
void doRun() {};
 
private:
int strength;
};
 
class Sniper : public Character {
public:
Sniper (int p) : precision(p) {};
void doSnipe() {};
 
private:
int precision;
};

Il mio problema si trova nella parte in grassetto del comando dell'esercizio, non riesco proprio a capire come fare. So che Ã¨ un problema piuttosto banale, chiedo venia 8-|

Grazie a chiunque sia disposto ad aiutarmi

Ultima modifica effettuata da naruto98 il 26/01/2019 alle 18:18

TheDarkJuster (Member)
Guru^2

Messaggi: 1620
Iscritto: 27/09/2013

Postato alle 18:39
Sabato, 26/01/2019

Devi usare un dynamic_cast<Stamina*>(...) Per controllare se il risultato è un nullptr o altro. Se è nullptr l'oggetto passato non è di tipo Stamina e nemmeno un suo sottotipo.

naruto98 (Normal User)
Newbie

Messaggi: 4
Iscritto: 26/01/2019

Postato alle 11:30
Domenica, 27/01/2019

Testo quotato

Postato originariamente da TheDarkJuster:
Devi usare un dynamic_cast<Stamina*>(...) Per controllare se il risultato Ã¨ un nullptr o altro. Se Ã¨ nullptr l'oggetto passato non Ã¨ di tipo Stamina e nemmeno un suo sottotipo.

Allora grazie molte per la risposta! Quindi mi stai dicendo di usare un dynamic_cast all'interno del metodo setPhysical nelle classi AssaultTrooper e SniperRifle?
Del tipo:

Codice sorgente - presumibilmente C/C++

void setPhysical(PhysicalFeature * aPF) {
if(dynamic_cast<Stamina*>(aPF)!=nullptr)
pf = aPF;
}

Ultima modifica effettuata da naruto98 il 27/01/2019 alle 11:33

TheDarkJuster (Member)
Guru^2

Messaggi: 1620
Iscritto: 27/09/2013

Postato alle 13:36
Domenica, 27/01/2019

Testo quotato

Postato originariamente da naruto98:

Testo quotato

Postato originariamente da TheDarkJuster:
Devi usare un dynamic_cast<Stamina*>(...) Per controllare se il risultato &Atilde;&uml; un nullptr o altro. Se &Atilde;&uml; nullptr l'oggetto passato non &Atilde;&uml; di tipo Stamina e nemmeno un suo sottotipo.

Allora grazie molte per la risposta! Quindi mi stai dicendo di usare un dynamic_cast all'interno del metodo setPhysical nelle classi AssaultTrooper e SniperRifle?
Del tipo:

Codice sorgente - presumibilmente C/C++

void setPhysical(PhysicalFeature * aPF) {
if(dynamic_cast<Stamina*>(aPF)!=nullptr)
pf = aPF;
}

Esattamente. Inoltre considera che dovresti chiamare setPhysical dal costruttore e magari dichiarare il campo come costante, visto che è una proprietà invariabile nel tempo di vita di un oggetto, inoltre comsidera di dichiarare pf come costante. Comunque questa è solo una questione di stile, desogn del codice e const-correctness, la soluzione al tuo problema l'hai gia trovata.

naruto98 (Normal User)
Newbie

Messaggi: 4
Iscritto: 26/01/2019

Postato alle 17:25
Lunedì, 28/01/2019

Testo quotato

Postato originariamente da TheDarkJuster:

Testo quotato

Postato originariamente da naruto98:

Testo quotato

Postato originariamente da TheDarkJuster:
Devi usare un dynamic_cast<Stamina*>(...) Per controllare se il risultato &amp;amp;amp;Atilde;&amp;amp;amp;uml; un nullptr o altro. Se &amp;amp;amp;Atilde;&amp;amp;amp;uml; nullptr l'oggetto passato non &amp;amp;amp;Atilde;&amp;amp;amp;uml; di tipo Stamina e nemmeno un suo sottotipo.

Allora grazie molte per la risposta! Quindi mi stai dicendo di usare un dynamic_cast all'interno del metodo setPhysical nelle classi AssaultTrooper e SniperRifle?
Del tipo:

Codice sorgente - presumibilmente C/C++

void setPhysical(PhysicalFeature * aPF) {
if(dynamic_cast<Stamina*>(aPF)!=nullptr)
pf = aPF;
}

Esattamente. Inoltre considera che dovresti chiamare setPhysical dal costruttore e magari dichiarare il campo come costante, visto che Ã¨ una proprietÃ  invariabile nel tempo di vita di un oggetto, inoltre comsidera di dichiarare pf come costante. Comunque questa Ã¨ solo una questione di stile, desogn del codice e const-correctness, la soluzione al tuo problema l'hai gia trovata.

Grazie mille davvero, sei stato molto gentile ed esplicativo. Ne approfitto della tua gentilezza e pazienza chiedendoti delucidazioni, o meglio rassicurazioni, sulla prima parte dell'esercizio. Sbaglio qualcosa ad impostare in questo modo le classi necessarie per implementare un Abstract Factory? Non riesco molto bene a distinguere l'Abstract Factory con il Factory Method.

Codice sorgente - presumibilmente C++

class CharacterFactory {
public:
    virtual ~CharacterFactory() {}
    virtual Character* createCharacter() = 0;
};
 
class AssaultTrooperFactory : public CharacterFactory{
    virtual ~AssaultTrooperFactory() {}
    virtual Character* createCharacter() override{
        return new AssaultTrooper(10);
    }
};
 
class SniperFactory : public CharacterFactory{
    virtual ~SniperFactory() {}
    virtual Character* createCharacter() override{
        return new Sniper(10);
    }
};

Ultima modifica effettuata da naruto98 il 28/01/2019 alle 17:27

TheDarkJuster (Member)
Guru^2

Messaggi: 1620
Iscritto: 27/09/2013

Postato alle 18:07
Lunedì, 28/01/2019

Testo quotato

Postato originariamente da naruto98:

Testo quotato

Postato originariamente da TheDarkJuster:

Testo quotato

Postato originariamente da naruto98:

Testo quotato

Allora grazie molte per la risposta! Quindi mi stai dicendo di usare un dynamic_cast all'interno del metodo setPhysical nelle classi AssaultTrooper e SniperRifle?
Del tipo:

Codice sorgente - presumibilmente C/C++

void setPhysical(PhysicalFeature * aPF) {
if(dynamic_cast<Stamina*>(aPF)!=nullptr)
pf = aPF;
}

Codice sorgente - presumibilmente C++

class CharacterFactory {
public:
    virtual ~CharacterFactory() {}
    virtual Character* createCharacter() = 0;
};
 
class AssaultTrooperFactory : public CharacterFactory{
    virtual ~AssaultTrooperFactory() {}
    virtual Character* createCharacter() override{
        return new AssaultTrooper(10);
    }
};
 
class SniperFactory : public CharacterFactory{
    virtual ~SniperFactory() {}
    virtual Character* createCharacter() override{
        return new Sniper(10);
    }
};

Non saprei cosa dirti, non ho mai avuto a che fare con un fabbricatore di oggetti. Ti posso dire che il tuo codice è corretto dal punto di vista logico. Non so assolutamente dirti se il mio punto di vista logico sia quello del tuo professore.
Sotto il profilo sintattico avrei da dire: 1) se usi override non ti serve specificare virtual. 2) se il costruttore ti serve in versione di default esplicitalo come si deve: virtual ~AssaultTrooperFactory() = default;