[VC++] Ereditarietà delle classi

[cleverboy]

Questo è il listato di un piccolo file C++.

#include "stdafx.h"
#include <stdio.h>
#include <math.h>


class poligono
{
public:
int lati;
poligono(int n);
poligono();
};

poligono:oligono()
{
lati=3;
}

poligono:oligono(int n)
{
lati=n;
}

// ----------------------------------------

class quadratoublic poligono
{
int lato;
public:
int perimetro();
int area();
quadrato(int dimlato);
quadrato();
};

quadrato::quadrato(int dimlato)oligono(4)
{
lato=dimlato;
}

quadrato::quadrato()oligono(4)
{
lato=10;
}

int quadrato:erimetro()
{
return (lato*lati);
}

int quadrato::area()
{
return (lato*lato);
}
//---------------------- fine classi ------------------

void main(int argc, char* argv[])
{
int x;
poligono *q;
q=new quadrato(100);
x=q->perimetro();
}


IL PROBLEMA

quando faccio (ultima riga) x=q->perimetro(), mi dice che perimetro non è una funzione di poligono. Ciò sta a significare (immagino) che non mi costruisce l'oggetto "quadrato". Perché? Dove potrebbe essere l'errore? Nel costruttore?
Faccio presente che se invece di creare un puntatore alla classe padre (poligono) creo un oggetto di tipo quadrato (direttamente) funziona tutto. WHY?

[cleverboy]

SCUSATE! Ovviamente al posto delle faccine che ridono c'è scritto '' solo che non consideravo che sul forum ci fossero di questi scherzi! O meglio non lo ricordavo.

Tanto immagino che lo avevate capito da soli!

[cleverboy]

C...o! Un'altra volta! Vabbè, mali estremi estremi rimedi!

FACCINA = 'duepunti'+'p'

Non so più come scriverlo!

Grazie per la pazienza!

[Luc@s]

#include "stdafx.h"
#include <stdio.h>
#include <math.h>


class poligono
{
public:
	int lati;
	poligono(int n);
	poligono();
};

poligono:: poligono()
{
	lati=3;
}

poligono:: poligono(int n)
{
	lati=n;
}

// ----------------------------------------

class quadrato: public poligono
{
	int lato;
public:
	int perimetro();
	int area();
	quadrato(int dimlato);
	quadrato();
};

quadrato::quadrato(int dimlato): poligono(4)
{
	lato=dimlato;
}

quadrato::quadrato(): poligono(4)
{
	lato=10;
}

int quadrato:: perimetro()
{
	return (lato*lati);
}

int quadrato::area()
{
	return (lato*lato);
}
 //---------------------- fine classi ------------------

void main(int argc, char* argv[])
{
	int x;
	poligono *q;
	q=new quadrato(100);
	x=q->perimetro();  	
}

Cosi?

[cleverboy]

Non riesco a capire cosa tu abbia cambiato nel mio listato. A me pare identico!

Quali modifiche hai apportato?
Non capisco proprio dove tu abbia messo le mani....



Inoltre (mia curiosità) come hai fatto a inserire il codice senza le faccine che rompono le scatole?? C'è forse un tag?

[cleverboy]

Sì, è proprio identico, infatti l'errore è lo stesso...

Può darsi che non abbia capito io.

[Luc@s]

Basta che usi Disabilita le faccine in questo messaggio che c'è qui sotto!
Cmq ti commento dove ho corretto!

 #include "stdafx.h"
#include <stdio.h>
#include <math.h>


class poligono
{
public:
	int lati;
	poligono(int n);
	poligono();
};

poligono:: poligono()
{
	lati=3;
}

poligono:: poligono(int n)
{
	lati=n;
}

// ----------------------------------------

class quadrato: public poligono
{
	int lato;
public:
	int perimetro();
	int area();
	quadrato(int dimlato);
	quadrato();
};

quadrato::quadrato(int dimlato): /* poligono(4) = a ce te serve?? */
{
	lato=dimlato;
}

quadrato::quadrato(): /*poligono(4)*/
{
	lato=10;
}

int quadrato:: perimetro()
{
	return (lato*lati);
}

int quadrato::area()
{
	return (lato*lato);
}
 //---------------------- fine classi ------------------

void main(int argc, char* argv[])
{
	int x;
	poligono *q;
	q=new quadrato(100);
	x=q->perimetro();  	
}

[TheGreatWorld]

Beh, penso che il tuo compilatore ti dia un messaggio piuttosto preciso, ovvero che il metodo perimetro non fa parte della classe poligono ed infatti e' prp cosi. Quel metodo fa parte della classe quadrato e di tutte le (eventuali) classi da essa derivata. Per fare quello che volevi fare tu il metodo più pulito era implementare un comportamento polimorfo delle classi derivate da poligono (e soprattutto di rendere la classe poligono come astratta). Ma forse queste cose non le hai ancora studiate. Volendo sistemare un po il tuo codice, facendo un esempio del polimorfismo, questo e' quello che ne verrebbe fuori:


struct poligono
{

int nlati;
poligono(const int);
virtual int perimetro(void) = 0; /* rende la classe astratta */
virtual int area(void) = 0;
};

class quadrato : public poligono
{
int lato;
public:
quadrato(const int);
int perimetro(void);
int area(void);
};

poligono:oligono(const int plg) : nlati(plg) { }

quadrato::quadrato(const int qdrt) : poligono(4), lato(qdrt) { }

int quadrato:erimetro() {
return (lato * 4);
}

int quadrato::area() {
return (lato * lato);
}

Eccoti una versione molto semplice ma che può farti capire bene. Un giorno, se volessi implementare al cerchio, puoi farti la tua bella classe

class cerchio : public poligono
{
int raggio;
public:
cerchio(const int);
int perimetro();
int area();
//.... etc. etc.
};

Spero di essere stato chiaro. Una nota sullo stile: se tutti i membri della classe sono publici usa una struttura. E ricordati che la funzione main ritorna sempre un int.

bye

P.S: quasi dimenticavo... eccoti il programma di prova:

#include <iostream>

int main() {

int per;
quadrato *p;
p = new quadrato(10);
per = p->perimetro();
std::cout << per << std::endl;
delete p;
}

[cleverboy]

Adesso lo provo, ma non dubito affatto che funzioni!

per quanto riguarda le classi astratte... sì, le conosco ma quando ho fatto quel programmino di prova non era mia intenzione implementarle!

Il punto però è un altro. A parte l'astrazione della classe principale, dove era l'errore? Voglio dire, in facoltà un esempio del tutto analogo funzionava! Non capisco per quale motivo la dichiarazione new quadrato(10) non abbia fatto effetto!

Eppure tutti i metodi della classe principale sono pubblici! perché non li eredita??


CMQ grazie 1000 per l'aiuto che mi hai già dato!

[TheGreatWorld]

Forse l'esempio era meno analogo di quello che tu possa pensare. Sarebbe bene che postassi l'esempio. Cmq... cosa fa poligono *p; p = new quadrato(100); ? crea un puntatore del tipo poligono e alloca tanta memoria quanto indicato da quadrato(). Tutto qua ed e' proprio questo il comportamento che deve assumere il programma. Non e' che il puntatore e' stato 'magicamente castato al tipo desiderato'. Usa il polimorfismo, e' molto meglio .

bye