[c/C++] Metodi virtuali

[sccc]

Raga penso che nn mi sia abbastanza chiaro il concetto di metodi virtuali. In prativa ho preso una classe base e ho definito due metodi di cui uno virtuale:

#ifndef _BASE_
#define _BASE_

class base
{

public:

    base(void);
    ~base(void);
    void uno();
    virtual void due();
};
#endif // _BASE_

#include "base.h"
#include <iostream.h>


base::base(void){};
base::~base(void){};

void base::uno()
{
    cout << "Uno in classe base" << endl;
}
void base::due()
{
    cout << "Due in classe base" << endl;
}

poi ho preso una classe che deriva dalla base e ho modificato entrambi i metodi:

#ifndef _DERIVATA1_
#define _DERIVATA1_

#include "base.h"

class derivata1: public base
{
   
public:
   
    derivata1(void);
    ~derivata1(void);
    void uno();
    void due();

};
#endif // _DERIVATA1_

#include "derivata1.h"
#include <iostream.h>


derivata1::derivata1(void){};
derivata1::~derivata1(void){};

void derivata1::uno()
{
    cout << "Uno in classe derivata1" << endl;
}
void derivata1::due()
{
    cout << "Due in classe derivata1" << endl;
}

funzione di stampa

#include "funzione.h"

void stampa(base* p_b)
{
	p_b->uno();
	p_b->due();

}
void stampa(derivata1* p_d1)
{
	p_d1->uno();
	p_d1->due();
}

#include "base.h"
#include "derivata1.h"
#include "derivata2.h"
#include "funzione.h"


void main()
{
	base A;
	derivata1 B;
	stampa(&A);
	stampa(&B);
	
	base array[2];
	array[0] = A;
	array[1] =(derivata1) B;
	
	for(int i=0; i<2; i++)
	{
		stampa(&array[i]);
	}

}

ora andando a lanciare il programma e lanciando i metodi uno() e due() di entrambe le classi ho notato che il risultato è lo stesso di quando non uso la parola "virtual"...mi spiegate un po'meglio questa cosa getilmente?

[Stoicenko]

Posta il main intanto..,.

[sccc]

funzione di stampa

#include "funzione.h"

void stampa(base* p_b)
{
	p_b->uno();
	p_b->due();

}
void stampa(derivata1* p_d1)
{
	p_d1->uno();
	p_d1->due();
}

#include "base.h"
#include "derivata1.h"
#include "derivata2.h"
#include "funzione.h"


void main()
{
	base A;
	derivata1 B;
	stampa(&A);
	stampa(&B);
	
	base array[2];
	array[0] = A;
	array[1] =(derivata1) B;
	
	for(int i=0; i<2; i++)
	{
		stampa(&array[i]);
	}

}

[Stoicenko]

Allora.. ci sono degli errori..

class derivata1: public base
{
   
public:
   
    derivata1(void);
    ~derivata1(void);
    void uno();
    void due();  //virtual pure qui!

};

eppoi perchè nel main fai un casta a derivata?

[sccc]

Allora, mi spiego meglio. Ho ridefinito come virtual tutti i metodi di base e derivata1. L'idea era quella di creare un ciclo for in cui mi si utilizzasse il metodo stampa in maniera corretta in base al tipo di oggetto a cui viene invocato. Inizialmento ho operato così:

array base[2];
base[0] = A;
base[1] = B;

for(int i=0; i<2; i++)
{
     stampa(array[i]);
}

vedendo che, in questo modo, mi viene lanciato sempre il metodo stampa della classe base ho provato a fare un cast del tipo:

array base[2];
base[0] = A;
base[1] = (derivata1)B;

for(int i=0; i<2; i++)
{
     stampa(array[i]);
}

ma il rusiltato non cambia...come posso fare per fare in modo che, all'interno del ciclo for, mi venga invocato il giusto metodo di stampa?

[Stoicenko]

Il modo da te utilizzato è corretto.. quindi il problema è a monte.. dichiarazione della classe, override ecc..

Provato a stampare un oggetto della classe derivata senza cicli vari? Secondo me chiama la stampa di base.. Perchè? Perchè non riconosce l'override della stampa..

Se invece la stampa è corretta allora il problema è l'utilizzo errato della parola "virtual"..

[sccc]

Se utilizzo la funzione di stampa sui singoli oggetti A e B il risultato è corretto, ma se la uso in un ciclo non si capisce più niente...Mi indicheresti una soluzione cortesemente? Io mi sto esaurendo di brutto, magari tu che sei espert ci metterai qualche minuto perché di sicuro avrò fatto qualche cavolata

[Stoicenko]

Trovato!

#include "funzione.h"

void stampa(base* p_b)
{
	p_b->uno();
	p_b->due();

}
void stampa(derivata1* p_d1)
{
	p_d1->uno();
	p_d1->due();
}

L'errore sta nel fatto che non hanno una dichiarazione uguale.. vedi l'override (e non è l'overloading sia chiaro) vuole che le dichiarazioni siano uguali..

quindi:

#include "funzione.h"

void stampa(base* p_b)
{
	p_b->uno();
	p_b->due();

}

una sola funzione che chiamerà i metodi virtuali uno() e due () a runtime.. capito?

[sccc]

mmmm purtroppo ancora niente

[Stoicenko]

- i metodi uno e due sono marcati virtual in tutte e due le classi?
- dopo le modifiche la stampa di un oggetto "derivato" è corretta?
- la stampa è virtuale in base? (ps. non deve esserci pure in derivata1 perchè la eredita )