P>Ну второе-то вроде просто если выполнить первое

   A *a = dynamic_cast<A *>(ptr);

A *a = static_cast<A*>(ptr);
AA *aa = dynamic_cast<AA*>(a);
if( aa )
{
  aa->method();
}

class BaseType
{
public:
    virtual void Function () {}
    virtual ~BaseType () {}
};

class ChildType : public BaseType
{
public:
    virtual void Function () {}
    virtual ~ChildType () {}
};

int main ()
{

    int Value;

    void * Pointer ( & Value);
    
    BaseType * Base (static_cast <BaseType * const> 
        (Pointer));

    ChildType * Child (dynamic_cast <ChildType * const> 
        (Base)); /// тут всё упало

    return 0;
}

#include <vector> /// for example only

#include <boost/bind.hpp> /// use in declaration for wrapper type
#include <boost/function.hpp> /// use in declaration for wrapper type

/// declaration for wrapper type
class WrapperType
{
    /// declaration for delete type
    template <typename ValueType> 
        struct DeleteType
    {
        static void Delete (void * Pointer)
        {
            delete static_cast <ValueType * const> 
                (Pointer);
        }
    };

    /// declaration for delete member
    boost::function0 <void> Delete_;

    /// declaration for function member
    boost::function1 <void, int> Function_;

public:
    /// declaration for wrapper constructor
    template <typename ValueType> explicit WrapperType 
        (ValueType * Value) : Delete_ (boost::bind (DeleteType 
            <ValueType>::Delete, Value)), Function_ (boost::bind 
                ( & ValueType::Function, Value, _1)) {}

    /// declaration for wrapper destructor
    ~WrapperType ()
    {
        Delete_ ();
    }

    /// declaration for function member
    void Function (int Value)
    {
        Function_ (Value);
    }

};

class ObjectType
{
public:
    void Function (int i)
    {
        ++ i; /// делаем соотв. обработку
    }
};

int main ()
{
    ObjectType * const Object 
        (new ObjectType ()); /// создаем объект (тип объекта известен)

    WrapperType Wrapper (Object); /// создаем обложку вокруг объекта (тип объекта известен)

    std::vector <WrapperType> Vector;

    Vector.push_back (Wrapper); /// добавляем объект в контейнер (тип объекта не известен)

    Vector.back ().Function (45); /// делаем вызов необходимой функции (тип объекта не известен)
    
    return 0;
}

A>>   A *a = dynamic_cast<A *>(ptr);
A>>

P>Компилятор VC7.0 грит error C2681: 'void *' : invalid expression type for dynamic_cast

A* pA = reinterpret_cast<A*>(pVoid); // первое допущение мы вынуждены сделать на свой страх и риск
AA* pAA = dynamic_cast<AA*>(pA); // в случае неудачи получим NULL

delete reinterpret_cast<A*>(pVoid);

typedef void(*deleter_func)(void*);

struct deleteable_ptr
{
    void* ptr;
    deleter_func del;
    // всякий обвес - конструкторы, операторы и т.п. - напиши сам по вкусу
};

////////////////////////////////

deleteable_ptr p;
p.ptr = new AA();
p.del = boost::checked_delete<AA>;

/////////////////////////////////

p.del(p.ptr);

template<class T> void checked_delete(void* p) { delete reinterpret_cast<T*>(p); }

/// declaration for wrapper type
class WrapperType
{
    /// declaration for delete type
    template <typename ValueType> 
        struct DeleteType
    {
        static void Delete (void * Pointer) /// очищающая функция
        {
            delete static_cast <ValueType * const> 
                (Pointer);
        }
    };

    /// declaration for delete member
    boost::function0 <void> Delete_; /// указатель на очищающую функцию

    /// declaration for function member
    boost::function1 <void, int> Function_; /// интерфейс объектов

public:
    /// declaration for wrapper constructor
    template <typename ValueType> explicit WrapperType 
        (ValueType * Value) : Delete_ (boost::bind (DeleteType 
            <ValueType>::Delete, Value)), Function_ (boost::bind 
                ( & ValueType::Function, Value, _1)) {}

    /// declaration for wrapper destructor
    ~WrapperType ()
    {
        Delete_ ();        /// я сначала вызываю для него очищающую функцию 
                                   /// (типа деструктора что ыб удаление прошло корректно), 
                                                     /// а затем освобождаю память из под самого объекта
    }

    /// declaration for function member
    void Function (int Value)
    {
        Function_ (Value);
    }

};

typedef void (*destruct_fun)(void*, bool, bool);

template<class T> void checked_destruct(void* pv, bool destruct, bool release)
{
    if(destruct && release)
        delete (T*)pv;
    else if(destruct)
        ((T*)pv)->~T();
    else if(release)
        T::operator delete(pv);
}

Дано: Есть указатель void *ptr; Известно что этот указатель указывает на реально существующий объект какого-то класса АА, так же известно что любой из классов АА является потомком класса А