Использование указателя на объект шаблонного класса в шаблонном классе.

template <class T> class Vertex {
        private: 
            char* name;
            T data;
            int index;
        public: 
            Vertex();
            Vertex(char* nam, T dat, int ind);
            ~Vertex();
            char* getName(); 
            T getData(); //возвращает данные, связанные с вершиной,
            void setName(char *nam); //задает имя вершины,
            void setData(T dat); //записывает данные data в дескриптор вершины.
    };

template <class TT>
class Edge {
    private:
        Vertex *v1, *v2;
        int w;
    public:
        Edge(Vertex *va, Vertex *vb) {
            v1 = va;
            v2 = vb;
        }
            Edge(Vertex *va, Vertex *vb, int ww) {
            v1 = va;
            v2 = vb;
            w = ww;
           }
           Edge(Vertex *va, Vertex *vb, int ww, TT dat) {
            v1 = va;
            v2 = vb;
            w = ww;
            data = dat;
           }
           ~Edge();
        
           int getW();
           void setW(int ww);
           TT getData();
           void setData(TT dat);
};

Vertex<int> e1("parampampam", 123, 0);
Vertex<int> e2("parampampam", 123, 1);
Edge<int> rebro(&e1, &e2);

template <class TT>
class Edge {
//...........
        public:
                Edge(Vertex<TT> *va, Vertex<TT> *vb) {//вот так надо
                        v1 = va;
                        v2 = vb;
                }
//...........

class Edge {
//...........
        public:
                Edge(Vertex<int> *va, Vertex<int> *vb) {//вот так надо
                        v1 = va;
                        v2 = vb;
                }
//...........

Vertex<char*> e1("parampampam", "sdffsd", 0);
Vertex<char*> e2("pudupidu pu", "sdsfdfsd", 1);
Edge<int> rebro(&e1, &e2);

template<class T>
class A{};
 
template<class T>
class B{
public:
    template<class TT>
    B(A<TT>*){};
};
 
int main() {
    A<int> a;
    B<char> b(&a);
}

template<class T>
class B{
private:
        A<TT>* a;  //Вот про это говорю
public:
    template<class TT>
    B(A<TT>*){};
};

template<typename T, typename TT>
class B{
private:
        A<TT>* a;
public:
        B(A<TT>*){};
};
 
// ...
 
B<char, int> b(&a);

B<int, int> b; //Вот тут вся проблема

#include <iostream>
#include <typeinfo>
 
class A_Base
{
public:
    virtual ~A_Base() {}
    virtual void SomeFunc() { std::cout << "A_Base::SomeFunc" << std::endl; }
};
 
template<typename T>
class A : public A_Base
{
public:
    void SomeFunc() { std::cout << "A<" << typeid(T).name() << ">::SomeFunc" << std::endl; }
};
 
template<typename T>
class B
{
private:
    A_Base* a;
public:
    B(A_Base* x) : a(x) {};
    void Test() { a->SomeFunc(); }
 
};
 
int main()
{
    A<int> a1;
    A<long> a2;
    B<char> b1(&a1), b2(&a2);
    b1.Test();
    b2.Test();
}