Mi pregunta: Estoy tratando de sobrecargar el operador de asignación para los punteros a dos clases diferentes. Aquí hay un ejemplo:

dc.h:

#ifndef DC_H_
#define DC_H_

#include "ic.h"

class dc {

double d;
char c;

public:

dc(): d(0), c(0) { }

dc(double d_, char c_): d(d_), c(c_) { }

dc* operator=(const ic* rhs);

~dc() { }

};

#endif /* DC_H_ */

clase ic.h:

#ifndef IC_H_
#define IC_H_

class ic {

int i;
char c;

public:

ic(): i(0), c(0) { }

ic(int i_, char c_): i(i_), c(c_) { }

~ic() { }

};

#endif /* IC_H_ */

dc.cpp:

#include "dc.h"

dc* dc::operator=(const ic* rhs) {
d = rhs->i;
c = rhs->c;  
return this;
}

ic.cpp:

#include "ic.h"

main.cpp:

#include "dc.h"
#include "ic.h"

#include<iostream>

int main() {

dc DC;
ic IC;

dc* dcptr = &DC;
ic* icptr = &IC;

dcptr = icptr;

return 0;
}

Recibo el siguiente mensaje de error:

error: no se puede convertir 'ic *' a 'dc *' en la asignación

Todo esto funciona si lo hago con referencias en lugar de punteros. Desafortunadamente, dado que me gustaría usar los punteros a ic y dc como miembros de otra clase, no puedo usar referencias ya que las referencias como miembros deben inicializarse y una vez que se inicializan, no se pueden cambiar para referirse a otro objeto. Me gustaría poder realizar operaciones aritméticas con ic y dc, por ejemplo:

dc *d1, *d2, *d3;
ic *i1, *i2, *i3;
*d1 = (*d1)*(*i1) + (*i2)*(*d2) - (*d3)*(*i3);

Sin embargo, quiero que mi código se vea bien y no quiero tener(*)*(*) por todo el lugar. En cambio algo como esto:

d1 = d1*i1 + i2*d2 - d3*i3;

Esta es la razón por la que me gustaría hacer esto. Por favor, hágamelo saber si esto es posible en absoluto. A mí me parece que el compilador quiere llamar al puntero predeterminado para la asignación del puntero en lugar de al sobrecargado.

Gracias por su ayuda por adelantado!