Pure abstract classes and instantiation of derived types

Question

I want to improve compile times in a large C++ code base littered with cyclic dependencies. I've decided to go with using mainly pure abstract interfaces to reduce cyclic dependencies and thereby be able to split the project into smaller modules.

ibar.h:

struct IBar {
  IBar();
  virtual ~IBar();
  virtual void foo() = 0;
}

std::unique_ptr<IBar> createIBar();

bar.cpp:

#include "ibar.h"

class Bar : IBar {
  Bar();
  virtual ~Bar();
  virtual void foo() {<do stuff>;}  
}

Now my createIBar function needs to be defined somewhere. If I define it in bar.cpp, anyone using using ibar.h needs to link in bar.o which is what I'm trying to avoid. So I need some sort of factory which can work for clients only using this interface.

In our code base we are already employing a pattern where we create run-time initializers which instantiate derived classes to fulfill the duties of an interface. This is done by the build system identifying initializer functions based on a fixed pattern, and these are "linked" into the main application via extern int definitions so all instantiations are run when the application starts.

I could use this pattern to create a factory that creates Bars for clients only knowing about IBar, but I don't like it because it imposes extra duties on the build system which I'm trying to improve in the first place. Second, I would like to employ lazy loading dlls at a later stage and this pattern effectively kills that. Third, since this will be done with quite a lot of components, the list of factories and initializer calls would grow quite large after a while.

What other techniques exist that can take care of this use case?

This may be of interest to you http://stackoverflow.com/questions/23626803/can-a-factory-somehow-determine-all-possible-classes-by-looking-in-a-particular/23626894#23626894 — StoryTeller - Unslander Monica, Dec 13 '16 at 10:03

score 0 · Answer 1 · answered Dec 21 '16 at 07:37

(Answering myself) The abstract factory pattern creates derived objects with base handles and I've concluded it is the best complement to the interface/implementation separation work I'm doing.

The crtp pattern as suggested by StoryTeller can also play a part if you accept a link time dependency to Bar everywhere you need to create a Bar. Crtp helps with static polymorphism, so that calls to a static createIBar function can be relayed to a static createBar function, which is not possible with regular polymorphism. I was not able to avoid the link time dependency using this pattern though.

Pure abstract classes and instantiation of derived types

1 Answers1