Проверка того, является ли переданный в функцию void* либо shared_ptr, либо unique_ptr

Указатель void* не несет никакой информации о типе. Что вам нужно сделать, так это передать дополнительное значение вместе с void*, чтобы указать, на что указывает void*, а затем вы можете соответствующим образом привести его тип.

#ifndef ALLOCATOR_H
#define ALLOCATOR_H

#include <memory>
#include <iostream>

template<class Type>
class Allocator {
public:
    enum AllocateType { eSharedPtr, eUniquePtr };

    Allocator() {}
    Allocator( Type type, std::shared_ptr<Type>& pData );
    Allocator( Type type, std::unique_ptr<Type>& pData );
    // ~Allocator(); // Default Okay

    void allocate( Type type, std::shared_ptr<Type>& pData );
    void allocate( Type type, std::unique_ptr<Type>& pData );

private:
    Allocator( const Allocator& c ); // Not Implemented
    Allocator& operator=( const Allocator& c ); // Not Implemented

    void allocate( Type type, AllocateType eDataType, void* pData );

}; // Allocator

#include "Allocator.inl"

#endif // ALLOCATOR_H

template<class Type>
Allocator<Type>::Allocator( Type type, std::shared_ptr<Type>& pData ) {
    allocate( type, pData );
}

template<class Type>
Allocator<Type>::Allocator( Type type, std::unique_ptr<Type>& pData ) {
    allocate( type, pData );
}

template<class Type>
void Allocator<Type>::allocate( Type type, std::shared_ptr<Type>& pData ) {
    allocate( type, eSharedPtr, &pData );
}

template<class Type>
void Allocator<Type>::allocate( Type type, std::unique_ptr<Type>& pData ) {
    allocate( type, eUniquePtr, &pData );
}

template<class Type>
void Allocator<Type>::allocate( Type type, AllocateType eDataType, void* pData ) {
    switch (eDataType) {
        case eSharedPtr: {
            static_cast<std::shared<Type>*>(pData)->reset( new Type( type ) );
            break;
        }
        case eUniquePtr: {
            static_cast<std::unique_ptr<Type>*>(pData)->reset( new Type( type ) );
            break;
        }
    }
}

In which case, I wouldn't even bother trying to funnel everything through a single function to begin with:

#ifndef ALLOCATOR_H
#define ALLOCATOR_H

#include <memory>
#include <iostream>

template<class Type>
class Allocator {
public:
    Allocator() {}
    Allocator( Type type, std::shared_ptr<Type>& pData );
    Allocator( Type type, std::unique_ptr<Type>& pData );
    // ~Allocator(); // Default Okay

    void allocate( Type type, std::shared_ptr<Type>& pData );
    void allocate( Type type, std::unique_ptr<Type>& pData );

private:
    Allocator( const Allocator& c ); // Not Implemented
    Allocator& operator=( const Allocator& c ); // Not Implemented

}; // Allocator

#include "Allocator.inl"

#endif // ALLOCATOR_H

template<class Type>
Allocator<Type>::Allocator( Type type, std::shared_ptr<Type>& pData ) {
    allocate( type, pData );
}

template<class Type>
Allocator<Type>::Allocator( Type type, std::unique_ptr<Type>& pData ) {
    allocate( type, pData );
}

template<class Type>
void Allocator<Type>::allocate( Type type, std::shared_ptr<Type>& pData ) {
    pData.reset( new Type( type ) ) ;
}

template<class Type>
void Allocator<Type>::allocate( Type type, std::unique_ptr<Type>& pData ) {
    pData.reset( new Type( type ) );
}

Вы не можете проверить, какой тип void*. Это void*. Вот и все. Это не похоже на boost::any, где он хитро скрывает какую-то другую информацию о типе. Это просто void*. Вы не можете проверить, из какого он типа. Вы не можете проверить, произошло ли оно от определенного типа. У вас ноль информации. Почтовый индекс Нада. пшик. Пустота.

