Question

我正在尝试使用C ++，并且正在尝试模板，枚举类等。在我的涉猎中，我遇到了一个问题，我不确定解决问题的好方法。我有两种不同类型的＆＃34;内存＆＃34;：mem1和mem2。这两个方面都有关于如何访问它们的特殊政策，但使用相同的方法：创建，阅读和＆amp;写。现在，根据内存的访问类型，我希望编译器给出一个错误，例如，访问类型是只读的，它的调用是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) {};
};

我正在考虑将std :: enable_if用于检查所提供访问的访问类型的write和read方法。但我无法想到如何解决这个问题。根据提供的access_type，只能用于编译方法。

编辑：

谢谢狗狗琼斯的回答！它完全符合我的要求！

Answer 1

特别是当您尝试使用std :: enable_if？

时遇到的问题

编辑：

为了确定base_policy类是否应该在编译时定义create / write / read（使用模板），mem1_access和mem2_access的访问类型必须是编译时常量：

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;
};

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

稍后，在base_policy中，您可以指定默认模板参数，然后对其进行专门化：

// 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();
};

或者使用std :: enable_if，我认为应该看起来像这样（在base_policy的主体中）：

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

带有enable_if方法的枚举类

1 个答案: