Question

My situation is a follows: There is some class MyList that will probably get a specific implemenation later on. For now, behavior like std::vector is fine.

However, I really need an easy way to call some kind of asString() / toString() method on it, because I’ll need it in test assertions, debug output and so on. The only options I see are:

1. Public inheritence. I’ll never delete such a list through a base-pointer, since there should never be any base pointers. If I do, there will be no pointer members, anyway. However, rule of thumb still states: Don’t inherit from stl containers.

2. Some kind of “global” (actually in a namespace, of course) method that takes an instance of MyList as argument and does the asString() magic for me. In that case, MyList could be a simple typedef for std::vector.

I like neither of those options too much. Is there something else I failed to think of? Or if not – which way should I prefer?

Answer 1

what is wrong about the second approach? that is by far the easiest and also pretty elegant.-
Imagine the alternative of wrapping the vector. that would cause you alot of extra work and glue code that is error prone! I’d go with the function approach for sure!

edit: btw, i almost exclusively use free functions(sometimes static members) for conversions. Imagine you have a load of types that somehow need to be convertible to string. Having the toString() functions as free functions and not as members does not give you the headache you are heaving right now since you can basically simply overload the function as much as you want and don’t have to touch any existing classes (or maybe classes that you don’t even have source access to).

Then you can have a function like:

template<class T>
void printDebugInfo(const T & _obj)
{
   std::cout<<toString(_obj)<<std::endl;
}

and you wont have the constraints you are experiencing.