Sobre clases derivadas

Me respondo yo mismo, por si le es de utilidad a alguien (cualquier otro
enfoque es bienvenido):

Se puede hacer con templates de la siguiente forma:

Fichero a.h


class B{
private:
int m_n;
public:
B();
~B();
void Inicializar(int n);
int Obtener();
BOOL Comparar(B &);
};


template<class B> class A
{
public:
A(void);
~A(void);

void Inicializar(int n);
void Recorrer();
int Obtener(int n);
private:
int m_nSize;
B *m_pArrayBs;
};

fichero a.cpp

B::B()
{
m_n = -1;
}

B::~B(){}

void B::Inicializar(int n)
{
m_n = n;
}

int B::Obtener()
{
return m_n;
}

BOOL B::Comparar(B &b)
{
return m_n > b.m_n;
}


A<class B>::A(void)
{
m_pArrayBs = NULL;
m_nSize = -1;
}

A<class B>::~A(void)
{
if(m_pArrayBs) delete [] m_pArrayBs;
}

void A<class B>::Inicializar(int n)
{
int i;
if(n <= 0) return;
m_pArrayBs = new B[n];
m_nSize = n;
for(i = 0; i < n; i++)
{
m_pArrayBs[i].Inicializar(i);
}
}


void A<class B>::Recorrer()
{
BOOL b;
int i;
for(i = 1; i < m_nSize; i++)
{
b = m_pArrayBs[0].Comparar(m_pArrayBs[i]);
}
}


int A<class B>::Obtener(int n)
{
if(n < 0 || n >= m_nSize) return -1;
return m_pArrayBs[n].Obtener();
}


Utilización
#include "a.h"

A<B> a;

a.Inicializar(10);
a.Recorrer();
int n;
for(int i = 0; i < 10; i++)
{
n = a.Obtener(i);
}
Fin

Un saludo,

Jose



jose wrote in
news::

Hola grupo,

estoy creando una clase A que contiene varios objetos de la clase B
en, por ejemplo un Array.
Ahora bien, y aquí biene mi lio:
Necesito que B sea una clase virtual y que la clase A tenga unos
métodos que sean también virtuales, para crear una clase derivada de A
(la llamo A2) que contenga en lugar de B, objetos derivados de B (B2).


class B{
B();
~B();
virtual BOOL Comparar(B &);
};

class A{
A();
~A();
B *m_pArrayBs;

virtual void Ordenar(); // Operacion sobre los objetos derivados
de
B, utilizando su funcion virtual
}


Mi pregunta es:
¿Cómo debo definir A2? ¿qué camino debo seguir? ¿qué documentación me
recomendáis que lea?

Muchas gracias,

Jose