使模板类型更具体（T => 确定<X>）以帮助内容辅助

Question

如何使模板类型在内部更具体以帮助内容辅助？

template<class T>class B{  //note: in real case, it has more template parameter
    public: void f(){}
};
template<class B1>class C{ //<-- I know for sure that B1 derived from "B<something>".    
    B1* b;
    void test(){
        b->
             ^ ctrl+space doesn't show f()
    }
};

我糟糕的解决方法是在 C 类中创建模板专业化，但它会以另一种方式混淆内容辅助。

下面是另一种解决方法，但它很乏味。
我必须在B 反映模板参数，并在C 一个接一个地使用这样的反映。

template<class T>class B{  
    public: using reflectiveT=T;
    /* other T e.g. reflectiveT2=T2 , ... */
    public: void f(){}
};
template<class B1>class C{ 
    using BX=B<B1::reflectiveT>; //B<B1::reflectiveT1,..T2,...T3> ... tedious
    BX* b;
    void test(){
        b->
             ^ ctrl+space will show f()
    }
};

问题：

• 它遭受可维护性问题， 当我想重构 B 以便以后有更多/更少的模板参数时。
• 如果BX 恰好是从B<something>派生的类，BXT 将 != BX。

我的梦想是：

template<class B1>class C{ 
    using BX=B<...> as base of B1;   //????
};

我可能也依赖内容辅助，但它极大地帮助我编写非常复杂的类。

编辑

我不能只在 B 中传递 Args 作为 C 的模板参数，因为 C 可能会出错。

例如，B<D>::callback 将被调用而不是下面代码中的D::callback (demo)：-

class x{};
template<class T>class B{
    public: static void callback(){ std::cout<<"B<D>::callback()";       }
};
class D : public B<D>{ //
    public: static void callback(){ std::cout<<"D::callback()"; }
};
template<class... Args>class C{ 
    using BX=B<Args...>;
    BX* b;
    public: void test(){
        BX::callback(); 
        //^ will invoke B<D>::callback (wrong)
        //  instead of D::callback
    }
};
int main(){
    C<D> c;  c.test();  //print "B<D>::callback()"
}

编辑：大大简化问题。

Answer 1

您可以将每个函数的实现和接口分开：

#include <iostream>

// Base class with default implementations and common interface
template<class T> class B {
    static void callback_impl() { std::cout<<"B<T>::callback()\n"; }
    void f_impl() { std::cout << "B<T>::f()\n"; }
public:
    static void callback() { T::callback_impl(); }
    void f() { static_cast<T*>(this)->f_impl(); }
};

class D1 : public B<D1>{ // D1 overrides callback
    friend class B<D1>;
    static void callback_impl(){ std::cout<<"D1::callback()\n"; }
};
class D2 : public B<D2> { // D2 overrides f
    friend class B<D2>;
    void f_impl() { std::cout << "D2::f()\n"; }
};

template<class... Args>class C{
    using BX=B<Args...>;
    BX b;
    public: void test(){
        BX::callback();
        b.f();
    }
};

int main(){
    C<D1> c1;  c1.test();  //print "D1::callback()\nB<T>::f()\n"
    C<D2> c2;  c2.test();  //print "B<T>::callback()\nD2::f()\n"
}