C ++如何从此标头实例化VkSubProcess对象？

Question

我很难理解如何实例化ViewKit VkSubProcess对象。 这个东西的手册页在这里： VkSubProcess.3

我已经对C ++进行了足够的了解，以了解该头文件描述了一个引用计数的抽象基类，并且我认为我或多或少都了解所涉及的概念。 但是，我在实际使用此东西方面的​​微薄尝试均未成功。

我的努力导致了各种编译器错误，例如：

“类“ RPtr_VkSubProcessRep”没有成员“创建”

要么：

“没有构造函数'VkSubProcessRep :: VkSubProcessRep'的实例与参数列表匹配”

有人可以请我演示如何从此标头实例化VkSubProcess对象吗？

为简洁起见，我从标题中删除了手册页中提到的仅在创建实例后才起作用的功能。

非常感谢。

#ifndef _VKPROCESS_H
#define _VKPROCESS_H

#include <signal.h>
#include <Xm/Xm.h>
#include <Vk/VkCallbackObject.h>
#include <Vk/VkBase.h>
#include <Vk/VkApp.h>

class VkSPCounted : public VkCallbackObject {

    friend class VkSPRPtr_base;

    int nreferences;
    void addRef() { nreferences++; }
    void delRef() {
            if (--nreferences <= 0)
              delete this;
    }

    public:
        VkSPCounted() : VkCallbackObject() { nreferences = 0; }
        virtual ~VkSPCounted();

    private:
        VkSPCounted(const VkSPCounted&);
        VkSPCounted &operator= (const VkSPCounted&);
};

class VkSPRPtr_base : public VkBase {

    public:
        operator void*() { return (void *)ptr; }
        VkSPRPtr_base& operator=(VkSPCounted *tp) { 
            if (ptr) ptr->delRef();
            ptr = tp;
            if (ptr) ptr->addRef();
            return *this; 
        }
        VkSPRPtr_base& operator=(const VkSPRPtr_base& r){ 
            if (ptr) ptr->delRef();
            ptr = r.ptr;
            if (ptr) ptr->addRef();
            return *this; 
        }

    protected:
        VkSPCounted *ptr;
        VkSPRPtr_base() : VkBase() { ptr = 0; }
        VkSPRPtr_base(const VkSPRPtr_base& r) : VkBase() {
            ptr = r.ptr;
            if (ptr) ptr->addRef();
        }
        VkSPRPtr_base(VkSPCounted *tp) : VkBase() { 
            ptr = tp;
            if (ptr) ptr->addRef();
        } 
        ~VkSPRPtr_base() { 
            if (ptr) ptr->delRef(); 
        }
};

class VkSubProcessRep;

class RPtr_VkSubProcessRep : public VkSPRPtr_base {

    public: 
        RPtr_VkSubProcessRep(); 
        RPtr_VkSubProcessRep(VkSubProcessRep *tp);  
        RPtr_VkSubProcessRep(const RPtr_VkSubProcessRep& that) : VkSPRPtr_base(that) {} 
        ~RPtr_VkSubProcessRep();    
        RPtr_VkSubProcessRep& operator=(VkSubProcessRep *tp) { 
            *((VkSPRPtr_base *) this) = (VkSPCounted *) tp;     
            return *this; 
        }       
        VkSubProcessRep& operator *();  
        VkSubProcessRep *operator->();  
        int operator !(){ return !ptr; }    
};

typedef RPtr_VkSubProcessRep VkSubProcess;

class VkSubProcessRep : public VkSPCounted {

    public:
        static  VkSubProcess create(char* cmd,
                                    int killChildOnExit,
                                    int redirectIn);

        /* Actually create VkSubProcess */
        void     run();

    protected:
        VkSubProcessRep(const char* prog,
                        char **argv,
                        int killChildOnExit,
                        int redirectIn);

        ~VkSubProcessRep();

    private:
        VkSubProcessRep(const VkSubProcessRep&);
        VkSubProcessRep &operator= (const VkSubProcessRep&);
};

#endif

Answer 1

好了，花了一天的时间阅读C ++之后，我现在知道该标头描述了一个引用计数的Singleton模式。 从我所读的内容来看，静态“ create（）”函数和受保护的构造函数似乎是此模式的典型代表。

您可以这样使用它：

VkSubProcess process = VkSubProcessRep::create("ls -al", 1, 1);
process->run();