Desbordamiento en una clase [realloc]

[Doommarine_Maxi]

Bueno, estoy teniendo un problema con una clase, se llama "Servicios"
Dentro de otra clase llamada empresa cuando la quiero editar, agregarle parametros, se desborda.
Pero si la creo afuera de la clase no pasa lo mismo, funciona correctamente.


clases.cpp

Código C++:

/*La clase Factura no la agrego por que no es la causante del problema*/
class Compania
{
    private:
        char* nombre;
    public:
        char* getName(){ return nombre; }
        void setName(char* n){ nombre = n; return; }
};
class Servicio
{
    private:
        char* nombre;
        int m_max;
        Compania *comp;
    public:
        Servicio();
        char* getName(){ return nombre; }
        void setName(char* p){ nombre = p; return; }
        void Agregar(Compania);
};
Servicio::Servicio()
{
    m_max = 0;
    comp = (Compania*)calloc(1, sizeof(Compania));
}
void Servicio::Agregar(Compania Cp)
{
    m_max++;
    comp = (Compania*)realloc(comp, sizeof(Compania)*(m_max+1));  /* EL desbordamiento
 se genera aquí dentro de la clase empresa*/
    comp[m_max] = Cp;
    return;
}
class Empresa
{
    private:
        int f_max;
        int c_max;
        int s_max;
    public:
        Factura *facturas;
        Compania *companias;
        Servicio *servicios;
        Empresa();
        void AgregarFactura(char*, float);
        void AgregarServicio(char*);
        void AgregarEmpresa(char*);
};
 
void Empresa::AgregarFactura(char* ser, float mont)
{
    f_max++;
    facturas = (Factura*)realloc(facturas, sizeof(Factura)*(f_max+1));
    facturas[f_max].setMonto(mont);
    facturas[f_max].setNombre(ser);
}
void Empresa::AgregarServicio(char* ser)
{
    s_max++;
    servicios = (Servicio*)realloc(servicios, sizeof(Servicio)*(s_max+1));
    servicios[s_max].setName(ser);
    return;
}
void Empresa::AgregarEmpresa(char* emp)
{
    c_max++;
    companias = (Compania*)realloc(companias, sizeof(Compania)*(c_max+1));
    companias[c_max].setName(emp);
    return;
}
Empresa::Empresa()
{
    f_max = 0;
    c_max = 0;
    s_max = 0;
    facturas = (Factura*)calloc(1, sizeof(Factura));
    companias = (Compania*)calloc(1, sizeof(Compania));
    servicios = (Servicio*)calloc(1, sizeof(Servicio));
}
 

main.cpp

Código C++:

....
    Empresa em;
    em.AgregarServicio(ConstToCad("Luz"));
    em.AgregarServicio(ConstToCad("Internet"));
    em.AgregarServicio(ConstToCad("Gas"));
 
    em.AgregarEmpresa(ConstToCad("Edesur"));
    em.AgregarEmpresa(ConstToCad("Metrogas"));
    Compania p;
    p.setName(ConstToCad("Edenor"));
    em.servicios[1].Agregar(em.companias[1]); //Desbordamiento aquí
    em.servicios[1].Agregar(p); //Desbordamiento aquí
    Servicio f;
    f.Agregar(em.companias[1]); //Esto funciona bien
    f.Agregar(p); //Esto funciona bien
        ...
 

Por lo lo que veo el desbordamiento se genera en la clase empresa, pero no se por que, solamente tengo hipótesis.

Gracias por su atención.

[sam90]

Para crear instancias de clases usa new...
Esto asi:
comp = (Compania*)calloc(1, sizeof(Compania));

Quedaria asi:

comp = new Compania;