Visitor pattern in separate files

Cat.hpp

#include "Visitable.hpp"

struct Cat: Visitable
{
    void hunt_birds() { throw "Hunting birds..."; }
    void accept( Doer& doer ) override { doer.deal_with( *this ); }
};

create_cat.cpp

#include "Cat.hpp"
auto create_cat() -> Visitable* { return new Cat; }

create_person.cpp

#include "Person.hpp"
auto create_person() -> Doer* { return new Person; }

Doer.hpp

#pragma once

struct Cat;
struct Phone;

struct Doer
{
    virtual ~Doer() {}
    virtual void deal_with( Cat& ) = 0;
    virtual void deal_with( Phone& ) = 0;
};

main.cpp

#include "Visitable.hpp"

extern auto create_person() -> Doer*;
extern auto create_cat() -> Visitable*;

#include <stdio.h>
#include <memory>
using std::unique_ptr;

auto main() -> int
{
    using C_str = const char*;
    try {
        auto doer    = unique_ptr<Doer>( create_person() );
        auto object  = unique_ptr<Visitable>( create_cat() );
        object->accept( *doer );    // "Hunting birds..."
    } catch( const C_str s ) {
        printf( "%s\n", s );
    }
}

Person.hpp

#include "Doer.hpp"     // Not really necessary but to be clear.
#include "Cat.hpp"
#include "Phone.hpp"

struct Person: Doer
{
    void deal_with( Cat& cat ) override        { cat.hunt_birds(); }
    void deal_with( Phone& phone ) override    { phone.call_999(); }
};

Phone.hpp

#include "Visitable.hpp"

struct Phone: Visitable
{
    void call_999() { throw "Calling 999!"; }
    void accept( Doer& doer ) override { doer.deal_with( *this ); }
};

Visitable.hpp

#pragma once
#include "Doer.hpp"

struct Visitable
{
    virtual ~Visitable() {}
    virtual void accept( Doer& doer ) = 0;
};