Re: Proper use of templated containers as class members

From:

Maxim Yegorushkin <maxim.yegorushkin@gmail.com>

Newsgroups:

comp.lang.c++

Date:

Thu, 4 Dec 2008 07:38:37 -0800 (PST)

Message-ID:

<c620a82f-8a72-4c2e-84be-ec4d1f7adf27@l39g2000yqn.googlegroups.com>

On Dec 4, 3:15 pm, Victor Bazarov <v.Abaza...@comAcast.net> wrote:

Per wrote:

I am finding myself doing the following rather often when I have
template containers in classed, e.g. stl::map

For example:

class Foo
{
public:
   typedef std::map<std::string, int> direcory_t;
   //More typedefs of the same style...
private:
   directory_t directory_m;
   //More members of the same style...
public:
   //Constructors and stuff
   const directory_t& directory() const {return directory_m;}
};

The question is what is your opinion on typedefing like this. At the
same time as it saves a lot of typing. After a while there are very
many types in a project. And in the end can get confusing about what
the type really contains. Classes should of course hide their
implementation but it seams very stupid not to have read access
directly to a member. If I didn't have that I have to bloat the class
with wrapper functions for the members. And not using typedefs would
lead to an awful lot of typing.

I use this approach everywhere. It's an abstraction. The users of y=

our

class will use "Foo::directory_t" when they need the type. The main
thing is not saving typing (although it's a nice side effect) but the
ability to change what 'directory_t' means with a single line, and not
to worry about changing the rest of the code that uses it. That's the
whole idea behind typedefs. It doesn't matter how they are defined, as
a namespace member or as a class member.

More often such an approach is called abstraction leak.

The interface of directory_t "abstraction" is that of std::map<>. You
can only change the type of directory_t to something that supports the
full interface of std::map<>, otherwise you break the client code (you
may be lucky if there was limited use of std::map<> directory_t
interface, so that recompilation after changing the type of
directory_t succeeds, but you can't count on that).

--
Max