совмещение ооп и фп в одной программе

#include <iostream>
 
void f(const char* i)
{
    std::cout << "f(const char*) called\n";
}
 
void f(int i)
{
    std::cout << "f(int) called\n";
}
 
void f(float i)
{
    std::cout << "f(float) called\n";
}
 
void f(double i)
{
    std::cout << "f(double) called\n";
}
 
int main()
{
    f(100.500);
    f("100500");
    f(100500);
    f(100.500f);
    return 0;
}

#include <iostream>
#include <cmath>
 
class complex
{
protected:
    double real;
 
private:
    double imag;        // производные классы не должны знать
                // о мнимой части
 
public:
    complex(double, double);
    complex(const complex&);
 
    complex operator + (const complex&) const;
 
    friend std::ostream& operator << (std::ostream&,
                      const complex&);
};
 
class floating: public complex
{
public:
    floating(double);
    floating(const floating&);
 
    floating operator + (const floating&) const;
 
    operator complex () const;
    
    friend std::ostream& operator << (std::ostream&,
                      const floating&);
};
 
complex operator + (const floating&, const complex&);
 
#define PRINT(EXP) std::cout << #EXP ": " << (EXP) << std::endl
 
int main()
{
    complex c1(2,3), c2(2, -3);
    floating f1(2), f2(-3);
 
    PRINT(c1);
    PRINT(c2);
    PRINT(f1);
    PRINT(f2);
    PRINT(c1 + c2);
    PRINT(f1 + f2);
 
    PRINT(f1 + c2);
    PRINT(c1 + f2);
    
    return 0;
}
 
complex::complex(double r, double i)
    : real(r), imag(i)
{
}
 
complex::complex(const complex& rhs)
    : real(rhs.real), imag(rhs.imag)
{
}
 
complex complex::operator + (const complex& rhs) const
{
    return complex(real + rhs.real, imag + rhs.imag);
}
 
std::ostream& operator << (std::ostream& os,
               const complex& rhs)
{
    bool minus = rhs.imag < 0;
 
    os << rhs.real;
 
    if(rhs.imag != 0)
    os << (minus ? " - " : " + ") << fabs(rhs.imag) << "i";
 
    return os;
}
 
floating::floating(double f)
    : complex(f, 0)
{
}
 
floating::floating(const floating& rhs)
    : complex(rhs.real, 0)
{
}
 
floating floating::operator + (const floating& rhs) const
{
    return floating(real + rhs.real);
}
 
floating::operator complex () const
{
    return complex(real, 0);
}
 
std::ostream& operator << (std::ostream& os,
               const floating& rhs)
{
    return (os << rhs.real);
}
 
complex operator + (const floating& f, const complex& c)
{
    return static_cast<const complex&>(f) + c;
}