Acyclic Visitor C++

I'm reading the book by Alexandrescu, and I've run into the Acyclic Visitor pattern. I think that it's possible to get rid of the macross that calls AcceptImpl method of the BaseVisitable class. Could you tell me, whether the following implementation bellow conforms the standard?

class BaseVisitor
{
public:
    virtual ~BaseVisitor() {}
};

template <class SpecificVisitable>
class SpecificVisitor
{
public:
    virtual void Visit(SpecificVisitable& t) = 0;

protected:
    ~SpecificVisitor() {}
};

template <class SpecificVisitable>
class BaseVisitable
{
public:
    void Accept(BaseVisitor& visitor)
    {
        SpecificVisitor<SpecificVisitable>& specificVisitor = dynamic_cast<SpecificVisitor<SpecificVisitable>&>(visitor);
        specificVisitor.Visit(static_cast<SpecificVisitable&>(*this));
    }
protected:
    ~BaseVisitable() {}
};

class A : public BaseVisitable<A>
{
public:
    void PrintA() { std::cout << "A\n"; }
};

class B : public BaseVisitable<B>
{
public:
    void PrintB() { std::cout << "B\n"; }
};

class PrintVisitor final:
    public BaseVisitor,
    public SpecificVisitor<A>,
    public SpecificVisitor<B>
{
public:
    virtual void Visit(A& a) override
    {
        a.PrintA();
    }

    virtual void Visit(B& b) override
    {
        b.PrintB();
    }
};

int main()
{
    A a;
    B b;

    PrintVisitor visitor;
    a.Accept(visitor);
    b.Accept(visitor);
}