[c++]passare dati a classe base

[giuseppe500]

ciao.
Ho un progetto che legge e trasforma gli stessi dati da 2 diverse fonti : file di testo e database.
Vorrei implementare la logica dell'applicazione nella classe base(creader) e la semplice lettura dei dati in due classi che derivano dalla classe base(ctext e cdatabase).
Ho pensato che tutti e due i sistemi di lettura alla fine si possono vedere come riempimento di un array.
In pratica creo un array, lo passo alla classe derivata corrispettiva(cdatabase o ctext) e questa me lo riempie.
Il problema è che non so come "passare" l'array riempito alla classe base per essere processato dalla logica.
Come posso fare?
posso forse usare delle variabili membro protected?
grazie.

[mondobimbi]

non è molto chiaro quello che vuoi fare.

Se pensi di scrivere una classe base da cui derivare le due classi, prima di tutto dovresti definire le funzioni base comuni alla due classi, che faranno parte della classe base ed i membri in comune, se ci sono. Le funzioni le puoi definire virtuali, ed ognuna delle classi derivate potrà implementare la proprio logica.
Prova a buttare giù la dfinizione della classe base con i suoi membri e le sue funzioni membro (virtuali e non)

ciao
sergio

[giuseppe500]

allora semplificando:


ho una classe Che dirige l'importazione :
for (pApi->JointReset(); pApi->NextJoint() {
if(!pApi->GetJoint(&JointID, &x, &y, &z, m_pModel->GetFreeIDEntity(0)))
.
.
.
questa deve rimanere cosi'

dove pApi è una classe specializzata per l'importazione da un dato programma che puo' essere ad es sap ma che puo' essere anche robot ecc...

Classe Base CBaseSap.h:
funzioni

virtual void JointReset();
virtual bool NextJoint();	
virtual bool GetJoint(int* JointID, double *px, double *py, double *pz, int nFreeID);

Classe CreaderTextSap.h:
eredita da CBaseSap
funzioni

void JointReset();
bool NextJoint();	
bool GetJoint(int* JointID, double *px, double *py, double *pz, int nFreeID);

Classe CreaderDbSap.h:
eredita da CBaseSap
funzioni

void JointReset();
bool NextJoint();	
bool GetJoint(int* JointID, double *px, double *py, double *pz, int nFreeID);

ora ,CreaderTextSap e CreaderDbSap ereditano da CBaseSap dove vorrei implementare la logica. in pratica:

bool CBaseSap::GetJoint(int* JointID, double *px, double *py, double *pz, int nFreeID)
{
        *px = *px * m_dLFactor;
        *py = *py * m_dLFactor;
       	*pz = *pz * m_dLFactor;


}

per semplificare molto devo solo moltiplicare *px * m_dLFactor;
e cosi' sarebbe semplice ,perchè ho i dati che la logica deve processare nei parametri della funzione , quindi basta richiamare
la funzione della classe base cosi:CBaseSap::GetJoint(x1,x2 ecc...

ma se la logica deve processare molti piu dati come posso passarli alla classe base senza aumentare il numero dei parametri
nella funzione della classe base?
si puo?
In pratica vorrei separare la logica dalla lettura dati.
Avete metodi da proporre migliori?
grazie.

[giuseppe500]

up

[giuseppe500]

nessuno?

[shodan]

Il suggerimento di Sergio è la via corretta di agire.
Cosa non ti è chiaro nello specifico?
I parametri supplementari li puoi passare tramite costruttore (o funzioni) delle classi derivate.
Alla fine la tua logica è questa:

for (pApi->JointReset(); pApi->NextJoint();) {
   if(!pApi->GetJoint(&JointID, &x, &y, &z, m_pModel->GetFreeIDEntity(0)))

Su cosa elaborino le funzioni, lo deve sapere la classe derivata, non la classe base.

Esempio banale.

class Poligono {
    public:
        virtual int perimetro()=0;
};

class Triangolo : virtual public Poligono {
    public:
       Triangolo(int x, int y, int z) : a(x),b(y),c(z) {}
       int perimetro() { return a+b+c; }
    private:
        int a,b,c;

}; 

class Quadrato : virtual public Poligono {
    public:
       Quadrato (int x) : a(x) {}
       int perimetro() { return 4*a; }
    private:
        int a;
}; 

class Rettangolo : virtual public Poligono {
    public:
       Quadrato (int x, int y) : a(x), b(y) {}
       int perimetro() { return (2*a) + (2*b); }
    private:
        int a,b;
}; 


Triangolo t(10,20,30);
Quadrato q(10);
Rettangolo r(10,20);

Poligono *p = &t;
cout << p->perimetro() << endl;

p = &q;
cout << p->perimetro() << endl;

p = &r;
cout << p->perimetro() << endl;

Come vedi la logica del cout non è cambiata, cambia solo il modo di calcolo all'interno della funzione perimetro.
Qui c'è un articolo in tema.
http://www.eptacom.net/pubblicazioni/pub_it/objifc.html