Tablica dynamiczna, szablon funkcji

Witam serdecznie.
Mam do zrobienia zadanie o treści:

Dane są trzy dynamicznie alokowane tablice, które przechowują imię (char), wiek (int) oraz płeć (bool). Napisz program pozwalający na: **
#-wprowadzenie danych do tablic.
#- wyświetlenie dotychczas wprowadzonych danych*
#-posortowanie danych zgodnie z kryterium:
#imię - rosnąco lub malejąco.
#wiek - rosnąco lub malejąco.
#płeć

Realizacja tego zadania wymaga definicji wszystkich powtarzających się operacji w postaci funkcji szablonowych. Należy również zadbać o właściwe wielkości tablic, tab aby nigdy nie zabrakło miejsca dla kolejnej wprowadzonej osoby.

Dotychczas udało mi się wymyślić, coś takiego (patrz poniżej na kod). Niestety nie jest to dobre rozwiązanie.
Wszystkie pomysły mi się skończyły, a nawet jeśli jakieś mam nie potrafię ich zastosować w kodzie

Dlatego zwracam się z ogromną prośbą o pomoc.

template <typename Data, int size>
class Stos {
　　　Data* data;
　　　int top;
　　　public:
　　　Stos();
　　　bool empty() const;
　　　void push(Data);
　　　Data pop();
　};

template <typename Data, int size>
　　　Stos<Data,size>::Stos() {
　　　　　 data = new Data[size];
　　　　　 top = 0;
　}
　
template <typename Data, int size>
　　　inline bool Stos<Data,size>::empty() const {
　　　　　　 return top == 0;
　}
　
template <typename Data, int size>
　　　inline void Stos<Data,size>:ush(Data dat) {
　　　　　　 data[top++] = dat;
　}

template <typename Data, int size>
　　　void show(Stos<Data,size>* p_stos) {
　　　while ( ! p_stos->empty() ) {
　　　　　cout << p_stos->pop() << " ";
　　　}
　　　cout << endl;
　}

template <typename Data, int size>
　　　inline Data Stos<Data,size>:op() {
　　　return data[--top];
　}

int main(int argc, char *argv[])
{

Stos<string,15> imie;
　　　　　 imie.push("Ala");
　　　　　 imie.push("Ela");
　　　　　 imie.push("Ola");
　　　　　 show(&imie);

　　Stos<int,15> wiek;
　　　　　 wiek.push(5);
　　　　　 wiek.push(10);
　　　　　 wiek.push(15);
　　　　　 show(&wiek);
　　　　　 
　　Stos<bool,15> plec;
　　　　　 plec.push(true);
　　　　　 plec.push(true);
　　　　　 plec.push(false);
　　　　　 show(&plec);
}

Może coś takiego?

 #include <iostream>
using namespace std;


template <class T> class Wektor
{ public:
    int size(){return rozm;};
    Wektor(){};
    Wektor(const int &n)
	{
		rozm=n;
		A=new T[n];
	};
	~Wektor()
	{
		delete []A;
	}
    T& operator [ ](const int &i){if(0<=i && i<=rozm) return A[i];};

  private:
    int rozm;
    T* A;
};


class Plec
{
public:
	Plec(){}
	Plec(bool &_plec){plec=_plec;}
	Plec& operator=(Plec &p){this->SetPlec(p.GetPlec()); return *this;}
protected:
	bool& GetPlec(){return plec;}
	void SetPlec(bool _plec){this->plec=_plec;}
private:
	bool plec;
};

class Wiek
{
public:
	Wiek(){}
	Wiek(int &_wiek){wiek=_wiek;}
protected:
	int& GetWiek(){return wiek;}
private:
	int wiek;
};

class Imie
{
public:
	Imie(){}
	Imie(char* &_imie){imie=_imie;}
	Imie& operator=(char* &imie){ this->SetImie(imie); return *this;}

protected:
	char& GetImie(){return *imie;}
	void SetImie(char* &_imie){imie=_imie;}


private:
	char* imie;
};

int main()
{
	int rozmiar;
	cin>>rozmiar;
	Wektor<Imie> imie(rozmiar);
	Wektor<Wiek> wiek(rozmiar);
	Wektor<Plec> plec(rozmiar);
	for(int i=0;i<rozmiar;i++)
	{
	}
	return 0;
}

Musiałbyś w klasie Wektor zrobić reo-lokowanie pamięci, ale na pewno google pęka od tego. i w tej pętli w mainie oczywiście dodajesz dane.