ParentChildDemoClasses

#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>
#include <string>
#include <vector>


class Parent
{
protected:
    int id;
public:
    Parent(int val=0) : id{val} {};
    virtual std::ostream& print(std::ostream& out) const
    {
        if (typeid(out) == typeid(std::ofstream))
        {
            std::cout << "File I/O!!!\n";
            return out << 'P' << '\n' << id << '\n';
        }
        return out << "Parent id:" << id << '\n';
    };

    virtual std::istream& input(std::istream& in)
    {
        return in >> id;
    }

    virtual ~Parent(){};
    friend std::ostream& operator<<(std::ostream& out, const Parent& obj);
    friend std::istream& operator>>(std::istream& in, Parent& obj);
};

std::ostream& operator<<(std::ostream& out, const Parent& obj)
{
    return obj.print(out);
};

std::istream& operator>>(std::istream& in, Parent& obj)
{
    return obj.input(in);
};

class Child : public Parent
{
    std::string name;
public:
    Child(std::string str="Child", int val=0) : Parent{val}, name{str} {};
    virtual std::ostream& print(std::ostream& out) const
    {
        if (typeid(out) == typeid(std::ofstream))
        {
                std::cout << "File I/O!!!\n";
                return out << 'C' << '\n' << id << '\n' << name << '\n';
        }
        return out << "Child id:" << id << " name:" << name << '\n';
    };

    virtual std::istream& input(std::istream& in)
    {
        return in >> id >> name;
    }

    void childWork() {std::cout << "Children " << name << " is working hard!\n"; };

    virtual ~Child(){};
};


class Dereference
{
public:
    template<class T>
    const T& operator()(const T* ptr)
    {
        return *ptr;
    }

};

/*
    for(auto& object : objects)
    {
        if ( typeid(*object) == typeid(Child))
        {
            std::cout << "Input Child id and name\n";
        }
        else
        {
            std::cout << "Input Parent id\n";
        }
        std::cin >> *object;
    }

*/