如何给结构一个“虚拟” typedef？

Question

I have a struct BaseStorage that stores various run-time data, and a struct BaseStatic that holds a BaseStorage (or derived) typedef and "static" data that doesn't get changed and is read from multiple instances of a struct Holder . Holder has a pointer to one of each, a const BaseStatic* to access that read-only, shared data and a BaseStorage* as its personal info store. The "static" data in BaseStatic is still populated at run-time (read from a file); it is not constant!

The idea here is that BaseStatic has a certain set of read-only data and functions that will be shared 1:N among many Holder instances. Each Holder will also have run-time info specific to its instance that needs to match the BaseStatic derived type. So that's what BaseStorage derived stuff does, it holds the specific run-time info that a BaseStatic type will need. Holder itself also stores data and has functions that are the same among all Holder s; it isn't an inert container.

So I need a derived BaseStorage paired with each derived BaseStatic . There will be many of these derived pairs.

struct BaseStorage
{
 int something[2];
};

struct BaseStatic
{
 typedef BaseStorage Storage;

 //members and stuff
};


struct DerivedStorage : public BaseStorage
{
 std::string somethingelse;
};

struct DerivedStatic : public BaseStatic
{
 typedef DerivedStorage Storage;

 //other things
};


struct Holder
{
 const BaseStatic* base;
 BaseStorage* storage;
};

I have a builder function that does some stuff, among them populating storage. The only way I can think of doing it is with templates, like so:

template<typename T> Holder& builder(const T* base) //receives a BaseStatic
{
 Holder& holder = ...;

 //add to a list, etc

 holder.base = base;
 holder.storage = new T::Base();
}

However, that is going to result in a lot of templated functions getting made by the compiler for a very trivial thing (accessing a single type!). Further I can never have params for my T::Base constructor (unless all structs have the same ones!). I'm sure this is terrible in other ways too.

Is there any way to store a type that can be accessed virtually from BaseStatic without using templates? There's gotta be a better way.

There are various constraints that have led me to this setup, so I apologize if it's ugly.

Answer 1

Templating isn't as bad as you seem to think it is. Any polymorphic solution would likely require some sort of RTTI use, which would require comparisons and indirect branching -- potentially more or less expensive than a bunch of templated functions and depending on your requirements this could be bad, good or more likely, meaningless. Remember, that the only one template will be instantiated per unique set of template parameters, so only one per base T in your case.

One solution to your constructor issue is to use C++11 Variadic Template args:

template<typename T, typename ...Args> 
Holder builder(const T* base, Args ...args) //receives a BaseStatic
{
  Holder holder;

  //add to a list, etc

  holder.base = base;
  holder.storage = new typename T::Storage(args...);
  return holder;
}

Note that for this to work, the derived storage types have to use private inheritance with BaseStorage , otherwise the Storage typedef becomes ambiguous.

Now this could blow up into a lot of functions depending on the scope of your project, but remember -- "don't optimize yet."

Answer 2

I used Raymond Chen's comment and created this method in BaseStatic :

Storage* CreateStorage() const {return new Storage();}

And override it in DerivedStatic with:

Storage* CreateStorage() const {return new Storage();}