什么是奇怪的重复模板模式(CRTP)？
奇怪的重复模板模式（Curiously Recurring Template Pattern，CRTP）是一种C++编程技术，它利用了C++的模板特性和继承机制。CRTP的核心思想是通过在派生类中继承一个模板基类，并将派生类自身作为模板参数传递给基类，从而实现在编译期间的静态多态性。
CRTP的主要特点和应用场景如下：
- 特点：
- CRTP是一种编译期间的技术，通过模板实现静态多态性，避免了运行时的开销。
- CRTP通过在派生类中继承模板基类，实现了一种间接的静态多态性，使得派生类可以在编译期间调用基类中的成员函数。
- CRTP可以用于实现一些通用的代码模式，如计数器、单例模式等。
- 应用场景：
- CRTP常用于实现静态多态性，特别是在需要在编译期间确定类型的情况下，可以提高代码的效率和性能。
- CRTP可以用于实现一些通用的代码模式，如计数器、单例模式等，通过在派生类中继承模板基类，可以避免代码的重复编写。
腾讯云提供了一系列云计算相关产品，其中与CRTP相关的产品和链接如下：
- 腾讯云C++ SDK：腾讯云提供的C++开发工具包，可用于在C++项目中使用腾讯云的各类云服务。详情请参考：腾讯云C++ SDK
- 腾讯云函数计算（Serverless）：腾讯云提供的无服务器计算服务，可用于按需运行代码，无需关心服务器管理和资源调度。详情请参考：腾讯云函数计算
- 腾讯云容器服务（TKE）：腾讯云提供的容器化部署和管理服务，可用于快速构建、部署和扩展容器化应用。详情请参考：腾讯云容器服务
请注意，以上产品仅作为示例，实际选择产品时应根据具体需求进行评估和选择。
相关·内容
这样做的一个好理由是什么？
template <class BaseClass>
class DerivedClass : public BaseClass
{
}
我正在看一个同事的代码，我看到了这个模式，我觉得非常奇怪。
我能想到的唯一原因是，也许在DerivedClass中，您想要构造一堆BaseClass实例。在编写代码时，您不知道BaseClass可能是什么，因此需要使用它进行参数化。
但是，我不认为他会这么做。
那么你为什么要做这样的事情呢？
浏览 2提问于2014-03-31得票数 0
3回答
派生类作为模板参数的用途是什么？
、、、、
这个模式的目的是什么？叫什么来着？当我第一次看到它的时候，它看起来非常奇怪，尽管我现在已经看过很多次了。
template<typename Derived>
struct Base {
//...
};
struct Example : Base<Example> {
//...
};
浏览 13提问于2010-10-27得票数 8
回答已采纳
1回答
继承和CRTP
、、
出于实际原因，我有一个类似这样的类
template <class A>
class CRTP
{
template <int (A::*Member)()>
int func(void * obj)
{
int result
// Do something with Member, like
// result = (reinterpret_cast<A*>(obj)->*Member)();
return result;
}
};
template &l
浏览 0提问于2013-03-10得票数 1
1回答
我有一个类作为一些原语或自定义类型的包装器。我想为自定义模板类型编写显式专门化。我的代码复制了问题：
template < class T >
struct A {
void func() { std::cout << "base\n"; }
};
template <>
struct A<int> {};
template < class T, class CRTP >
struct BaseCrtp {
void someFunc() {
CRTP::someStaticFunc
浏览 5提问于2022-08-25得票数 3
回答已采纳
1回答
在PyTorch C++关于GitHub 的官方示例中，您可以看到类的奇怪定义：
class CustomDataset : public torch::data::datasets::Dataset<CustomDataset> {...}
我的理解是，这定义了一个类CustomDataset，它“继承”或“扩展”torch::data::datasets::Dataset<CustomDataset>。这对我来说很奇怪，因为我们正在创建的类是从另一个类继承的，这个类是由我们是creating...How的类参数化的，它甚至可以工作吗？什么意思？在我看来，这就像一个继
浏览 2提问于2020-04-20得票数 6
回答已采纳
模板方法允许为不同静态类型的参数跨一组方法实例。自动参数推导避免了信息的重复。
我们所面临的情况是，我们希望自动推断为模板参数的静态类型是类实例本身的类型。(在调用站点上，实例的类型可以是比声明模板方法的类更专业的类型。)
例如：
class Base
{
public:
template <class T_callingObject>
T_callingObject foo()
{
bar += 1;
// We have a strong guarantee on this cast only if T_callingOb
浏览 0提问于2014-07-03得票数 0
2回答
可能重复：
template<typename T>
struct A {
typename T::Sub s;
};
struct B : A<B> {
struct Sub {};
};
Clang正在报告此错误：
todo.cc:3:15: error: no type named 'Sub' in 'B'
typename T::Sub s;
~~~~~~~~~~~~^~~
todo.cc:6:12: note: in instantiation of template class 'A&l
浏览 3提问于2012-07-23得票数 0
我没有对这个问题的准确描述，所以我只是在问这是否可能(如果是的话，其他一些信息会更好)。
一位程序员告诉我，你可以避免由虚函数/多态性引起的运行时开销。他说，为了避免运行时开销，你可以在名为Curiously_recurring_template_pattern的模式中使用模板，它看起来像这样：
class Derived : public Base<Derived>
{
// ... implementation here
};
这个奇怪的循环模板模式是如何工作的？
如何使用奇怪的递归模板模式来替换正常的虚函数/多态？
我说错了吗？
浏览 0提问于2013-06-08得票数 9
回答已采纳
此代码只在调用CRTP的方法时编译和工作：
template <typename CRTP>
struct crtp
{
// using type = typename CRTP::type; // will not compile
void print() const
{
using type = typename CRTP::type; // compiles
static_cast<const CRTP&>(*this).print();
}
};
#include <iostrea
浏览 2提问于2022-08-31得票数 -1
我在想奇怪的是反复出现的模板模式。
我发现它非常有用，而且它可以很好地调节许多任务。但我不得不承认，我在野外没有看到多少CRTP代码。
很难理解吗？总体来说，虚拟功能更容易吗？它不应该用于90%的虚拟关键字出现的情况吗？
浏览 0提问于2011-12-07得票数 11
回答已采纳
TL;DR；-我希望能够在父类的函数中创建子类的对象，而不需要指定确切的子类。
class CParent用于在m_data中存储一些特定于“版本”的数据。每个class CChild*将按照该组内的相同规则使用其自己的数据组进行操作。
现在，我必须在每个CChild*类中声明CParent *replicate(int ver)，但它们是相同的，并且我认为我只能在父类中定义这个函数。
class CParent
{
public:
int m_ver;
std::vector<int> m_data;
CParent(int ver)
{
浏览 0提问于2018-07-27得票数 2
我可以覆盖模板类型的子类并将其用作超类吗？
我是一名Java程序员，这与泛型配合得很好，但是我不熟悉如何在C++中做很多事情
我可以使用类吗？
template <typename T>
class A{
public:
T get(){
return t;
}
A(){
}
void set(T tt){
t=tt;
}
private:
T t;
};
并将其扩展为类似于
class B:A<B>
其中，子类B用作类A的泛型类型，而类B不需要泛型
浏览 1提问于2012-03-14得票数 3
回答已采纳
我一直在研究奇怪的重复出现的模板模式，以确定如何使用它来实现Bridge设计模式。
我的问题是将IBridgeConnector::GetBridgeImpl方法连接到Bridge::GetBridgeImpl方法，因为覆盖方法实际上是模板化的。
既然虚拟分派在这种情况下不起作用，那么将这些方法指向彼此的最佳方式是什么？功能委派？有没有更好的模式呢？
这应该怎么做呢？
谢谢你的帮助！
在没有shared_ptrs、OpenGL和DirectX调用的情况下，我尽可能地简化了代码。:)希望这能在将来对某些人有用！
#include <string>
/*****************
浏览 0提问于2013-02-06得票数 1
回答已采纳
1回答
作为虚拟函数的参数的子类对象。
、、、、
好的，基本上，我在另一个类中使用了一个类，它要求object报告它与另一个相同类型的对象的关系。效果很好。这个类代表一个协议。不幸的是，现在我正试图通过添加一个称为包装器的类来修饰类关系。这个类的主要功能是它可以将第一个类作为参数(或其他做同样操作的东西)：
template< class InnerInterpreter >
class WrapperInterpreter
{
public:
WrapperInterpreter(const InnerInterpreter &m) : innerMessage(m) {}
...
virtu
浏览 0提问于2014-04-14得票数 2
回答已采纳
2回答
我想要一个具有多种可能实现的接口，在编译时选择。我看到CRTP是实现这一点的最佳选择。为什么会这样呢？另一种选择是策略模式，但我在任何地方都看不到这种技术：
template <class Impl>
class StrategyInterface
{
public:
void Interface() { impl.Implementation(); }
void BrokenInterface() { impl.BrokenImplementation(); }
private:
Impl impl;
};
class StrategyImplemen
浏览 4提问于2014-01-11得票数 9
1回答
我尝试用模板化的类实现一个CRTP，但我在下面的示例代码中遇到错误：
#include <iostream>
template<class T> class Traits
{
public:
typedef typename T::type type; // <- Error
// : "no type named 'type' in 'class MyClass<double, 3u, 3u>'
浏览 3提问于2012-08-03得票数 7
回答已采纳
我正在寻找一种在基类的函数中使用派生类类型的方法，类似于模板化函数。 class Base
{
T foo() const
{
return T(*this);
}
}
class Derived : public Base
{
} 这类似于我想使用它的目的，这样我就不必在每个派生类中将foo作为一个纯虚函数来覆盖。我们的目标是找到一种方法，让foo中的T成为派生类的类型。例如，在派生类型的对象上调用foo应该调用如下所示的foo版本： Derived foo() const
{
return Derived(*this);
} 我知道这可能
浏览 14提问于2020-09-27得票数 2
回答已采纳
3回答
此代码使用clang 3.7.1编译(没有诊断)，但GCC 5.3.0 ()失败：
#include <iostream>
template<typename T>
struct A {
void foo()
{
static_cast<T*>(this)->implementation();
}
};
struct Crtp : A<Crtp> {
template<typename T>
friend struct A;
private:
void impl
浏览 1提问于2016-04-07得票数 8
回答已采纳
我知道在C++中缺乏反射和基本的模板机制，所以下面的示例无法工作。但也许有一种以另一种方式达到预期目的的黑客攻击？
template <typename OwnerClass>
struct Template
{
OwnerClass *owner;
};
struct Base
{
virtual void funct ()
{
Template <decltype(*this)> temp;
// ...
}
};
struct Derived : public Base
{
void wh
浏览 1提问于2019-03-15得票数 1
回答已采纳
1回答
我正在尝试创建一个CRTP类，其中包含一个未定义的类-由派生类定义，如下所示：
#include <memory> // unique_ptr
template<typename T>
class crtp
{
public:
class inside;
crtp();
std::unique_ptr<inside> m;
};
这适用于非模板化数据类型。
但是，如果我试图传递一个模板化的类，例如：
template<>
template<typename T>
class
浏览 0提问于2012-07-25得票数 1
2回答
我正在尝试用的概念实现C++20。关键是防止父类模板被除其子类之外的任何类型参数实例化。
编译器抱怨requires-clause中的自引用requires-clause。
#include <concepts>
//error: ‘CRTP_Root’ was not declared in this scope
// | requires std::derived_from<derived_type, CRTP_Root<derived_type>>
template<typename derived_type>
requires
浏览 19提问于2022-08-10得票数 1
1回答
我想为我的向量类添加一个迭代器类类型，并且我声明了一些比较操作符作为迭代器class.but的朋友函数--它没有正确地完成，我做了前向声明。
template<class object>class vector;
template<class object>
bool operator<(typename vector<object>::const_iterator& lhs, typename vector<object>::const_iterator& rhs);
template<class object&g
浏览 3提问于2019-11-13得票数 2
回答已采纳
1回答
使用C++模板更改操作
、、、
这可能是一个重复的问题，但我不确定如何搜索它，我还找不到任何东西。假设我有两个类，如下所示：
class MyMatrix : public MyAbstract {
using MatrixType = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>;
MatrixType A, B;
public:
...
MatrixType product() { return A * B; }
...
}
和
class MyDiagonal : public MyAbstract {
using Ve
浏览 0提问于2018-10-10得票数 0
2回答
我编写了这个有效的代码，这让我想知道它是否有一个名称：
public class GenericObject<T> {
public T Obj { get; set; }
}
public class DerivedClass: GenericObject<DerivedClass> { }
这导致了以下方面的能力：
var x = new DerivedClass();
x.Obj = x;
x.Obj.Obj = x;
x.Obj.Obj.Obj = x;
// ...
x.Obj.Obj.Obj.Obj.Obj.Obj.Obj.Obj.Obj.Obj..
浏览 0提问于2021-01-05得票数 5
回答已采纳
2回答
我有一些CRTP依赖，我不确定如何解决。理想情况下，我希望在基类中放入尽可能多的东西，比如函数，这样我就不必为继承这些函数的每个类重新定义这些函数。这似乎导致了初始化顺序的问题，在初始化顺序中，result_type依赖于尚未初始化的类型。下面是一个示例：
下面是代码：
template<typename T>
struct CRTP_Derived;
template<typename Derived>
struct CRTP
{
using result_type = typename Derived::result_type;
};
template
浏览 0提问于2019-10-17得票数 3
2回答
背景
最近，我一直在考虑如何设计一个特定的软件，我曾经制作了以下代码：
template <typename ... Mixins>
class Foo : public virtual Mixins... {
/* ... */
};
我的想法是能够根据用户的需要，使用附加的属性或行为来增强基本类。假设一个应用程序需要使用带有标识号的Foo。也许其他一些应用程序需要能够用颜色来讨论Foo。可以通过添加以下类来满足这些需求：
class HasID {
int m_id = -1;
public:
int getID() { return m_id; }
浏览 3提问于2016-07-27得票数 4
1回答
我没有几节课
class A;
class B;
class C;
class D;
类B，C，D继承自A。在我的问题中，我有多个类B，C，D，其中每个类都有一个静态字段。
static int gold;
类A是抽象类，它有方法getGold()；
当然，每个B，C，D类都有它自己的静态场。
static int gold;
在每个类(B，C，D)中，我都以相同的方式实现
getGold()
{
return gold;
}
它是复制和粘贴，但我不知道如何使它更好。
例如，B、C、D
B是图卢斯盒子
C是斧头
D是剑
相同类的每个对象的成本都是相同的，所以这就是为
浏览 2提问于2012-11-22得票数 2
回答已采纳
我在Java语言中有一个小的算法集合，用于玩多个基于回合的游戏，如TicTacToe，Othello，Checker等。我使用Java Generics (自界类型)来做这件事，以便能够使用相同的算法，而不必专门为每个游戏更改它们。我使用自绑定类型的原因没有在这里展示，但它是计算函数所必需的。
public interface Game<GAME extends Game<GAME>> {
GAME copy();
int getCurPlayer();
...
}
public class TicTacToe implements Game&
浏览 0提问于2011-12-15得票数 0
回答已采纳
2回答
我正在尝试使用Barton和Nackman技巧来实现类，以避免动态分派。(我正在编写性能非常重要的MCMC代码。)我不是C++专家，但基本的技巧在其他地方对我有效。然而，我现在遇到了第二个派生类需要模板化的情况。这似乎会带来问题。我的代码概要是：
// Generic step class
template<class DerivedStepType>
class Step {
public:
DerivedStepType& as_derived() {
return static_cast<DerivedStepType&>(*this)
浏览 1提问于2009-06-05得票数 4
我需要将克隆和创建成员函数插入到我的类中。
class Base
{
protected:
const int x_;
public:
Base() : x_(0) {}
Base(int x) : x_(x) {}
};
我认为CRTP可以是保存一些打字和避免错误的方法。
template <typename Derived>
class CRTP_Iface : public Base
{
public:
virtual Base *create() const { return new Derived(); }
virtual Base
浏览 0提问于2015-10-21得票数 3
回答已采纳
1回答
我有一个模板层次结构，我希望它具有clone()函数，这取决于模板类型是否是可复制的。作为第一步，我想从附加参数bool Clonable开始
template<class T, bool Clonable>
class Base {
T t;
void foo();
virtual void bar();
virtual unique_ptr<Base> clone() const = 0; //should be only for Clonable=true
};
template<class T, bool Clonable>
cla
浏览 3提问于2017-03-27得票数 2
回答已采纳
2回答
我有一个基类，它包含一个成员变量std::unique_ptr< Base > next。我有几个基本的派生类。
我有一个非虚拟函数库：：grow()，它初始化next。接下来，将始终指向调用grow对象类型的对象。
下一个类型是正确的，通过Base::grow()中的一个虚拟函数调用来保证。
为每个派生类创建一个虚拟函数既麻烦又容易出错，因此我的问题是:我能更简洁地这样做吗？
我当前的最小工作示例如下所示：
#include <iostream>
#include <memory>
class Base{
public:
static con
浏览 0提问于2015-05-04得票数 1
回答已采纳
1回答
这可能是不可能的，但是c++以前让我很惊讶，所以让我们开始吧。
我有这个基类和三个几乎相同的子类：
class MyBaseClass {
};
class MyClassX : public MyBaseClass {
public:
static MyClassX *create() { return new MyClassX(); }
};
class MyClassY : public MyBaseClass {
public:
static MyClassY *create() { return new MyClassY(); }
};
class MyClas
浏览 0提问于2013-03-26得票数 2
回答已采纳
我使用的是复合设计模式，我想从复合类中克隆我的对象。我试图在组件类中创建一个泛型克隆方法，但是当我试图将对象的具体类型发送到泛型(模板)方法时，‘type of’和‘type in’返回抽象类类型。所以，当我尝试使用新类型(对象)时，我看到了错误
“无效的新-抽象类类型‘组件’的表达式”。
我的编译器是MigGW 32位。
由于我不知道对象的类型，所以我不能使用dynamic_cast。
我是错误地使用了type or /type I，还是应该使用其他关键字来知道具体的对象类型？
#include <iostream>
#include <vector>
#in
浏览 3提问于2018-02-02得票数 2
回答已采纳
3回答
我有以下两个对象。我想知道是否有办法让Pixel作为PixelBGR的基类，以便任何运算符(+，-，*，/，[]等等)不用重新定义就可以使用吗？
template<class T, std::size_t N>
struct Pixel
{
T ch[N];
inline T& operator[](const int x)
{
return ch[x];
}
};
template<class T>
struct PixelBGR
{
union
{
struct
浏览 0提问于2019-04-01得票数 1
回答已采纳
下面是我所想要做的事情的“简单”例子。我有一个抽象类A，它通过两种方法向世界公开一个公共接口：operator==和performTasksSpecificToA。您可以看到，我使用的是“模板方法模式”和“奇怪的反复出现的模板模式”，以确保A的用户不需要担心A的实现，换句话说，AImpl，同时仍然能够根据AImpl的两个实例检查等式。有关此方法的更多信息和上下文，请参见。
现在，假设我希望定义一个类B如下：
class B
{
public:
virtual ~B() = 0;
bool operator(const B& b) con
浏览 2提问于2017-08-02得票数 0
2回答
下面的代码不能编译，我不知道原因：
#include <type_traits>
// Base class definition
template<template<typename> class CRTP, typename T> class Base
{
// Friend function declaration
public:
template<template<typename> class CRTP0, typename T0, class>
friend int fun
浏览 1提问于2012-08-19得票数 3
回答已采纳
3回答
在中，如果我们想让派生类中的实现函数保持受保护状态，我们就会遇到问题。我们必须将基类声明为派生类的朋友，或者使用 (我还没有在链接的文章上尝试过该方法)。有没有其他(简单的)方法可以让派生类中的实现函数保持受保护？
编辑:下面是一个简单的代码示例：
template<class D>
class C {
public:
void base_foo()
{
static_cast<D*>(this)->foo();
}
};
class D: public C<D> {
protected: //ERROR
浏览 0提问于2011-12-16得票数 33
1回答
我有以下课程：
class A {
public:
virtual std::string Serialize();
virtual void Deserialize(std::string);
template <typename T>
T* Clone()
{
std::string s = Serialize();
T* t = new T();
t->Deserialize(s);
return t;
}
};
class B : public A {
public:
std::string Serial
浏览 4提问于2017-05-09得票数 14
回答已采纳
当我尝试用Clang编译这段代码时
template<class T>
struct Field
{
char const *name;
Field(char const *name) : name(name) { }
};
template<class Derived>
class CRTP { static Field<Derived> const _field; };
class Class : public CRTP<Class> { };
Field<Class> const CRTP<Clas
浏览 0提问于2013-03-31得票数 10
回答已采纳
的能力是否足以完全胜过virtual功能？
我看到CRTP的唯一缺点是为每个重复出现的模式生成大量的代码。对于较小的设计(其中2-3个类是从基础派生的)，CRTP是更好的主意吗？
浏览 1提问于2011-07-08得票数 2
回答已采纳
给定下面的类结构，我想从struct C<O>中的方法调用struct B中的方法。C<O>遵循奇怪的循环模板模式。我想在不将方法放置在struct O中的情况下这样做。在struct O中放置方法将违背struct C<>的目的。我怀疑这是不可能的，但我想我会问。
编辑： struct O可以是以struct B和struct C<O>作为基类的一组类型之一。
struct B
{
virtual void foo ()
{
// dynamic_cast this to C<O>* and call
浏览 2提问于2017-12-11得票数 1
根据cp首选项，使用奇怪的递归模板模式(CRTP)定义视图的助手类模板。
他们背后的设计理念是什么？与重写派生类中的虚拟基类方法相比，是否有显著的优势？
浏览 3提问于2021-02-08得票数 2
回答已采纳
我有两个类使用了一个父类奇怪地重复出现的模板模式。
当我在VS2013上编译时，我得到两个错误，每个子类一个，声明：
'Parent<Child1>::_child' uses undefined struct 'Child1'
'Parent<Child2>::_child' uses undefined struct 'Child2'
我是否不正确地包含文件，还是需要进行某种转发声明？
Child1.h
#include "Parent.h"
struct Child1 : publi
浏览 2提问于2020-07-10得票数 0
回答已采纳
1回答
我正在编写C++类的层次结构，比如A、B继承A、C继承A和D继承B。
现在，所有这些类都必须有一个方法bar() &，其主体是：
{
A::foo();
return *this;
}
它是完全相同的代码，执行完全相同的操作--除了返回值的类型--返回对类类型的lvalue引用。
现在，这个方法的签名对于每个类都是不同的。但是-本质上是相同的方法。问题是，就目前的情况而言，我需要多次复制代码。如何避免这种代码重复？
我正在考虑用CRTP写一些混音，但当我深入到细节时，它变得超级丑陋。
注意:为了本例的目的，只为rvalue定义了bar()，以避免涉及从rvalue返回*
浏览 8提问于2022-10-05得票数 0
回答已采纳
3回答
类层次虚拟方法的CRTP参数
、、、、
我试图将CRTP类型参数传递给虚拟方法。因此，虚拟方法需要是一个模板。但是，C++还不允许这样做，因为这意味着vtable的大小--编译器实现动态分派的常见方式--在编译和链接所有源之前都是未知的。(.)
然而，在我的特定环境中，有一个有限的和已知的数量的CRTP专门化。因此，可以在每个专门化中定义一个虚拟方法重载，并在子类中覆盖这些重载。我准备了一个小的MWE来演示我的情况。考虑以下CRTP层次结构：
template<typename Actual>
struct CRTPBase
{
using actual_type = Actual;
void foo()
浏览 18提问于2021-12-07得票数 1
3回答
在实现奇怪的递归模板模式(CRTP)时，析构函数是否需要是虚拟的？如果不是，什么是正确的非虚拟实现？
我将提供一个例子，希望能让事情变得更容易：
template<typename T>
class Base
{
public:
virtual ~Base()
{
// Should this be virtual? Non-virtual?
std::cout << "Base::~Base()\n";
}
};
class Derived : public Base<Derived>
浏览 5提问于2017-08-18得票数 4
回答已采纳
2回答
我第一次看到一个同事这样做是在他实现对象池的时候。他将将要池化的类作为参数传递给一个泛型基类。这个基类布置了池化代码。
奇怪的是基类会知道它的子类。这在任何正常情况下都被认为是不好的做法。但在这种情况下，父对象只是一种避免编写重复代码的技术解决方案。基类永远不会被任何其他代码引用。
这种结构的一个缺点是它“烧掉了基类”。不能在层次结构的中间引入泛型基类。这个问题可能超出了主题范围。
下面是一个可以想象的例子：
public abstract class Singleton<T> where T : class
{
public static T Instance { get
浏览 1提问于2013-10-08得票数 16
2回答
CRTP编译错误
、、、、
下面的代码将用GCC 5.2编译，而不是用Visual 2015编译。
template <typename Derived>
struct CRTP {
static constexpr int num = Derived::value + 1;
};
struct A : CRTP<A> {
static constexpr int value = 5;
};
它抱怨A没有一个名为value的成员。如何修复代码，使其在两个编译器上编译？还是完全不合法？
浏览 3提问于2016-03-02得票数 4
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
