Designing for multiple interfaces

To all experts out there:

I am designing a test tool to test voice application, Tool is intended to
read a test scripts (that has commands to connect/manipulate/disconnect
voice applications) and accordingly creates commands/voice packets which are
written to a test input file.

The input to application may be either circuit interface or packet
interface. Then those circuit and packet types have different flavors of
applications. The original design is like this:

class voice_manager: It is base class which acts more like interface class.
class ckt_voice : public voice_manager
class ckt_voice_1 : public ckt_voice
class ckt_voice_2: public ckt_voice
class pkt_voice_1: public pkt_voice
class pkt_voice_2 : public pkt_voice

Main program has a base pointer and instantiates correct object during
runtime e.g.

voice_manager* vmgr = new ckt_voice_2

Then it reads commands from the scripts and passes to command handlers. All
command handlers are virtual functions hence they are handled correctly by
the appropriate class.

My first question is: is this the right way to provide a combined interface
for an application which multiple interfaces but only one could be active at
a given time in this case either circuit or packet? The base class,
voice_manager, has to declare all command handlers which are found in
circuit interface or packet interface. In one way, it is nice because base
class has error message and if a packet related command is encountered on
circuit call, the function in the base class is called (as there is no
handler in voice_ckt class for packet commands) which prints error message
without causing any crashes. On the other hand, it does not seem right to
have one class act as both ckt & pkt interface.

I thought of having two classes ckt_interface (has function definitions for
circuit related commands) and pkt_interface (with packet command handlers)
and then derive user_interface from these two. But that would be opposite of
inheritance philosophy i.e. generic class deriving from specific classes
ouch.

I could live with the above as both ckt & pkt interfaces have only 4-5
functions so there are only 10-12 function handlers in voice_manager class.
But there are some common functions in voice_ckt_1 & voice_pkt_1. I would
like to create a base class base_voice_1 and derive those from base_voice_1
as well, so the new design looks like:

class voice_manager
{
   virtual void ckt_cmd_1();
   virtual void pkt_cmd_1();

   virtual void voice_cmd_1();
}
class base_voice_1
{
   void voice_cmd_1();
}
class ckt_voice : public voice_manager
class ckt_voice_1 : public ckt_voice, public base_voice_1
class ckt_voice_2: public ckt_voice
class pkt_voice_1: public pkt_voice, public base_voice_1
class pkt_voice_2 : public pkt_voice

which causes ambiguity as voice_cmd_1() is present in both base classes. I
could call it from ckt_voice_1 & pkt_voice_1 using class scope, but not sure
if thats the right design approach.

So let me know if you think there are better design alternatives available
for combining multiple interfaces instead of creating a gigantic big class
which has all interface commands in it.

Thanks
Zaigham A. Kazmi

      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]