Can Virtual Functions be Private in C++?

// C++ program to demonstrate how a
// virtual function can be private
#include <iostream>

using namespace std;

class base {
public:
    // default base constructor
    base() { cout << "base class constructor\n"; }

    // virtual base destructor
    // always use virtual base
    // destructors when you know you
    // will inherit this class
    virtual ~base() { cout << "base class destructor\n"; }
    // public method in base class
    void show() { cout << "show() called on base class\n"; }

    // public virtual function in base class,
    // contents of this function are printed when called
    // with base class object when called with base class
    // pointer contents of derived class are printed on
    // screen
    virtual void print()
    {
        cout << "print() called on base class\n";
    }
};

class derived : public base {
public:
    // default derived constructor
    derived()
        : base()
    {
        cout << "derived class constructor\n";
    }
    // virtual derived destructor
    // always use virtual destructors
    // when inheriting from a
    // base class
    virtual ~derived()
    {
        cout << "derived class destructor\n";
    }

private:
    // private virtual function in derived class overwrites
    // base class virtual method contents of this function
    // are printed when called with base class pointer or
    // when called with derived class object
    virtual void print()
    {
        cout << "print() called on derived class\n";
    }
};

int main()
{
    cout << "printing with base class pointer\n";

    // construct base class pointer with derived class
    // memory
    base* b_ptr = new derived();

    // call base class show()
    b_ptr->show();

    // call virtual print in base class but it is overridden
    // in derived class also note that print() is private
    // member in derived class, still the contents of
    // derived class are printed this code works because
    // base class defines a public interface and drived
    // class overrides it in its implementation
    b_ptr->print();

    delete b_ptr;
}

#include <iostream>

using namespace std;

// Base class declaration
class Base {
public:
    Base() {}
    virtual ~Base() {}

    // Public method that calls the private virtual function
    void show() { printMe(); }

private:
    // Private virtual function that can be overridden in
    // derived classes
    virtual void printMe()
    {
        cout << "Base calling printMe!!!\n";
    }
};

// Derived class inheriting from Base class
class Derived : public Base {
public:
    Derived(){}
    virtual ~Derived() {}

private:
    // Override the private virtual function in the derived
    // class
    virtual void printMe() override
    {
        cout << "Derived calling printMe!!!!\n";
    }
};

int main()
{
    Derived dd;
    dd.show();
    return 0;
}