После некоторого размышления и осознания того, что этот класс не хранит внутри никаких переменных-членов и содержит только функции, выполняющие конкретную задачу, я выбрал другой подход. Я благодарю всех за их отзывы и ответы, так как они дают хорошие и достоверные ответы на основные вопросы, которые я изначально задавал. Вот чего я смог добиться благодаря вашим советам. Я убрал оговорку, что сам этот класс является шаблоном, я сделал конструктор по умолчанию приватным. Я убедился, что каждая функция является шаблоном функции, и сделал их статическими. Вот мой новый класс:

Распределитель.h

#ifndef ALLOCATOR_H
#define ALLOCATOR_H

#include <memory>

class Allocator {
public:
    template<class Type>
    inline static void allocate( std::shared_ptr<Type>& pShared, const Type& type = Type() );

    template<class Type>
    inline static void allocate( std::unique_ptr<Type>& pUnique, const Type& type = Type() );

private:
    Allocator();
    Allocator( const Allocator& c );
    Allocator& operator=( const Allocator& c );

}; // Allocator

#include "Allocator.inl"

#endif // Allocator

Распределитель.cpp

#include "Allocator.h"

Распределитель.inl

template<class Type>
inline void Allocator::allocate( std::shared_ptr<Type>& pShared, const Type& type ) {
    pShared.reset( new Type( type ) );  
}

template<class Type>
inline void Allocator::allocate( std::unique_ptr<Type>& pUnique, const Type& type ) {
    pUnique.reset( new Type( type ) );
}

Это делает использование этого класса простым.

main.cpp

#include <iostream>
#include <conio.h>

#include "Allocator.h"

class A {
private:
    int m_a;
public:
    explicit A( int a = 0 ) : m_a( a ) {}
    A( const A& a ) { this->m_a = a.m_a; }

    int  getA() const { return m_a; }
    void setA( int a ) { m_a = a; }
}; // A

int main() {

    // Creating Smart A Pointer Just From A Class Type
    std::shared_ptr<A> pShared;
    std::unique_ptr<A> pUnique;

    Allocator::allocate( pShared );
    Allocator::allocate( pUnique );

    std::cout << "Shared: " << pSharedA->getA() << std::endl;
    std::cout << "Unique: " << pUniqueA->getA() << std::endl;

    pSharedA->setA( 4 );
    pUniqueA->setA( 5 );

    std::cout << "Shared: " << pSharedA->getA() << std::endl;
    std::cout << "Unique: " << pUniqueA->getA() << std::endl;

    // Create A Smart Pointer From An Object Of Type In This Case A
    // This next sections does rely on the fact that Type in this case A, should have a copy constructor defined.

    A a1( 3 );
    std::shared_ptr<A> sharedA;
    std::unique_ptr<A> uniqueA;
    Allocator::allocate( sharedA, a1 );
    Allocator::allocate( uniqueA, a1 );

    std::cout << "Shared: " << sharedA->getA() << std::endl;
    std::cout << "Unique: " << uniqueA->getA() << std::endl;

    sharedA->setA( 6 );
    uniqueA->setA( 7 );

    std::cout << "Shared: " << sharedA->getA() << std::endl;
    std::cout << "Unique: " << uniqueA->getA() << std::endl;

    pSharedA.reset();
    pUniqueA.release();
    pUniqueA.reset();

    sharedA.reset();
    uniqueA.release();
    uniqueA.reset();

    std::cout << std::endl << "Press Any Key To Quit" << std::endl;
    _getch();

    return 0;

} // main

Это также устраняет необходимость приведения типов, сравнений и т. д., повышая эффективность выполняемой работы. Я мог бы даже сделать еще один шаг вперед, объявив все эти функции встроенными.

ИЗМЕНИТЬ

Я последовал совету Реми Лебо и удалил две перегруженные функции, добавив Type type в качестве параметра по умолчанию, а также изменил его для передачи по константной ссылке. Я также сделал функции встроенными.