[C++] Ereditarieta' + membri statici.

[Bonfo]

La domanda e' molto semplice: come si fa??

Esempio: ho definito un funzionamento nella classe base in funzione di una variabile di "classe", infatti e' static :D
Vorrei che le classi che derivano, ridefinendo il valore di quella classe, modificassero il comportamento della classe base.
Voi mi direte...l'ereditarieta' serve a quello.

Infatti, ma il problema e' che non voglio sovrascrivere il metodo, infatti fa un sacco di cose belle, fa cicli e delle elaborazioni inizali, e non mi sembra furbo per un paio di controlli sui valori di ingersso riscrivere tuttttttto il codice.

Classe Base (in ordine header e codice)

#ifndef BASE_H_
#define BASE_H_

class Base:
{

public:
GreyScale();
virtual ~GreyScale();

virtual void DoSomenthing();
protected:
static bool m_doIt;
};

#endif /*BASE_H_*/




#include "Base.h"
#include <stdio.h>

bool Base::m_doIt = false;

Base::Base() :
{
}

Base::~Base()
{
}

void Base::DoSomenthing()
{
if(m_doIt)
{
printf("OK");
}
}


Ed ecco la classe che eredita ( come al solito header e poi codice :D)

#ifndef EXECUTOR_H_
#define EXECUTOR_H_

class Executor:
{

public:
Executor();
virtual ~Executor();

protected:
static bool m_doIt;
};

#endif /*EXECUTOR_H_*/




#include "Executor.h"

bool Executor::m_doIt = true;

Executor::Executor() :
{
}

Executor::~Executor()
{
}


Peccato che questo non stampa nulla:

int main(int argc, char* argv)
{
Executor* exec = new Executor();
exec->DoSomething();
return 0;
}

:cry: :cry: :cry:

Ogni aiuto e' ben acetto ;)

P.S.: adesso che ci penso potrei fare un metodo astratto per il controllo e ereditare solo quello, ma mi piacerebbe in ogni caso capire come si fa a fare questa cosa in C++ :sofico:

[Bonfo]

Come al solito...era 1000 volte piu' facile di quello che sembrava.

Basta ridefinire i valori nel costruttore:

#include "Executor.h"

Executor::Executor() :
{
m_doIt = true;
}

Executor::~Executor()
{
}


Che figuraccia :bimbo: :bimbo: :flower:

[Bonfo]

Ovviamente ... come non detto :muro: :muro: :muro:
Appena eredito un'altra classe da Base mi si incasina tutto...del resto e' un campo statico della classe quindi e' giusto che sia cosi' !!

Mi sa che trovo un altro sistema, ma nessuno sa veramente come si fa in C++ una cosa del genere...o almeno se si puo' fare?? :fagiano: :fagiano:

[dupa]

Ovviamente ... come non detto :muro: :muro: :muro:
Appena eredito un'altra classe da Base mi si incasina tutto...del resto e' un campo statico della classe quindi e' giusto che sia cosi' !!

Mi sa che trovo un altro sistema, ma nessuno sa veramente come si fa in C++ una cosa del genere...o almeno se si puo' fare?? :fagiano: :fagiano:

non ho capito molto, tu vorresti che il valore di quell'attributo statico venga impostato da solo da ogni tipo di sottoclasse?
Non ti basta mettere l'assegnazione del valore nel costruttore della classe?

[wingman87]

Non vorrei dire una cazzata xk l'ereditarietà il mio prof me l'ha spiegata in pochi minuti ieri ma nell'header della classe che eredita non dovresti scrivere:
class Executor:Base
{
eccetera
altrimenti non vedo quand'è che stai ereditando..

[dupa]

scusa, ma son molto arrugginito col C++, ma dove scrivi nel codice che Executor estende Base?

[giangian2]

Ciao,
scusa ma il metodo "DoSomething" lo hai messo virtuale xche` lo vuoi reimplementare nelle classi derivate?
Perche` da quello che hai scritto non lo vuoi fare, quindi non ne vedo il motivo.
Se tu non lo vuoi reimplementare ma solamente che si comporti in modo diverso su delle classi derivate in base ad un certo dato io non farei una membro statico ma bensi` dichiareri una metodo virtuale che reimplemento nelle classi deriviate.

file base.h

#ifndef BASE_H_
#define BASE_H_

class Base
{

public:
Base();
virtual ~Base();

void DoSomenthing();

protected:
virtual bool IsDoIt() { return true; }
};

#endif /*BASE_H_*/

file base.cpp

#include "Base.h"
#include <stdio.h>

bool Base::m_doIt = false;

Base::Base() :
{
}

Base::~Base()
{
}

void Base::DoSomenthing()
{
if(IsDoIt())
{
printf("OK");
}
}


file .h della classe derivata
N.B.: ricordati di derivare la classe dalla clase "Base", nel codice da te scritto non c'era ;)

#ifndef EXECUTOR_H_
#define EXECUTOR_H_

class Executor : public Base
{

public:
Executor();
virtual ~Executor();

protected:
virtual bool IsDoIt() { return false; }
};

#endif /*EXECUTOR_H_*/

[Bonfo]

Oopppss :flower:
...mi sono solo scordato di scriverlo qua l'ereditarieta', nel mio codice c'e' ;)


Ciao,
scusa ma il metodo "DoSomething" lo hai messo virtuale xche` lo vuoi reimplementare nelle classi derivate?
Perche` da quello che hai scritto non lo vuoi fare, quindi non ne vedo il motivo.
Se tu non lo vuoi reimplementare ma solamente che si comporti in modo diverso su delle classi derivate in base ad un certo dato io non farei una membro statico ma bensi` dichiareri una metodo virtuale che reimplemento nelle classi deriviate.


mmmh... il perche' ho dichiarato il metodo virtual effettiavemnte non lo so; probabilmente e' rimasto li da implementazioni precedenti. Ora ci riguardo ;)
Per il resto indovinate un po' che soluzione ho trovato..praticamente quella di giangian2!!!! (che ringrazio :mano: )

Solo che invece di ereditare dei metodi protected ho fornito la classe Base di alcuni metodi, smepre protected, per effettuare il set delle proprieta' che mi interessano per differenziare l'esecuzione.

Praticamente Base ha il metodo protected SetToDo(bool value) e le classi che ereditano eventualemnte lo invocano per cambiarne il comportamento ;)

Ma ormai, piu' che far funzionare il codice, che per fortuna ci ero gia' riuscito :sofico:, sono curioso di sapere se uesat cosa dei membri statici e' possibile in C++ ... in Java sono quasi al 100% sicuro che si possa fare. :rolleyes: :rolleyes: