父类可以调用其子类版本的函数

Question

我有一个基类 MyScreen &我希望始终在其构造函数内调用函数 initComponents() ，即使对于此类的子类也是如此。但是，如果子类重写了 initComponents() 函数，那么我希望 MyClass 调用 initComponents() 的 子类 版本，而不是 initComponents() 的超类(MyScreen) 版本。

是否可以在 MyClasses 构造函数中执行此操作？

class MyScreen
{
  public:
     MyScreen()
     {
        // a child of this class (& any instance of this class) should always call the initComponents() from this constructor
        initComponents(); 
     } 

     void initComponents()
     {
         // initialise mainLayout, etc, usually this function wont be overridden, sometimes it will be
     }

  protected:
      Layout *mainLayout;
};

class MenuScreen : public MyScreen
{
  public:
     MenuScreen : public MyScreen()
     {
        // I know I could just call initComponents from here, but this is just an example, somethings must be called from the base class
     } 

     void initComponents()
     {
         // create layout, set main layout etc.
         mainLayout = new MenuLayout(...);
     }
};

Answer 1

你不应该（或者甚至不能）这样做。问题是，当构造派生类的对象时，基类构造函数总是在派生类的构造函数之前调用。这意味着派生对象尚未创建，因此其成员不会被初始化（这可能对 v 表也有效，因此虚拟函数调用将不起作用）。检查 这篇文章

相反，您应该由类的用户显式调用 initComponents 并标记它虚拟的

Answer 2

不，你不能这样做。对象的动态类型始终是 MyScreen 构造函数内的 MyScreen。您无法从其中调用 MenuScreen 函数。

Answer 3

通过使用内部类可以通过调用虚函数来填充资源。这是一个示例

#ifndef CLAZYSTATICRESOURCINITIALIZATIONASPECT_H
#define CLAZYSTATICRESOURCINITIALIZATIONASPECT_H

#include <boost/thread/mutex.hpp>

template <typename R>
class CLazyStaticResourceInitialization
{
public:

    /**
     * Destructor
     */
    virtual ~CLazyStaticResourceInitialization()
    {
    }

protected:

    /**
     * Internal class used for calling  virtual function from constructor
     */
    struct parent_virtual
    {
        /**
         * Virtual destructor
         */
        virtual ~parent_virtual ()
        {
        }
        /**
         * Virtual method implemented by parent class is necessary
         */
        virtual void initializeOnce () const
        {
        }
    };

    /**
     * Constructor that can call a virtual function of the parent 
     * @param obj specifies the virtual function
     */
    CLazyStaticResourceInitialization(const parent_virtual& obj )
    {
        boost::mutex::scoped_lock scoped_lock(m_Mutex);

        //Initialize the resource only once
        if (isInitialized () == false)
        {
            obj.initializeOnce ();

            setInitialized ();
        }
    }

    /**
     * Returns if any instance of this class has been initialized or not 
     * @return true if initialized, false otherwise
     */
    bool isInitialized () const
    {
        return m_bInitialized;;
    }

    /**
     * Returns if any instance of this class has been initialized or not 
     */
    void setInitialized ()
    {
        m_bInitialized = true;
    }

protected:

    /**
     * The flag that indicates whether this class is initialized or not
     */
    static volatile bool    m_bInitialized;

    /**
     * The resource instance
     */
    static R        m_Resource;

    /** 
     * The mutex to protect initialized flag
     */
    static boost::mutex     m_Mutex;


};

//Assume that this  class is not initialized in the beginning
template <typename R> volatile bool CLazyStaticResourceInitialization<R>::m_bInitialized    = false;

//Create a static instance of resource
template <typename R> R CLazyStaticResourceInitialization<R>::m_Resource;

//Create a static instance of mutex
template <typename R> boost::mutex CLazyStaticResourceInitialization<R>::m_Mutex;


#endif

，以下是如何使用它

class CTestLazyInitialized : public CLazyStaticResourceInitialization <std::vector<int> >
{
public:
    CTestLazyInitialized():
    CLazyStaticResourceInitialization<std::vector<int> >(lazyderived_virtual())
    {
    }

    unsigned int size ()
    {
        return this->m_Resource.size ();
    }
protected:

    struct lazyderived_virtual : public CLazyStaticResourceInitialization <std::vector<int> >::parent_virtual
    {

        lazyderived_virtual ()
        {
        }

        void initializeOnce () const
        {
            m_Resource.push_back (1);
        }

    };
};

只需注意基类和派生类中使用的内部类。对于您的情况，可以忽略互斥锁定和模板内容。