Approfondendo la questione (=studiare), mi viene in mente che la mia situazione possa essere gestita in maniera forse più efficiente nel seguente modo (a parte il fatto di aver implementato le funzioni membro direttamente all'interno della classe, ma non ho a disposizione il codice che ho testato con la classica divisione nei file .h e . cpp)

1)
codice:
class Sezione_type
{
public:
Sezione_type()
{
area=0;
};
~Sezione_type();
virtual void calcola_area();
...
protected:
double area;
};
2)
codice:
class Sezione_rettangolare_type
{
public:
Sezione_rettangolare_type(double B, double H):Sezione_type()
{
base=B;
altezza=H;
calcola_area();
};
~Sezione_rettangolare_type();
void calcola_area()
{
area=base*altezza;
};
protected:
double base;
double altezza;
};
3)
codice:
class Sezione_circolare_type
{
public:
Sezione_circolare_type(double D):Sezione_type()
{
diametro=D;
calcola_area();
}
void calcola_area()
{
area=3.14*pow(D,2.0)/4.0;
}
protected:
double diametro;
};
4)in questo modo, nel programma posso fare
codice:
int main()
{
Sezione_type *sezione;
...
//righe di codice che permettono di scegliere se sezione rettangolare o circolare e fare l'input dei dati come base e
//altezza o in alternativa diametro
...
//in base a quanto fatto prima se ho scelto sezione rettangolare
sezione = new Sezione_rettangolare_type(B,H);
//se ho scelto la sezione circolare
sezione = new Sezione_circolare_type(D);
....
//righe di codice che permettono di scegliere una sezione di forma diversa e relativo input dati
//quindi distruggo la sezione precedentemente creata
delete sezione;
...
//in base al nuovo tipo di sezione scelta, rifaccio
sezione = new ...//e qui ci metto il corrispondente nuovo tipo di costruttore
...
//fine del programma
delete sezione;
return 0;
}
Ora pongo le seguenti domande:
1) se al posto di
codice:
virtual void calcola_area();
avessi fatto
codice:
virtual void calcola_area()=0;
nella classe "Sezione_type" tutto quanto riportato nella precedente parte di ipotetico main non avrei potuto
farlo, perdendone i vantaggi, ho capito giusto? (però se è stato inventato in qualche caso tornerà utile, ma per ora non riesco a capire quando)
2) se in "Sezione_type" avessi semplicemente scritto
codice:
void calcola_area();
e nelle altre classi avessi reimplemento la funzione membro (dovrebbe essere overload, spero di non sbagliarmi), avrei anche in questo caso perso la possibilità di definire all'inizio un oggetto di tipo "generale" come Sezione_type, e "particolareggiarlo" successivamente
durante l'esecuzione del programma, corretto?

Grazie