Klasa potomek jako argument a szablony

Cześć, czy takie podejście jest poprawne? Mam klasę Wiadomosc a po niej dziedzicza klasy Tekstowa, Ping (ta pierwsza to wiadomosc tekstowa, zawiera dodatkowe pole na tekst wiadomosci a druga to wiadomosc ping, nie zawiera zadnego dodatkowego pola). Mam zamiar dodac jeszcze inne typy Wiadomosci bardziej rozbudowane.

class Wiadomosc {
  protected:
  int size;
  string type;
  public:
  //settery/gettery
};

class Ping : public Wiadomosc {};
class Tekstowa : public Wiadomosc {
   private:
   string tekst;
   public:
   //setter, getter
};

I teraz to chcę przesłać jako argument do wysłania przez sieć.

void pinguj() {
    Ping ping;
    wyslij(ping);
}

Pomyślałem ze warto skorzystać z szablonów i zrobić coś takiego

template<class TWiadomosc> wyslij(TWiadomosc &wiadomosc) {
   std::cout<<"Wiadomosc: "<<wiadomosc.gettekst()<<std::endl; //tylko zeby pokazac ze moge teraz dobrac sie do pol klasy pochodnej (bo //gdybym w parametrze dal Message & to bym ni mogl
   //dalej serializacja i wysylanie
}

Poprawne jest to czy mozna lepiej? Pzdr

struct Base{ virtual void importantFunc() = 0; };
struct Message : Base{ void importantFunc(){}; }
...
void batman(Base &b){ b.importantFunc(); }

Rozważałem f. wirtualne, ale wtedy musiałbym te wszystkie funkcje wypisać w klasie Message. Myślałem że jeżeli klasa bazowa ma jakieś f. wirtualne to klasa pochodna musi zaimplementować je wszystkie ( przynajmniej taka jest konwencja?).

Na przykładzie:

#include <iostream>
#include <string>
using namespace std;

struct Message{
	virtual string get(){
		return "Nananana";
	}
};

struct SpecialMessage : Message{
	string get(){
		return " Batman!";
	}
};

void printMessage(Message *m){
	cout << m->get();
}

int main(){
	Message* messages[2] = {
		new Message(), new SpecialMessage()
	};
	for(int i=0; i<2; ++i)
		printMessage(messages[i]);
	return 0;
}

out:
Nananana Batman!

Wiem co to funkcje wirtualne i jak działają ;] Tyle że mam sytuację jak poniżej:

class A {
  public:
   virtual void foo() {}
   virtual void boo() {}
};

class B : public A { 
public:
   void foo() {}
};

class C : public A {
public:
  void boo() {}
};

A * a = new B();
a->boo();

kompilator tutaj wywali błąd bo obiekt B nie ma metody boo

A4TECH napisał(a):

kompilator tutaj wywali błąd bo obiekt B nie ma metody boo

Chrzani waść: http://ideone.com/WQ8v6s

Hmm to pewnei strona mi się pobugowała bo też sprawdzałem to na ideone. No to dobrze ale czy to jest dobre wyjście w mojej sytuacji? Tzn, jeżeli będę miał załóżmy 10 klas, które różnią się paroma polami to czy jest sens robić coś takiego że wszystkie metody wpycham do klasy bazowej i robię je jako wirtualne? Czyli w bazowej będzie np. 40 wirtualnych a każda podklasa nadpisuje np. tylko 4?