使用enable_if方法枚举类 我正在玩C++，尝试模板、枚举类等等。在我的涉猎中，我遇到了一个问题，我不确定是否有一个好的方法来解决它。我有两种不同类型的“记忆”：mem1和mem2。这两种方法都有关于如何访问它们的特殊策略，但方法相同：创建、读取和写入。现在，根据内存的访问类型，我希望编译器在访问类型为只读且调用write（）时给我一个错误。以下是我目前掌握的情况： enum class mem1_access_type : int { write = 0, read = 1, rw = 2 }; enum class mem2_access_type : int { write = 3, read = 4, rw = 5 }; struct mem1_access { mem1_access() : m(mem1_access_type::rw), p(0); mem1_access(mem1_access_type _m) : m(_m), p(0); mem1_access_type getAccess(){ return m; }; int getP(){ return p; }; private: mem1_access_type m; int p; }; struct mem2_access { mem2_access() : m(mem2_access_type::rw), p(0); mem2_access(mem2_access_type _m) : m(_m), p(0); mem2_access_type getAccess(){ return m; }; int getP(){ return p; }; private: mem2_access_type m; int p; }; template <typename Access> struct base_policy { Access a; base_policy(Access _a) : a(_a) {}; void create(); //HERE void write(); //AND HERE void read(); }; struct mem1_policy : base_policy<mem1_access> { mem1_policy(mem1_access _a) : base_policy<mem1_access>(_a) {}; }; struct mem2_policy : base_policy<mem2_access> { mem2_policy(mem2_access _a) : base_policy<mem2_access>(_a) {}; }; enum类mem1\u访问类型：int{write=0，read=1，rw=2}； 枚举类mem2\u访问类型：int{write=3，read=4，rw=5}； 结构mem1\u访问 { mem1_access（）：m（mem1_access_type:：rw），p（0）； mem1_访问（mem1_访问类型m）：m（_m），p（0）； mem1_access_type getAccess（）{return m；}； int getP（）{return p；}； 私人： mem1\u访问\u类型m； INTP； }; 结构mem2\u访问 { mem2_access（）：m（mem2_access_type:：rw），p（0）； mem2_访问（mem2_访问类型m）：m（_m），p（0）； mem2_access_type getAccess（）{return m；}； int getP（）{return p；}； 私人： mem2\u访问\u类型m； INTP； }; 样板 结构基策略 { 访问a； 基本策略（访问）：a（{a}； void create（）； //这里 无效写入（）； //这里呢 无效读取（）； }; 结构成员1_策略：基本_策略 { mem1_策略（mem1_访问_a）：基本策略（_a）{}； }; 结构成员2_策略：基本_策略 { mem2_策略（mem2_访问_a）：基本策略（_a）{}； };

我正在考虑将std:：enable_if用于检查所提供访问的访问类型的写和读方法。但我就是想不出该怎么办。根据提供的访问类型，只能用于编译方法的内容

编辑：

---

谢谢狗琼斯的回答！这正是我想要的

当您尝试使用std:：enable_if时，具体遇到了什么问题

编辑：

为了确定基本_策略类是否应在编译时（使用模板）定义创建/写入/读取，mem1_访问和mem2_访问的访问类型必须是编译时常量：

template <mem1_access_type accessType> struct mem1_access
{
    // These typedefs will help 'store' the read/write access information for later:
    typedef mem1_access_type AccessType;
    typedef std::integral_constant<mem1_access_type, accessType> AccessValue;

    mem1_access() : p(0) {}

    mem1_access_type getAccess(){ return m; };
    int getP(){ return p; };

        static const mem1_access_type m = accessType;
    private:
        int p;
};

template <mem2_access_type accessType> struct mem2_access
{
    typedef mem2_access_type AccessType;
    typedef std::integral_constant<mem2_access_type, accessType> AccessValue;
    mem2_access() : p(0) {}

    mem2_access_type getAccess(){ return m; };
    int getP(){ return p; };

        static const mem2_access_type m = accessType;
    private:
        int p;
};

template struct mem1\u访问
{
//这些typedef将有助于“存储”读/写访问信息，以便以后使用：
typedef mem1_access_type AccessType；
typedef std：：整数值；
mem1_access（）：p（0）{}
mem1_access_type getAccess（）{return m；}；
int getP（）{return p；}；
静态常量mem1\u access\u type m=accessType；
私人：
INTP；
};
模板结构mem2\u访问
{
typedef mem2_access_type AccessType；
typedef std：：整数值；
mem2_access（）：p（0）{}
mem2_access_type getAccess（）{return m；}；
int getP（）{return p；}；
静态常量mem2\u access\u type m=accessType；
私人：
INTP；
};

请注意，您不能再在构造函数中设置访问类型。它现在是一个模板参数，一个编译时常量。你愿意做这个交易吗

稍后，在base_策略中，您可以指定默认模板参数，然后专门化这些参数：

// Be default, this class can write():
template <typename Access, bool shouldWrite=Access::AccessType::write == Access::m || Access::AccessType::rw == Access::m>
struct base_policy
{
    Access a;
    base_policy(Access _a) : a(_a) {};

    void create();
    //HERE
    void  write();
   //AND HERE
    void read();
};

// This class can't write():
template <typename Access>
struct base_policy<Access, false>
{
    Access a;
    base_policy(Access _a) : a(_a) {};

    void create();
    //HERE
    //AND HERE
    void read();
};

//默认情况下，此类可以写入（）
样板
结构基策略
{
访问a；
基本策略（访问）：a（{a}；
void create（）；
//这里
无效写入（）；
//这里呢
无效读取（）；
};
//此类无法写入（）
样板
结构基策略
{
访问a；
基本策略（访问）：a（{a}；
void create（）；
//这里
//这里呢
无效读取（）；
};

或者使用std:：enable_if，我认为应该是这样的（在base_策略的主体中）：

std:：enable_if:：type write（）；

我真的很喜欢这个！我只是不知道这对我的想法是否有效。因为mem1和mem2具有读、写和rw访问权限。因此，mem1仍然需要一个write方法，以防策略具有写访问权限。这就是为什么我在想enable_if write（）。对不起，如果我弄糊涂了：/对不起，我没有注意到你的首要问题。我收到一个错误，上面写着“错误：模板类型参数的模板参数必须是一个类型”，所以我假设这是因为访问类型是枚举类。我想我现在明白你想要什么了。这是您的基本问题：如果希望在编译时基于访问类型从基本策略定义中包括或排除创建/写入/读取函数定义，那么访问类型必须是编译时常量。目前，在mem1_访问和mem2_访问结构中，m（访问类型）不是常数。我会更新我的答案，让你知道我的意思。

std::enable_if<Access::AccessType::write == Access::m || Access::AccessType::rw == Access::m, void>::type  write();