dictionary design, comments?

[John]

I am trying to design a dictionary in such a way that I can
keep the interface and implementation separate. Here is my
initial design. Anyone has any comments on it or suggestions
on how I could make it better.

Does anyone have a good code/pointer that discusses
dictionary design.
Thanks,
--j
template <typename K,
typename I,
class _Compare = std::less<K>,
class dic_impl = my_dict<K,I,_Co mpare> >
class dictionary : public dic_impl {

public:

typedef typename dic_impl::dic_i tem dic_item;
typedef typename dic_impl::const _dic_item const_dic_item;

typedef K key_type;
typedef I inf_type;
dictionary(){ };

virtual ~dictionary(){d ic_impl::clear( );}

const K& key(const_dic_i tem it) const { return dic_impl::key(i t);}
const I& inf(const_dic_i tem it) const { return dic_impl::inf(i t);}
int defined(const K& k) const
{ return (lookup(k) == dic_impl::end() ) ? false : true; }

inline dic_item insert(const K& k, const I& i)
{ return dic_impl::inser t(k,i); }

inline const_dic_item lookup(const K& k) const
{ return dic_impl::looku p(k); }

inline dic_item lookup(const K& k)
{ return dic_impl::looku p(k); }

inline void del(const K& k) { dic_impl::del(k ); }

inline void del_item(dic_it em it) { dic_impl::del_i tem(it); }

void change_inf(dic_ item it, const I& i)
{ dic_impl::chang e_inf(it,i); }

inline void clear() { dic_impl::clear (); }

inline int size() const { return dic_impl::size( ); }

inline bool empty() const { return (size()==0) ? true : false; }

inline const_dic_item begin() const { return dic_impl::begin (); }
inline const_dic_item end() const { return dic_impl::end() ; }

inline dic_item begin() { return dic_impl::begin (); }
inline dic_item end() { return dic_impl::end() ; }

inline const_dic_item succ_item(const _dic_item it) const
{ return dic_impl::succ_ item(it);}
inline const_dic_item pred_item(const _dic_item it) const
{ return dic_impl::pred_ item(it);}

inline dic_item succ_item(dic_i tem it)
{ return dic_impl::succ_ item(it);}
inline dic_item pred_item(dic_i tem it)
{ return dic_impl::pred_ item(it);}
typedef dictionary<K,I, _Compare,dic_im pl> this_type;
}; // end of dictionary
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[BigBrian]

Use the bridge pattern.
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]

[BigBrian]

I would use a bridge. You're defining the interface class to be a
subclass of the implementation. Make dic_impl and abstract class and
have your dictionary class aggregate it instead of deriving from it.
You can then derive concrete implementations from the abstract
dic_impl, and the interface can access the implementation
polymorphically .
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.m oderated. First time posters: Do this! ]