在C++中，可以使用函数重载来处理不同类型和它们的基类。下面是一个示例代码：

#include 

class MyBaseClass {
public:
    virtual void print() {
        std::cout << "Base class" << std::endl;
    }
};

class MyDerivedClass : public MyBaseClass {
public:
    void print() override {
        std::cout << "Derived class" << std::endl;
    }
};

void myFunction(int num) {
    std::cout << "Integer: " << num << std::endl;
}

void myFunction(float num) {
    std::cout << "Float: " << num << std::endl;
}

void myFunction(MyBaseClass* obj) {
    std::cout << "Base class object" << std::endl;
    obj->print();
}

int main() {
    int num1 = 10;
    float num2 = 3.14;

    myFunction(num1); // 调用 myFunction(int num)
    myFunction(num2); // 调用 myFunction(float num)

    MyBaseClass* obj1 = new MyBaseClass();
    MyBaseClass* obj2 = new MyDerivedClass();

    myFunction(obj1); // 调用 myFunction(MyBaseClass* obj)
    myFunction(obj2); // 调用 myFunction(MyBaseClass* obj) 但是调用的是派生类的print函数

    delete obj1;
    delete obj2;

    return 0;
}

在上面的代码中，我们定义了三个重载的myFunction函数，分别接受不同类型的参数：int、float和MyBaseClass指针。当我们调用myFunction时，编译器会根据参数的类型来选择正确的函数进行调用。

在main函数中，我们分别调用了myFunction(num1)和myFunction(num2)，根据参数的类型，分别调用了myFunction(int num)和myFunction(float num)。

同时，我们还创建了两个MyBaseClass的对象指针，一个指向基类对象，一个指向派生类对象。我们分别调用myFunction(obj1)和myFunction(obj2)，根据参数的类型，分别调用了myFunction(MyBaseClass* obj)。在这种情况下，由于obj2指向派生类对象，虚函数print会根据对象的实际类型来调用派生类的print函数，输出"Derived class"。

这就是在C++中处理不同类型和它们的基类的重载的一种解决方法。