Ayuda con constructor copia

[DarkNomak]

Tengo una clase (arbin) que representa un arbol binario, la cual esta compuesta por apuntadores
a nodos, los cuales estan representados por otra clase.

Mi problema es que necesito declarar un constructor copia para la clase arbin, y tendria que ser recursivo ya que de lo contrario no copiaria el arbol completo.

Tengo una idea de como hacerlo pero no se como.

Por favor, cualquier ayuda o consejo es bienvenido

Gracias

[margarito04]

podrias mostrar algo de código de tu idea, asi te podremos ayudar mejor

[DarkNomak]

Este es el codigo principal de mis clases:

Clase nodo

Código:

#ifndef NODO_H_
#define NODO_H_

template <class T>
class nodo
{
protected:
	T elem;
	nodo<T> *hijo_izq;
	nodo<T> *hijo_der;
public:
	nodo(T e, nodo<T> *i, nodo<T> *d);
	
	T get_elem();
	nodo<T> *get_hijo_izq();
	nodo<T> *get_hijo_der();
	
	void set_elem(T e);
	void set_hijo_izq(nodo<T> *p);
	void set_hijo_der(nodo<T> *p);
};

template <class T>
nodo<T>::nodo(T e, nodo<T> *i, nodo<T> *d)
{
	elem = e;
	hijo_izq = i;
	hijo_der = d;
}

template <class T>
T nodo<T>::get_elem()
{
	return elem;
}

template <class T>
nodo<T> *nodo<T>::get_hijo_izq()
{
	return hijo_izq;
}

template <class T>
nodo<T> *nodo<T>::get_hijo_der()
{
	return hijo_der;
}

template <class T>
void nodo<T>::set_elem(T e)
{
	elem = e;
}

template <class T>
void nodo<T>::set_hijo_izq(nodo<T> *p)
{
	hijo_izq = p;
}

template <class T>
void nodo<T>::set_hijo_der(nodo<T> *p)
{
	hijo_der = p;
}

#endif

Y la clase Arbol:

Código:

#ifndef ARBIN_H_
#define ARBIN_H_

#include "nodo.h"
#include "Cola.h"
#include <stddef.h>
#include <iostream>

using namespace std;

template <class T>
class arbin
{
protected:
	nodo<T> *raiz;
public:
	arbin();
	arbin(nodo<T> *p);
	bool es_nulo() { return raiz == NULL;}
	nodo<T> *get_raiz();
	T get_info();
	nodo<T> *get_hijo_izq();
	nodo<T> *get_hijo_der();
	
	void crear(T e, nodo<T> *a1, nodo<T> *a2);
	void crear2(T e, arbin<T> a1, arbin<T> a2);
	void ins_hijo_izq(nodo<T> *p);
	void ins_hijo_der(nodo<T> *p);
	void preorden();
	void inorden();
	void postorden();
	void niveles();
};

template <class T>
arbin<T>::arbin()
{
	raiz = NULL;
}

template <class T>
arbin<T>::arbin(nodo<T> *p)
{
	raiz = p;
}

template <class T>
T arbin<T>::get_info()
{
	return (raiz->get_elem());
}


template <class T>
nodo<T> *arbin<T>::get_raiz()
{
	return raiz;
}

template <class T>
nodo<T> *arbin<T>::get_hijo_izq()
{
	return (raiz->get_hijo_izq());
}

template <class T>
nodo<T> *arbin<T>::get_hijo_der()
{
	return (raiz->get_hijo_der());
}

template <class T>
void arbin<T>::crear(T e, nodo<T> *a1, nodo<T> *a2)
{
	nodo<T> *aux;
	aux = new nodo<T>(e, a1, a2);
	raiz = aux;
}
template <class T>
void arbin<T>::crear2(T e, arbin<T> a1, arbin<T> a2)
{
	nodo<T> *aux;
	aux = new nodo<T>(e, a1.get_raiz(), a2.get_raiz());
	raiz = aux;
}

template <class T>
void arbin<T>::ins_hijo_izq(nodo<T> *p)
{
	raiz->set_hijo_izq(p);
}

template <class T>
void arbin<T>::ins_hijo_der(nodo<T> *p)
{
	raiz->set_hijo_der(p);
}

template <class T>
void arbin<T>::preorden()
{
	nodo<T> *aux;
	aux = raiz;
	arbin<T> *hd, *hi;
	hi = new arbin<T>(aux->get_hijo_izq());
	hd = new arbin<T>(aux->get_hijo_der());
	cout << aux->get_elem() << endl;
	if(!hi->es_nulo())
		hi->preorden();
	if(!hd->es_nulo())
		hd->preorden();
}
	
template <class T>
void arbin<T>::inorden()
{
	nodo<T> *aux;
	aux = raiz;
	arbin<T> *hd, *hi;
	hi = new arbin<T>(aux->get_hijo_izq());
	hd = new arbin<T>(aux->get_hijo_der());
	if(!hi->es_nulo())
		hi->inorden();
	cout << aux->get_elem() << endl;
	if(!hd->es_nulo())
		hd->inorden();
}

template <class T>
void arbin<T>::postorden()
{
	nodo<T> *aux;
	aux = raiz;
	arbin<T> *hd, *hi;
	hi = new arbin<T>(aux->get_hijo_izq());
	hd = new arbin<T>(aux->get_hijo_der());
	if(!hi->es_nulo())
		hi->postorden();
	if(!hd->es_nulo())
		hd->postorden();
	cout << aux->get_elem() << endl;
}

template <class T>
void arbin<T>::niveles()
{
	Cola< nodo<T> *> c1;
	arbin<T> *aux;
	nodo<T> *p;
	cout << aux->get_info() << endl;
	c1.encolar(aux->get_hijo_izq());
	c1.encolar(aux->get_hijo_der());
	while(!c1.esvacia())
	{
		p = c1.frente();
		cout << p->get_elem() << endl;
		c1.encolar(p->get_hijo_izq());
		c1.encolar(p->get_hijo_der());
		c1.desencolar();
	}
}

	
	
	

#endif

Y pues mi idea para el constructor, es algo asi como un procedimiento que recorra el arbol origen de manera recursiva y cree los nuevos nodos a medida que lo recorre y al retornar asigne los hijos de cada nodo de modo que quede todo enlazado.

Pero no he escrito ningun codigo porque no veo la manera de hacerlo. Se que es confuso porque los codigos son algo muy personal pero cualquier consejo o idea es bienvenido.

Gracias