如何为每个派生类存储一个幻数，然后可以从基类访问该幻数？

Question

class User {
    public:
        int v() {
            return min_pass_len;
        }
        static const int min_pass_len = 10;
};
class AdminUser : public User {
    public:
        int w() {
            return min_pass_len;
    }

    static const int min_pass_len = 42;
};

那么

int main() {
    AdminUser a;
    std::cout << a.v()  << " why? " << a.w() <<  std::endl;
    return 0;
}

我可以以某种方式避免额外的方法调用吗？我也对其他解决方案、最佳实践感兴趣。谢谢！

Answer 1

只需使用返回不同数字的虚拟方法，跳过静态变量。

class User {
    public:
        virtual int v() {
            return 10;
        }
};

class AdminUser : public User {
    public:
        virtual int v() {
            return 42;
    }    
};

Answer 2

如果你想为不同的派生类使用不同的常量，你应该像这样模板化基类：

template<class T>
class User 
{
    // Make the password len getter virtual.
    virtual GetPassLen() { return min_pass_len; }
    ...
    static const int min_pass_len = 10;
}

class AdminUser : public User<AdminUser>
{
}

// All admin users get this constant
AdminUser::min_pass_len = 42;

class GuestUser : public User<GuestUser>
{
}

// Guest user can have a different constant than Admin user.
Guestuser::min_pass_len = 0;

Answer 3

您缺少 virtual 关键字。在 C++ 中，方法默认情况下不是虚拟的，就像在其他一些编程语言（例如 Java）中那样。请尝试以下操作：

#include <iostream>

class User {
    static const int min_pass_len = 10;
public:
    virtual ~User() {}
    virtual int getPasswordLength() const {
        return min_pass_len;
    }
};

class AdminUser: public User {
    static const int min_pass_len = 42;
public:
    virtual ~AdminUser() {}
    virtual int getPasswordLength() const {
        return min_pass_len;
    }
};

int
main()
{
    AdminUser a;
    User u, *p = &a;
    std::cout
        << u.getPasswordLength() << "\n"
        << a.getPasswordLength() << "\n"
        << p->getPasswordLength() << "\n"
        << std::endl;
    return 0;
}

如果您想完全摆脱该方法，请使用 Sanjit 提到的“奇怪地重复出现的模板模式” 或将常量而不是将其嵌入到类中。我正在考虑类似于 std::numeric_limits 的实现方式：

template <typename T>
struct UserTraits {
    static const int minimum_password_length = 0;
};

template<> struct UserTraits<User> {
    static const int minimum_password_length = 10;
};
template<> struct UserTraits<AdminUser> {
    static const int minimum_password_length = 10;
};

int main() {
    std::cout
        << UserTraits<User>::minimum_password_length << "\n"
        << UserTraits<AdminUser>::minimum_password_length << "\n"
        << std::endl;
    return 0;
}

我通常更喜欢第一种方法，因为当您有指向实例的指针时它会起作用。后一种方法几乎没有那么有用，因为您无法使用它从实例中提取常量而不求助于编写自由函数，即使这样您也失去了动态类型方面。

template <typename T>
int getPasswordLength(T*) {
    return UserTraits<T>::minimum_password_length;
}
template <typename T>
int getPasswordLength(T&) {
    return UserTraits<T>::minimum_password_length;
}

这种方法的问题在于，如果您在第一个代码段中使用 p 调用 getPasswordLength(p)，则会得到错误的结果。

Answer 4

最佳实践建议使用virtual函数（这就是引入它们的原因，以使旧代码能够调用新代码）：

class base{
public:  virtual int get_magic(){return 10;};
};

class der1: public base{
public:  virtual int get_magic(){return 42;};
};

Howerer，一个在基类中定义的简单变量类，但在每个派生构造函数中重写会更快，并且会消除任何调用（因为它将被内联）：

class base{
protected:  int magic; // note that it's not static!
public:
    base(){magic = 10;};
    int get_magic(){return magic;};
};

class der1: public base{
public:
    der1(){magic = 42;};
};