Question

I’ve got a library written in C++ that provides a Virtual Machine (“VM”) of a graphical programming language. It uses an image (e.g. png file) as its source code and executes instructions. The VM is used in different types of applications (console, gui) so the aim for the lib is to be as flexible as it can be.

The question is: what should be the relation between the VM and the image object? Should it be aggregation (VM constructor takes existing Image instance as a parameter) or composition (VM constructor takes image file path as string parameter)?

Composition is where the outside (VM) object cannot exist without the inside object (image). Well, in this case a VM can exist, but it’s useless without any image (can’t perform no instructions if there is no code). So it should take the string parameter and create and destroy the image object on its own. But how about validating the string filepath (check if there’s no image there OR the file is not an image OR the image binary is corrupted) – where should this validation be implemented? The VM constructor, I guess?

On the second hand, if the VM could replace one image with another, it could be aggregation (more like Java Virtual Machine). But I’m not sure if it’s a good approach – VM would have to reset all image pointers and data stack bound to the image. Maybe one VM per one image is a cleaner and more logical solution.

Would you choose aggregation or composition in this case? Thanks for your answers.

Answer 1

Here’s steps to decide between aggregation and composition:

1. If you cannot handle several objects with dependencies, use composition.
2. If you can handle several objects, decision should be based on whether your image is inside or outside of VM object. If you consider it inside VM, use composition. If you consider it outside of it, use aggregation.

Note that handling several objects (with aggregation) is quite difficult. Usually requires something like:

struct Env {
   std::vector<I*> v1;
   std::vector<I2*> v2;
};
int push_image() { v1.push_back(new Image); return v1.size()-1; }
int push_vm(int image_id) 
    { v2.push_back(new VM(v1[image_id])); return v2.size()-1; }