Originariamente inviato da MItaly
Il costruttore di copia di una classe astratta fa quello che farebbe in una classe concreta... ma può essere richiamato solo ed esclusivamente dai costruttori di copia delle classi derivate, dato che una classe, se è astratta, non è istanziabile. Di fatto quindi non sarà altro che un helper per le classi derivate per copiare i membri della classe base.
L'operatore di assegnamento è una bestia strana nel caso di classi astratte... anche in questo caso, si dovrebbe limitare a fare da helper per le classi derivate, dato che una copia "da classe astratta a classe astratta" non ha motivo di esistere. Per questo motivo al massimo lo dichiarerei come virtual e protected, in modo che sia utilizzabile come helper dalle classi derivate ma non direttamente "dall'esterno".
Nota tra l'altro che, lavorando con gerarchie di classi di questo genere, spesso più che di un costruttore di copie/operatore di assegnamento serve piuttosto un metodo "clona" (vedi ad esempio
qui).
Ciao Mitaly grazie per la risposta
tieni presente che non sono un esperto e quindi con la parola helper (aiutante) non è che capisco cosa vuoi dire di preciso
quindi il costruttore di copia dovrebbe essere definito come funzione virtuale pura così come pure l'operatore di assegnamento?
stavo ragionando proprio su un problema con classe astratta e dati con estensione dinamica, se ti va, ed hai 5 minuti, mi potresti dire in base a quello che hai detto sul costruttore di copia e sull'operatore di assegnamento cosa dovrei fare di diverso?
codice:
#ifndef _COMPUTER_H_
#define _COMPUTER_H_
#include <iostream>
#include <string.h>
using namespace std;
class Computer{
private:
char* modello;
float prezzo;
public:
Computer():modello(0),prezzo(0){};
Computer(char*, float) ;
Computer(const Computer & ) ;
virtual ~Computer(){delete [] modello;}
virtual void stampaDati();
virtual bool offerta(float &)=0;
const Computer & operator=(const Computer & ) ;
};
#endif
#include "Computer.h"
Computer::Computer(char* st, float n){
modello = new char [strlen(st)+1];
strcpy(modello,st);
prezzo=n;
}
Computer::Computer(const Computer & c){
modello = new char [strlen(c.modello)+1];
strcpy(modello,c.modello);
prezzo=c.prezzo;
}
void Computer::stampaDati(){
cout<<"il modello e' : "<<modello<<"il prezzo e': "<<prezzo<<endl;
}
const Computer & Computer::operator=(const Computer & c){
delete [] modello;
modello = new char [strlen(c.modello)+1];
strcpy(modello,c.modello);
prezzo=c.prezzo;
return *this;
}
#ifndef _NOTEBOOK_H_
#define _NOTEBOOK_H_
#include "Computer.h"
#include <iostream>
#include <string.h>
using namespace std;
class Notebook: public Computer{
private:
float peso;
float spessore;
float pollici;
public:
Notebook():Computer(),peso(0),spessore(0),pollici(0){};
Notebook(char*, float, float, float, float) ;
virtual void stampaDati() ;
virtual bool offerta(float & ) ;
};
#endif
#include "Notebook.h"
Notebook::Notebook(char* st, float c, float n1, float n2, float n3):Computer(st,c){
peso=n1;
spessore=n2;
pollici=n3;
}
bool Notebook::offerta(float & of){
if(peso >= 2 && pollici <= 14){
of = prezzo-prezzo*20/100;
return true;
}
else return false;
}
void Notebook::stampaDati(){
Computer::stampaDati() ;
cout<<peso<<spessore<<pollici<<endl;
}
#ifndef _PDA_H_
#define _PDA_H_
#include "Computer.h"
#include <iostream>
#include <string.h>
using namespace std;
class Pda: public Computer{
private:
char* sisop;
bool bluetooth;
public:
Pda():Computer(),sisop(0),bluetooth(0){};
Pda(char*, float, char*, bool );
Pda(const Pda &);
~Pda(){ delete [] sisop;}
virtual bool offerta(float & ) ;
virtual void stampaDati();
};
#endif
#include "Pda.h"
Pda::Pda(char* sr , float c, char* psr, bool pb):Computer(sr,c){
sisop = new char [strlen(psr)+1];
bluetooth=pb;
}
Pda::Pda(const Pda & p):Computer(p){
sisop = new char [strlen(p.sisop)+1];
bluetooth=p.bluetooth;
}
bool Pda::offerta(float & of){
if(strcmp(getmodello(),"nokia") && bluetooth){
of = prezzo-prezzo*15/100;
return true;
}
else return false;
}
void Pda::stampaDati() {
Computer::stampaDati();
cout<<bluetooth<<sisop<<endl;
}