C++: Interface enforcing definition of copy-constr - c++

Question

Is there any way for an interface class to enforce a definition of the copy constructor and maybe of also other constructors? In my case, I have an IResource pure abstract class, and I want all classes that implement this interface to define a copy-constr, a constructor for loading from a file, and a constructor for loading from memory.

Answer 1

In order to construct an object, you need to know the concrete class to use (how would it otherwise know how much memory to allocate, or which virtual table to use, etc..?). As such, the interface is not in play when dealing with constructors, and you can't use interfaces (pure virtuals) to enforce the existence of such a constructor. It's kind of natural when you think about it, virtuals only work when you have a polymorphic object, i.e. after instantiation. Anyone referencing your IResource interface would only ever deal with instantiated objects, and never touch a constructor.
You can enforce these kind of constraints on stuff using templates if you want though. By simply calling the copy constructor from a templated function, the compiler will complain if it encounters a template instantiation using a type which does not have a copy constructor.

Answer 2

You cannot enforce that and it would not be a right way either. On the contrary, you should prevent the usage of public copy constructors in a polymorphic class hierarchy...
struct IResource {
virtual IResource* Clone() const = 0;
virtual ~IResource() {}
};
An implementer of IResource should follow this pattern:
class ConcreteResource : public IResource, public boost::noncopyable { // or equivalent
public:
virtual ConcreteResource* Clone() const;
explicit ConcreteResource(std::string const & pString) : mString(pString) {}
private:
std::string mString;
};
ConcreteResource* ConcreteResource::Clone() const {
return new ConcreteResource(this->mString);
}

Answer 3

Something in your project uses the IResource abstract class and somehow I doubt that it requires that the objects it uses contain particular constructors.
Something else creates IResource objects (possibly lots of things) and to do that it must use a constructor. The concrete classes that get created must implement the necessary constructors or the code will not compile.
So the answer to your question is that you enforce the presence of the constructors by using those constructors in some other code to create objects. Keep in mind, if the constructors aren't being used anywhere, they aren't necessary.

Answer 4

you can push all requirements to the resource implementations like so:
class t_resource_interface {
protected:
virtual ~t_resource_interface();
public:
virtual t_serialization* serializeResource() = 0;
virtual t_thing* cloneResource() = 0;
};
/* type disambiguators */
typedef enum t_load_from_url { LoadFromURL = 0 } t_load_from_url;
typedef enum t_load_from_memory { LoadFromMemory = 0 } t_load_from_memory;
typedef enum t_copy_constructor { CopyConstructor = 0 } t_copy_constructor;
template < typename TResourceImplementation >
class t_resource : public t_resource_interface {
public:
/* copy ctor should generally be avoided due to the expense. introduce a parameter for those cases where it's really needed and disable the standard copy ctor */
t_resource(const t_copy_constructor& copyCtor, const t_resource& other) : t_resource_interface(), d_implementation(TResourceImplementation::CopyConstructor(other.d_implementation)) {
MONUnusedParameter(copyCtor);
}
t_resource(const t_load_from_url& fromFile, const t_url& url) : t_resource_interface(), d_implementation(TResourceImplementation::LoadFromURL(url)) {
MONUnusedParameter(fromFile);
}
t_resource(const t_load_from_memory& fromMemory, const t_serialization& serialization) : t_resource_interface(), d_implementation(TResourceImplementation::LoadFromMemory(serialization)) {
MONUnusedParameter(fromMemory);
}
virtual ~t_resource() {
}
public:
/* t_resource_interface requirements. implementation forwarded to TResourceImplementation */
virtual t_serialization* serializeResource() {
return this->d_implementation->serializeResource();
}
virtual t_thing* cloneResource() {
return this->d_implementation->cloneResource();
}
private:
/* assuming you will end up needing dynamic allocation/polymorphism along the way... */
t_auto_pointer<TResourceImplementation> d_implementation;
private:
/* prohibited */
t_resource(const t_resource&);
t_resource& operator=(const t_resource&);
};
class t_image_resource_implementation : public t_resource_interface {
private:
static t_image_resource_implementation* ValidationCheck(const t_image_resource_implementation* const arg) {
assert(arg && "allocation or argument error");
if (0 == arg) {
return 0;
}
else if (0 == arg->isValid()) {
delete res;
return 0;
}
else {
return arg;
}
}
public:
static t_image_resource_implementation* CopyConstructor(const t_image_resource_implementation* const other) {
return ValidationCheck(new t_image_resource_implementation(other, ...));
}
static t_image_resource_implementation* LoadFromURL(const t_url& url) {
/* assuming t_image_at_url_resource_implementation exists */
return ValidationCheck(new t_image_at_url_resource_implementation(url, ...));
}
static t_image_resource_implementation* LoadFromMemory(const t_serialization& serialization) {
assert(serialization);
if (0 == serialization) {
return 0;
}
else {
return ValidationCheck(new t_image_resource_implementation(serialization, ...));
}
}
/* some physical ctors and the rest of the implementation... */
public:
/* t_resource_interface requirements */
virtual t_serialization* serializeResource() {
return this->createSerialization();
}
virtual t_thing* cloneResource() {
return this->clone();
}
};
typedef t_resource<t_image_resource_implementation> t_image_resource;
t_error_code ConvertImageToGrayscale(const t_url& sourceUrl, const t_url& destinationUrl) {
t_image_resource imageResource(LoadFromURL, sourceUrl);
/* ... */
}