在C++；可以在子类中使用不同的参数值扩展参数化基类吗？ 在我理解的所有语言中，这是不可能的，但是有人告诉我C++是可能的，但是我很难相信它。基本上，当您参数化一个类时，您是在编译阶段创建一个唯一的类，不是吗

如果我的问题不清楚，请告诉我

以下是我试图解释我要做的事情（注意L类）：

/；g++ModifingBaseClassParameter.cpp-o ModifingBaseClassParameter；ModifyFingBaseClassParameter
#包括
使用名称空间std；
模板
阶级基础
{
公众：
Base（）{}
基本（T&T）：m_T（T）{}
T&getMem（）{return m_T；}
私人：
T m_T；
};
模板
F类：基础
{};
模板
L类：F类
{};
int main（）
{
基地一；
F；
L；
你是在谈论模板吗

template<typename T>
class Base
{
    public:
        Base() {}
        Base(T& t) : m_t(t) {}
        T& getMem() {return m_t;}
    private:
        T m_t;
};

class X: Base<int>
{};

class Y: Base<float>
{};

模板
阶级基础
{
公众：
Base（）{}
基本（T&T）：m_T（T）{}
T&getMem（）{return m_T；}
私人：
T m_T；
};
X类：基本类
{};
Y类：基础
{};
您正在学习模板吗

template<typename T>
class Base
{
    public:
        Base() {}
        Base(T& t) : m_t(t) {}
        T& getMem() {return m_t;}
    private:
        T m_t;
};

class X: Base<int>
{};

class Y: Base<float>
{};

模板
阶级基础
{
公众：
Base（）{}
基本（T&T）：m_T（T）{}
T&getMem（）{return m_T；}
私人：
T m_T；
};
X类：基本类
{};
Y类：基础
{};
<代码> > p>如果你想问你是否可以在C++中这样做：

template <> 
class ParamClass<Type1> : public ParamClass<Type2> 
{
};

模板
类ParamClass：公共ParamClass
{
};

那么是的，这是可能的

它经常被使用，例如定义模板列表或继承另一类型的特征。
 如果您想问C++中是否可以做到这一点：

template <> 
class ParamClass<Type1> : public ParamClass<Type2> 
{
};

模板
类ParamClass：公共ParamClass
{
};

那么是的，这是可能的

例如，它经常用于定义模板列表或从其他类型继承特征。
您应该尝试编译它：

$ g++ so-test1.c++ -o so-test1.c++ && ./so-test
so-test1.c++:21: error: expected template-name before ‘<’ token
so-test1.c++:21: error: expected `{' before ‘<’ token
so-test1.c++:21: error: expected unqualified-id before ‘<’ token
so-test1.c++: In function ‘int main(int, const char**)’:
so-test1.c++:27: error: aggregate ‘Z z’ has incomplete type and cannot be defined

<代码> $g++SOTest1.C++ C++ OSTEST1.C++＆./SO测试
so-test1.c++:21:错误：预期模板名称在“之前您应该尝试编译它：

$ g++ so-test1.c++ -o so-test1.c++ && ./so-test
so-test1.c++:21: error: expected template-name before ‘<’ token
so-test1.c++:21: error: expected `{' before ‘<’ token
so-test1.c++:21: error: expected unqualified-id before ‘<’ token
so-test1.c++: In function ‘int main(int, const char**)’:
so-test1.c++:27: error: aggregate ‘Z z’ has incomplete type and cannot be defined

<代码> $g++SOTest1.C++ C++ OSTEST1.C++＆./SO测试
so-test1.c++:21：错误：“之前预期的模板名称无法直接完成您所请求的内容——但使用默认模板参数可以非常接近：

template <typename T>
class Base { };

template <typename T = int>
class X : Base<T> {};

class Y : Base<float>

class Z : X<long> {};

模板
类基{}；
模板
类X：基{}；
Y类：基础
类Z:X{}；

在这种特殊情况下，默认模板参数不会增加太多内容。您必须提供模板参数列表来实例化模板，即使所有参数都提供了默认值。因此，在派生类中重写默认值通常只对第二个和后续参数有用。
您所做的无法直接完成请求，但使用默认模板参数可以非常接近：

template<typename T>
class X: Base<int> 
{};
...
class Z: X<long>
{};

template <typename T>
class Base { };

template <typename T = int>
class X : Base<T> {};

class Y : Base<float>

class Z : X<long> {};

#include <iostream>
#include <typeinfo>

using namespace std;

template<typename T>
class Base
{
    public:
        Base() {}
        Base(T& t) : m_t(t) {}
        T& getMem() {return m_t;}
    private:
        T m_t;
};

template<typename T>
class F: public Base<T>
{};

template<typename T>
class L: public F<long>
{};

int main()
{
     Base<int> iNTEGER;
     F<float> fLOAT;
     L<long> lONG;

     int x;
     cout << typeid(iNTEGER.getMem()).name() << endl;
     cout << typeid(fLOAT.getMem()).name() <<endl; // this works now :)
     cout << typeid(lONG.getMem()).name() <<endl; // this works now :)
}

模板
类基{}；
模板
类X：基{}；
Y类：基础
类Z:X{}；

在这种情况下，默认模板参数不会增加太多内容。即使为所有参数提供了默认值，也必须提供模板参数列表来实例化模板。因此，在派生类中重写默认值通常只对第二个和后续参数有用。
\35; include
template<typename T>
class X: Base<int> 
{};
...
class Z: X<long>
{};

#include <iostream>
#include <typeinfo>

using namespace std;

template<typename T>
class Base
{
    public:
        Base() {}
        Base(T& t) : m_t(t) {}
        T& getMem() {return m_t;}
    private:
        T m_t;
};

template<typename T>
class F: public Base<T>
{};

template<typename T>
class L: public F<long>
{};

int main()
{
     Base<int> iNTEGER;
     F<float> fLOAT;
     L<long> lONG;

     int x;
     cout << typeid(iNTEGER.getMem()).name() << endl;
     cout << typeid(fLOAT.getMem()).name() <<endl; // this works now :)
     cout << typeid(lONG.getMem()).name() <<endl; // this works now :)
}

#包括
使用名称空间std；
模板
阶级基础
{
公众：
Base（）{}
基本（T&T）：m_T（T）{}
T&getMem（）{return m_T；}
私人：
T m_T；
};
模板
F类：公共基地
{};
模板
L类：公共F类
{};
int main（）
{
基整数；
F浮动；
L lONG；
int x；
不能包含
#包括
使用名称空间std；
模板
阶级基础
{
公众：
Base（）{}
基本（T&T）：m_T（T）{}
T&getMem（）{return m_T；}
私人：
T m_T；
};
模板
F类：公共基地
{};
模板
L类：公共F类
{};
int main（）
{
基整数；
F浮动；
L lONG；
int x；
我想你需要澄清你的问题。你问了一些关于类foo的问题，然后制作了一个类栏：public foo？@stephenmm不管它是否可编译-发布你所得到的解决问题的代码。我发现了一篇讨论模板和继承的精彩文章。我需要我花了一些时间仔细阅读，但似乎我的答案就在那里，似乎是可能的，但我只需要记住将其称为模板。我的其他语言似乎也有点欠缺。尽管如此，从我对文章的快速阅读来看，似乎大多数时候你应该使用继承而不是模板/参数不幸的是，我正在使用第三方库，在这件事上我没有选择的余地。发布一些代码来说明你的问题。我认为你需要澄清你的问题。你问了关于foo类的问题，然后制作了一个类栏：public foo？@stephenmm不管它是否可编译-发布你有什么可以解决的问题我们的问题。我发现了一篇讨论模板和继承的精彩文章。我需要一些时间来彻底阅读它，但似乎我的答案就在那里，似乎是可能的，但我只需要记住把它称为模板。我的其他语言似乎也有点欠缺。尽管如此，从我对这篇文章的快速阅读可以看出ems和大多数时候一样，您应该使用继承而不是模板/参数。不幸的是，我使用的是第三方库，在这方面我没有选择。为什么不在启动（不可编译）之前验证这个问题代码？因为我沉迷于写作。马丁，我并不想对你或这里的其他任何人感到恐怖，但当有人问一个模糊的问题时，最好的办法就是等待他们进一步回答。如果我们都等着，想想这会是一个多么好的网站啊！一个快乐的大气球！我喜欢快乐的大气球。虽然你常常很简洁，但我还是喜欢你没有专业知识