C++ How do I instantiate a VkSubProcess object from this header? - c++

Question

I'm having a hard time understanding how to instantiate a ViewKit VkSubProcess object. Manpage for this thing is here: VkSubProcess.3
I have read up enough about C++ to understand that this header describes a reference counted abstract base class and I think I more-or-less understand the concepts involved. However, my feeble attempts at actually using this thing have been unsuccessful.
My efforts lead to various compiler errors like:
"The class "RPtr_VkSubProcessRep" has no member "create"
or:
"No instance of constructor 'VkSubProcessRep::VkSubProcessRep' matches the argument list"
Could somebody be kind enough to please show how to instantiate a VkSubProcess object from this header?
For brevity I've removed from the header the functions mentioned in the manpage that come into play only after the instance has been created.
Many thanks.
#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

Well, after spending the day reading up on C++, I now know that this header describes a Reference-counted Singleton pattern. From what I have read, the static 'create()' function and the protected constructor seem to be typical for this pattern.
You might use it like so:
VkSubProcess process = VkSubProcessRep::create("ls -al", 1, 1);
process->run();