考虑以下类别:

//! Counter class base. Must be inherited.
class base_seeded_counter
{
public:
    //! Destructor
    virtual ~base_seeded_counter() { };

    //! Get the next value.
    int get_next();

protected:
    //! Override the counter next value.
    void set_next(const int next);

private:
    int m_next_value;    // Next value.
}

// ------------------------------------------------------

inline int base_seeded_counter::get_next()
{
    return m_next_value++;
}

// ------------------------------------------------------

inline void base_seeded_counter::set_next(const int next)
{
    m_next_value = next;
}

此类的目的是为了实现必须要继承的基础计数器对象。除析构函数外,它没有任何虚拟方法,更重要的是,它不初始化m_next_value成员。这是派生类的工作。例如:
class file_seeded_counter : public base_seeded_counter
{
public:
    file_seeded_counter(const std::string &file_name);

    void reseed();

private:
    std::string m_file_name;
}

inline int file_seeded_counter::file_seeded_counter(const std::string &file_name) :
    m_file_name(file_name)
{
    reseed();
}

inline void file_seeded_counter::reseed()
{
    int seed_from_file;

    // open file here and get seed value...

    set_next(seed_from_file);
}

从base_seeded_counter派生的此类从文件读取初始计数器值,并提供了通过reseed()方法从文件重新读取种子的功能。例如,可能会有其他类提供类似的功能来从数据库,网络源或PRNG进行种子。

我的问题是:鉴于我没有纯粹的虚方法,C++是否提供一种机制来防止某人创建base_seeded_counter实例?

最佳答案

假设您已经具有虚拟析构函数,则显而易见的方法是将其声明为纯虚函数。具有在基类中也定义的纯虚拟析构函数是完全合法的:

class base_seeded_counter {
public:
    virtual ~base_seeded_counter() = 0;
    int get_next();
protected:
    void set_next(const int next);
private:
    int m_next_value;
}

inline virtual base_seeded_counter::~base_seeded_counter() {}

以这种方式定义析构函数不会改变它是纯虚拟的事实,因此无法实例化此类。

顺便说一句,您当前在代码中的注释是100%无用的视觉噪声。在名为get next的函数上对get_next进行注释不会增加任何用处。

07-24 09:46
查看更多