具有公用基的派生类的模板专门化
是指在面向对象编程中，通过继承和模板化技术，创建一个派生类，该派生类可以在基类的基础上进行特定功能的扩展和定制化。
具有公用基的派生类的模板专门化的分类：
- 单继承模板专门化：派生类只继承一个基类，并在基类的基础上进行功能扩展和定制化。
- 多继承模板专门化：派生类同时继承多个基类，并在这些基类的基础上进行功能扩展和定制化。
具有公用基的派生类的模板专门化的优势：
- 代码复用：通过继承基类，可以重用基类中已经实现的功能，避免重复编写相同的代码。
- 扩展性：可以在基类的基础上进行功能扩展，满足特定需求。
- 可维护性：通过模板化的方式，可以将派生类的定制化功能与基类的公共功能分离，便于维护和修改。
具有公用基的派生类的模板专门化的应用场景：
- Web开发：在前端开发中，可以通过继承和模板化技术，创建特定功能的派生类，如自定义组件、UI库等。
- 后端开发：在后端开发中，可以通过继承和模板化技术，创建特定功能的派生类，如自定义框架、ORM库等。
- 软件开发：在软件开发中，可以通过继承和模板化技术，创建特定功能的派生类，如自定义插件、工具库等。
腾讯云相关产品和产品介绍链接地址：
- 云服务器（ECS）：提供弹性计算能力，满足不同规模和需求的应用场景。产品介绍链接
- 云数据库MySQL版（CDB）：提供高性能、可扩展的关系型数据库服务。产品介绍链接
- 云原生容器服务（TKE）：提供高可用、弹性伸缩的容器化应用管理平台。产品介绍链接
- 云存储（COS）：提供安全、可靠、低成本的对象存储服务。产品介绍链接
- 人工智能平台（AI Lab）：提供丰富的人工智能算法和模型，支持开发者构建智能化应用。产品介绍链接
请注意，以上链接仅为示例，实际使用时应根据具体需求选择合适的产品和服务。
相关·内容
1回答
嗨，谁能解释一下模板部分专门化的正确语法是什么？或者甚至有可能？任何帮助都非常感谢。
template < typename A >
class X
{
};
template < typename B >
class Y
{
};
template < template< typename > class U, class T >
class Z
{
// there are other methods in class which i don't want to replicate
void func
浏览 0提问于2016-03-02得票数 0
回答已采纳
1回答
我正在将一个大型代码库移植到clang (使用g++和英特尔c++构建)。类似于以下代码片段的代码在上编译和工作，但无法使用进行编译。第二次调用MinOp应该(AFAICT)获得基类专门化(“不要调用我！”)，但是clang试图实例化std::min版本并失败：
#include <algorithm>
#include <iostream>
#include <type_traits>
template <typename T> class Vector
{
public:
Vector() : xyz{} {}
Vector
浏览 1提问于2017-03-27得票数 0
回答已采纳
1回答
C++模板专业化
、、
你好!有人知道如何达到或模仿以下行为吗？(此代码导致编译时错误)。
例如，我只想在派生类.中添加特定的模板专门化。
struct Base {
template <typename T> void Method(T a) {
T b;
}
template <> void Method<int>(int a) {
float c;
}
};
struct Derived : public Base {
template <> void Method<float>(float a
浏览 0提问于2010-10-23得票数 3
回答已采纳
2回答
如果一个类的子类定义了特定的成员函数，我将尝试使用std::enable_if来专门化它。否则，它应该使用基类中定义的默认实现。
#include <boost/mpl/list.hpp>
#include <boost/function_types/function_type.hpp>
#include <boost/tti/has_member_function.hpp>
#include <iostream>
#include <type_traits>
#include <memory>
BOOST_TTI_H
浏览 4提问于2014-12-15得票数 7
回答已采纳
3回答
成员模板专门化及其范围
、、、
在我看来，C++不允许在命名空间和全局作用域以外的任何作用域中进行成员模板专门化(MS VSC++ Error C3412)。但对我来说，在派生类中专门化基类的主成员模板是有意义的，因为这就是派生类所做的-专门化基类中的内容。例如，考虑以下示例：
struct Base
{
template <class T>
struct Kind
{
typedef T type;
};
};
struct Derived : public Base
{
/* Not Allowed */
using Base::Kind;
template <
浏览 0提问于2009-04-30得票数 4
回答已采纳
不幸的是，我主要在Java上下文中学习了类设计和设计模式；因此，有时我很难将熟悉的模式转换为C++。
假设我们希望有一个基类，它的功能由一个子类扩展。在Java中，我们会这样做：
public class BaseClass<T> {
//T is used here
protected int foo = 0;
}
public class DerivedClass<T> extends BaseClass<T> {
public void incr_foo() {
++foo;
}
浏览 6提问于2014-04-30得票数 4
回答已采纳
3回答
代码：
template<class T>
struct A {
void f1() {};
void f2() {};
};
template<>
struct A<int> {
void f2() {};
};
int main() {
A<int> data;
data.f1();
data.f2();
};
错误：
test.cpp: In function 'int main()':
test.cpp:16: error: 'struct A<int>' has
浏览 1提问于2011-02-10得票数 12
回答已采纳
3回答
我如何专门化一个模板化函数，它被定义为基类中的纯函数？
struct A {
virtual void func(int a) = 0;
//virtual void func(int a) {} // replace above line with this and it works
};
struct B : public A {
template<typename T> void func(T t) {
cout <<"hello"<<endl;
}
};
template<>
浏览 0提问于2019-07-09得票数 3
回答已采纳
5回答
我试图允许一个子类定义变量函数专门化。例如：
#include <iostream>
#include <vector>
#include <memory>
class BaseClass
{
public:
BaseClass() {};
virtual ~BaseClass() {};
template<typename GenericData>
void ReceiveData(GenericData &inData)
{
throw std::runtime_error(
浏览 6提问于2018-01-12得票数 0
回答已采纳
这就是我的问题:我有一个类"Nodo“(用来生成but )，它有一个指向与属性类型相同类型的指针数组，然后我有一个子类"NodoAvl”(使AVL树)必须继承该属性，但是指针必须指向它的相同类型，即指向"NodoAvl“。有什么办法吗？也许用我的代码，我可以更好地解释它：
#include<iostream>
using namespace std;
template <class T>
class Nodo
{
protected:
T d;
"my_own_type" *h[2] = {NULL}; // He
浏览 3提问于2016-11-05得票数 2
要专门化一个类模板，必须重新定义底层基模板(即非专门化的类模板)中的所有成员函数，即使它们预计大部分保持不变。有哪些公认的方法和“最佳实践”可以避免这种代码重复？
谢谢。
浏览 0提问于2009-01-31得票数 5
回答已采纳
1回答
我编写了以下隐藏成员函数模板的代码。
#include <iostream>
struct A
{
template<int> void func()
{
std::cout<<"Function tamplate of A"<<std::endl;
}
};
struct B : A
{
template<char> void func()
{
std::cout<<"Function tamplate of B
浏览 1提问于2017-10-16得票数 23
回答已采纳
2回答
成员访问和模板专门化
、、、、
我有这个类模板
template <typename T>
class Wrapper
{
public:
virtual void parse(std::string s) = 0;
protected:
T value;
};
理想情况下，每种类型都应该知道如何从字符串中解析自身，所以我希望有这样的专门化：
template<>
class Wrapper<int>
{
public:
virtual void parse(std::string s)
{
浏览 5提问于2013-09-19得票数 7
1回答
SFINAE适用于功能体吗？
、、、、
我有以下示例代码：
class Serializable {};
class MyData : public Serializable {};
void GetData( Serializable& ) {}
template<typename T>
void GetData( T& data )
{
std::istringstream s{"test"};
s >> data;
}
int main()
{
MyData d;
GetData(d);
}
()
基于重载解析规则，应该首选非模板版
浏览 5提问于2014-12-04得票数 3
回答已采纳
2回答
我有以下类的层次结构
class Boy : Child
class Girl : Child
class Parent
{
vector<Child> children;
}
class Anna : Parent
但是我知道在编译之前安娜总是只会有男孩，所以我不想只使用父母的儿童界面，我希望安娜也能访问男孩的成员，这对她的孩子们会更好！不管怎么说，在没有强制演员的情况下，是否可以对此进行建模？
class Anna : public Parent
{
vector<Boys> children; //Here i just Hide the base cla
浏览 5提问于2015-02-17得票数 0
回答已采纳
4回答
我想问一个关于派生类的编程风格的问题：
class A
{
public:
virtual foo1()=0;
}
class B: public A
{
public:
virtual foo1();
virtual foo2();
}
class C: public A
{
public:
virtual foo1();
}
int main() {
B mB();
C mC();
mB.foo2() //OK!
mC.foo2() // obviously, it is not correct
return 0;}
因此，派生类的公共方法是否应该少
浏览 3提问于2013-03-13得票数 1
回答已采纳
1回答
我有以下代码：
#include <iostream>
#include <type_traits>
template <typename T> struct CSizex {
};
struct CSize : public CSizex<int>
{
};
struct Logger
{
template <typename T>
Logger& operator<< (T& value)
{
return *this << const_ca
浏览 2提问于2014-11-05得票数 3
回答已采纳
1回答
我正在我的工作中开发一个库，我设计了一个复杂的继承，其中包括模板类并从中派生出来。我的问题是，基模板类具有虚拟重载操作符，它接受2个参数并返回一些值。在基类中，将实现此运算符，并且大多数派生类都不会重新实现该运算符。
其他一些类使用派生类来完成某些工作，并使用它们的运算符成员函数。只要派生类没有其他重载运算符，即使有不同数量的参数，一切都能正常工作。如果这样做了，那么基类操作符就不能作为object()使用，因为编译器找不到合适的成员函数(抱怨参数计数不匹配)。
是否指定了基类的默认模板参数并不重要。此外，派生类的定义顺序不会改变引起问题的操作符(始终是SpecificDerived类)。
下
浏览 1提问于2014-06-11得票数 4
回答已采纳
2回答
我有一个套接字数据类型类，用于从套接字流读取和解析值(也可以用于文件)。
让我的课成为mc_double
class mc_double {
private:
double value;
public:
bool read(socket);
write(double);
}
实际的类比较复杂，但这是原则。现在，我需要从流中解析float。浮点数类似于double，因此已经实现了int。我不能将这个类定义与所有的double、int和float合并吗？
这就是我的意思：
class mc_<typename
浏览 3提问于2013-03-19得票数 0
回答已采纳
假设我有一个模板类
template <typename T> struct Node
{
// general method split
void split()
{
// ... actual code here (not empty)
}
};
需要在三角类案件中专门处理这个问题。就像这样
template <>
struct Node <Triangle*>
{
// specialise the split method
void split() {}
} ;
但我不想再重写整个模板了
浏览 6提问于2012-02-17得票数 27
回答已采纳
1回答
我正在编写一个程序，在这个程序中，ServiceWorker的派生类(如消防队员)可以“对抗”来自类事件(火、伤、抢劫)的对象。对抗将返回一个布尔值，即它是否成功。例如，消防队员面对火灾会是成功的，但面对抢劫的消防员则不会成功。ServiceWorker将跟踪对抗和成功对抗的次数，并有一种对质方法来确定对抗是否成功。
我想使用特性来存储ServiceWorker的每个派生类在其类定义中所能面对的内容。然而，在ServiceWorker中，直面方法创建了特性类，但是我希望将它专门化为派生类，这样每个派生类都只知道它可以面对什么。
class Incident { };
class Fire :
浏览 3提问于2016-01-02得票数 3
我在考虑使用CRTP类来帮助处理重载，并且想知道下面的代码会做什么：
#include <iostream>
#include <typeinfo>
template <class TDerived>
class FunctionImplementation
{
};
class AbstractFunction
{
};
class BaseFunction : public AbstractFunction, public FunctionImplementation<BaseFunction>
{
};
class DerivedF
浏览 0提问于2013-02-20得票数 1
回答已采纳
1回答
首先，我知道这个问题似乎是重复的。但我读过许多类似问题的帖子，但没有找到答案。
第二，到目前为止，我对我的解决方案没有任何问题。所以我要问的是，我的解决方案是否正确，没有陷阱。
假设我有一个类模板Particle，它应该是中的一个基类，并且打算有一个静态变量fName，可能因实例而有所不同。
基座
Particle.h
#pragma once
#include <iostream>
#include <string>
template<typename CONCRETE_PARTICLE>
class Particle
{
private :
浏览 4提问于2021-10-09得票数 2
2回答
我发现了一些问题，它们问的是类似的问题，但无法为我的特定情况找到直接的答案。模板的整个语法让我非常困惑，所以我可能只是误解了一些东西。 我有一个类模板，它应该接受每种类型。简单的例子： template <class T>
class State {
public:
void set(T newState);
T get();
private:
T state;
};
template <class T>
void State<T>::set(T newState){
state = newState;
}
temp
浏览 21提问于2019-03-29得票数 5
回答已采纳
3回答
编辑:我使用tdm-gcc-4.7.1-2用于
不知道怎么解决这个问题。我想用它作为一种类型列表，让我知道我正在尝试使用B的类型不存在的类型。
template <typename T, typename U>
struct A {
typedef pair<T, U> type;
};
struct B : A<int, string>, A<int, float> {};
B::type foo; // won't compile, ambiguous reference, as expected
B::A<int,
浏览 1提问于2013-02-08得票数 9
回答已采纳
假设我上了这门课：
template <class T>
class Test
{
Test(T* x);
const T* const t;
int i{0};
};
我希望t总是用x初始化
template <class T> Test<T>::Test(T* x) : t{x} {}
我有两个专业：
template <> Test<Foo>::Test(Foo* x) : t{x} { i = 1; }
template <> Test<Bar>::Test(Bar* x) :
浏览 4提问于2021-09-16得票数 4
回答已采纳
上周以来我偶然发现了一些我无法克服的事情.
有这种情况：
template<typename> struct fx;
template<typename R, typename...Args>
struct fx<R(Args...)>
{
virtual R operator()(const Args & ...x) const = 0;
};
这是：
template<typename> struct fx_err;
// I feel here something is wrong, but I can't fi
浏览 9提问于2015-07-27得票数 2
回答已采纳
标头mycomputationclass.h
#pragma once
template<typename numberType, bool increaseByOne>
class MyComputationClass
{
numberType a = 1;
numberType b = 2;
numberType compute();
};
#include mycomputationclass.hpp
头实现文件mycomputationclass.hpp
#pragma once
#include mycomputationclass.h
templa
浏览 3提问于2020-03-20得票数 2
回答已采纳
例如，在下面的程序中，我通过"using“关键字来取消名称隐藏。如果我有一个基类和一个派生类“我得到预期的歧义调用错误”。但是如果我有两个派生类(子类和孙类)，现在子类和孙类在这里有相同的重载函数，我也可以通过"using“关键字来取消名称隐藏。但它正在编译并得到输出。我的问题是，为什么我没有收到“对重载函数的模糊调用”的错误。
class baseNameHiding
{
protected:
int nameHidingexample(int t)
{
cout<<"im baseeeeeeeeeeee"<<endl;
浏览 3提问于2015-03-28得票数 3
1回答
在不违反严格别名规则的情况下，创建从抽象模板基类派生的对象数组的最佳方式是什么？每个派生对象将以不同的方式定义基类的模板参数，但只能通过常量枚举值。下面是一个例子
enum BlaEnum
{
Bla1,
Bla2,
Bla3
};
template <class T, BlaEnum bla = Bla1>
class A
{
public:
virtual void Foo() = 0;
T att;
BlaEnum bll;
};
class B : public A<int, BlaEnum::Bla2>
{
public:
浏览 4提问于2018-12-01得票数 0
3回答
我是C++的新手。在我的学习阶段，我遇到了以下问题。我正在尝试从一个类模板Queue派生一个类stack。编译器在stack的构造函数中引发以下错误
..\src\TrainingDay2.cpp:44:3: error: 'b' was not declared in this scope
b=a;
请帮助找出根本原因。
#include <iostream>
using std::cout;
using std::endl;
template<class T> class Queue //Base class
{
private:
T
浏览 0提问于2015-03-13得票数 2
可以解释为什么基类指针不能赋值给派生类指针吗？我知道这是不可能的，但是我想知道.logically派生类包含基class.Let的原因。
浏览 1提问于2014-12-09得票数 2
我正在尝试定义基类，它只包含typedef的。
template<typename T>
class A
{
public:
typedef std::vector<T> Vec_t;
};
template<typename T>
class B : public A<T>
{
private:
Vec_t v; // fails - Vec_t is not recognized
};
为什么在B中我收到Vec_t无法识别的错误，并且我需要显式地编写它？
typename A<T>::Vec_t v;
浏览 0提问于2009-10-29得票数 69
回答已采纳
2回答
访问派生类中类的受保护成员
、、、、
我这里有一个旧的代码库，他们使用了受保护的成员变量。这是不是一个好主意可以讨论。但是，代码必须使用gcc3编译得很好。我有一个派生模板类Bar，它使用来自类template Foo的受保护成员x，如下所示
template <class Something> class Foo {
public:
// stuff...
protected:
some::type x;
}
template <class Something> Bar : Foo<Something> {
public:
void cleanup();
}
在c
浏览 4提问于2009-10-26得票数 9
回答已采纳
1回答
继承和成员函数模板重载
、、、
我尝试使用clang (3.0版)编译以下代码，但它给出了这个错误
error: no matching member function for call to 'a'
在调用__a.a<0>()中。然后，我尝试使用g++ (版本4.2.1)，它可以按照预期进行编译和工作(打印出1 2)。
#include <iostream>
struct A {
template <int> int a() { return 1; }
};
struct B: A {
using A::a;
template <int,int>
浏览 1提问于2011-12-18得票数 3
回答已采纳
1回答
有没有办法在XSD中定义一个类型别名/ strong typedef / simpleType并带有一个空的限制？
<xsd:simpleType name="identifier">
<xsd:restriction base="xsd:string">
<xsd:pattern value="^[a-zA-Z_][a-zA-Z0-9_]*$" />
</xsd:restriction>
</xsd:simpleType>
<xsd:simpleType nam
浏览 2提问于2013-04-18得票数 5
回答已采纳
1回答
抽象基类子类的C++模板专门化
、、、、
假设我有一个纯粹的抽象基类。类模板实现了这个接口，并且是专门化的。现在，我的问题是，这种专门化应该能够处理专门化的子类。所以，我尝试了enable_if，但是子类最终是抽象的..。我怎么才能避开这一切？
举个例子：
// This example doesn't work because a subclass of A does not satisfy the
// specialization for B<T>::foo()
class A {
public:
virtual void foo() = 0;
};
template <class T>
浏览 2提问于2014-07-24得票数 1
回答已采纳
1回答
根据标准中的一些引语：
..。对于使用声明引入到派生类的非转换函数，为了定义隐式对象参数的类型，函数被视为派生类的成员。
并考虑以下代码：
#include <iostream>
struct Base {
void show(double) {
std::cout << "0" << std::endl;
}
};
struct Test :Base {
using Base::show; //#1
void show(double) { //#2
std::cout
浏览 4提问于2020-04-07得票数 1
回答已采纳
2回答
链接到我的另一个问题() --我有了这个构造--我的想法是，我想从GPtrBase派生专门的类型，而不必每次都重写赋值操作符：
template<class BaseType,class Self>
class GPtrBase
{
public:
...
Self& operator=(const BaseType& rhs)
{
...
return *this;
}
};
然而，当我专攻时，比如：
class GDrawablePtr : public GPtrBase<MyDrawab
浏览 1提问于2013-04-25得票数 1
回答已采纳
1回答
我有这样的代码：
#include <string>
#include <map>
typedef std::less<std::string> Comparator; // simplified
typedef std::allocator<std::pair<const std::string, int>> Allocator; // simplified
template<class T>
struct Base
{
typedef std::map<std::string, T, Compara
浏览 2提问于2019-09-17得票数 2
回答已采纳
4回答
用模板方法覆盖虚拟方法
、、、
可能重复：
在基类中，函数my_func被定义为虚拟函数。但是，在派生类中，我希望my_func成为一个模板方法。这个是可能的吗？
似乎并非如此。我得到了“不能分配抽象类型的对象”的错误，我认为这与编译器不承认基类中虚拟my_func的覆盖有关。这是否揭示了一个糟糕的设计？
非常感谢。
更新:谢谢你的回答。你们中的一些人建议我发布一些代码，就这样吧。在基类中：
virtual void Fill(EventInfo* info, EasyChain* tree, vector<Muon*>& muons, vector<Electron*>&
浏览 6提问于2012-12-11得票数 9
回答已采纳
1回答
使用声明作为过载者
、、、、
我们在标准中有以下简单的示例(稍微修改以添加main和输出)：
struct A {
virtual void f()
{
cout << "A\n";
}
};
struct B : virtual A {
virtual void f()
{
cout << "B\n";
}
};
struct C : B, virtual A {
using A::f;
};
int main()
{
C c;
c.f();
浏览 1提问于2018-10-29得票数 6
回答已采纳
1回答
我在尝试实现一个红黑树类时遇到了一个问题。我之前构建了一个二叉树类，所以我从它继承了我的红黑树。
二叉树声明如下：
template <typename KeyType, typename DataType>
class BTree{
protected:
struct BTreeNode{
KeyType key;
DataType data;
BTreeNode *left;
BTreeNode *right;
BTreeNode *parent;
BTreeNode(con
浏览 14提问于2017-07-22得票数 0
如果两个类都是模板，为什么不能简单地使用基类中定义的类型？是否有关于模板成员搜索的规则？下面是我可以推断出的最简单的例子：
struct iA {
using type = int;
};
template <class T> struct tA {
using type = T;
};
struct iB1 : iA {
void f(type i) {}
};
struct iB2 : tA<int> {
void f(type i) {}
};
template <class T> struct tB1 : iA {
浏览 2提问于2015-03-01得票数 5
回答已采纳
我找到了一个用于图形的开源类库。当我将它包含在我的项目中时，它有很多错误，我试图修复它们。但是有一个编译错误，我无法解决它。
基类：
template <typename K, typename W, typename T>
class _base_graph
{
//...
protected:
std::map<K, T> nod;
std::list<edge> edg;
};
派生类：
template <typename K, typename T = void*>
class graph : pub
浏览 5提问于2012-11-13得票数 3
回答已采纳
类：
template <class TYPE, class KTYPE>
class ExtAvlTree : public AvlTree<TYPE, KTYPE> {
public:
void ExtAvlTree_PrintDictionary();
void ExtAvlTree_ProcessNode (KTYPE key);
void ExtAvlTree_insertNewWord(string, int);
};
当我想在AvlTree中使用一个函数时，我必须这样做：
template <c
浏览 1提问于2016-05-14得票数 0
2回答
我有一个看起来像这样的类：
class Base
{
public:
Base( int val = 0 ) : value( val ) {};
int value;
};
类A和B继承Base
class A : public Base {};
class B : public Base {};
我还有一个模板化的类，它的签名类似于：
template < class T >
class Temp
{
public:
Temp ( const T & val = T() ) : m_T(
浏览 0提问于2010-08-21得票数 1
2回答
我在模板专门化方面遇到了问题，因为我不想重新定义一个方法，我想使用泛型方法。
template<class VarsContainer, class Specific>
class State
{
public:
State();
~State(){}
HSError_t Update(LoggerData const &lData);
VarsContainer state;
void swap(State &rhs);
State & operator=(State rhs); // pass by value copy
p
浏览 0提问于2013-06-26得票数 0
回答已采纳
2回答
我使用显式模板专门化来使用信息初始化std：：向量，但只对特定类型的std：：向量进行初始化，因此显式专门化。在构造函数中，如果我试图调用push_back或std::vector中的任何其他现有函数，编译就会失败。有什么问题，我该如何解决？
简化示例：
namespace std
{
template<>
class vector<int>
{
public:
vector(void)
{
int value = 5;
push_back(value);
}
};
}
编译器消息：
In constr
浏览 2提问于2013-12-27得票数 1
回答已采纳
3回答
我有一个
template <int N> class Base
和
class Derived : public Base<1>
..。有没有一种方法可以从Derived::myMethod()的定义内部访问int N (而不是得到编译器错误"use of undeclared 'N'")？
更准确地说，我想做的是
void Derived::myMethod() {
for (int n=0; n<N; n++) { ...
浏览 1提问于2012-08-09得票数 3
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
即时通信 IM活动推荐
腾讯云开发者
