Sharing member functions between classes

Question

I'm designing an application that uses one class to manage a TCP connection and one to manage UI elements. The connection manager receives message strings and does minimal processing on them to determine their type. If they're of a known type, the connection manager will pass the strings along to the GUI manager so it can update the UI elements accordingly.

My challenge is this: if I don't want to include header files across classes, how do I permit access to the other class's public functions?

For example:

//message_types.h
typedef void(*MessageHandlerPointer)(std::string);

enum MessageTypes { info_type, time_type, command_type, reply_type,
                    inside_type, update_type, NUM_TYPES };
/////////////////////////////////////////////////////////////////////////
//ConnectionManager.h
class ConnectionManager
{
  string hostname;
  string port;
  int connection_fd;

  string message_types[NUM_TYPES];
  string partial_message;

  void process_message(string message);
  MessageHandlerPointer message_handlers[NUM_TYPES];

  public:
    ConnectionManager(string hostname, string port);
    ~ConnectionManager();

    int connect();
    void disconnect();
    void listen();
};
/////////////////////////////////////////////////////////////////////////
//ConnectionManager.cpp
ConnectionManager::ConnectionManager(string hostname, string port,
                    void (*message_handlers[NUM_TYPES])(string)):
  hostname(hostname), port(port),
  message_types { "i", "t", "c", "r", "I", "u" }
{
  for(int i = 0; i < NUM_TYPES; i++)
  {
    this->message_handlers[i] = message_handlers[i];
  }
}
/////////////////////////////////////////////////////////////////////////
//GuiManager.h
class GuiManager
{
  void info_handler(string msg);
  void time_handler(string msg);
  void command_handler(string msg);
  void reply_handler(string msg);
  void inside_handler(string msg);
  void update_handler(string msg);

  public:
    GuiManager();
    ~GuiManager();

    MessageHandlerPointer message_handlers[NUM_TYPES];
};
/////////////////////////////////////////////////////////////////////////
//GuiManager.cpp
GuiManager::GuiManager()
{
  message_handlers[info_code]    = &info_handler;
  message_handlers[time_code]    = &time_handler;
  message_handlers[command_code] = &command_handler;
  message_handlers[reply_code]   = &reply_handler;
  message_handlers[inside_code]  = &inside_handler;
  message_handlers[update_code]  = &update_handler;
}
/////////////////////////////////////////////////////////////////////////
//generic main.cpp
int main()
{
    GuiManager gm();
    ConnectionManager cm("host", "45123", gm.message_handlers);
}

But C++ doesn't want me to do that, and I vaguely understand why. Member functions aren't free functions. But I was hoping that I could perhaps make the functions somewhat owner- or class-agnostic?

Either way, my idea isn't going to get me where I want to be, so I'd be glad to hear someone else's impression of what the best solution would be.

Also, I recognize that I might be getting a little ridiculous for the sake of modularity in not letting the classes interface with one another directly. Am I missing the point / sacrificing simplicity for principle?

I'm fairly new to OO, so I'm interested in all of the details of any answer. =)

Answer 1

So if I have got this right, you want your ConnectionManager to forward messages to your GUIManager, but without having to include the header of GUIManager, just using forward declarations.

On place you get stuck is that as you notice the type of

void GUIManager::handle_info( std::string ) 

which is different from the type of a pointer to a free function

void handle_info (std::string).

To declare a pointer to the former you have to write

typedef void (GUIManager::*MessageHandlerPointer)(string );

I wrote a simplified example (with Foo and Bar :) ), where an instance of Bar forwards a message to an instance of Foo. Here it is:

#include <iostream>
#include <string>

using namespace std;

class Foo;
typedef void (Foo::*FooMessageHandlerPointer)(string );     // this is the type of a pointer to a member of Foo that gets a string and returns void.

class Bar
{
public:
    Bar ( Foo* foo_, FooMessageHandlerPointer ptr )
    :
    foo (foo_),
    p (ptr)
    {}

public:

    void ForwardMessage ( string s )
    {
        (foo->*p)(s);
    }

private:

    Foo* foo;
    FooMessageHandlerPointer p;
};


class Foo
{
public:

    void ProcessMessage (string s)
    {
        cout << "Foo received: " << s << "\n";
    }
};


int main (void)
{
    Foo foo1;

    Bar bar1 ( &foo1, &Foo::ProcessMessage );

    bar1.ForwardMessage( "Hello world!" );

    return 0;
}

Note that when Bar is defined, it has available only a forward declaration of Foo and the type of the member function pointer. Note also, that Bar needs not only a pointer to a function but also a pointer to the instance too. Of course when you create the instance of Bar in the main, you need to have access to the headers.

I hope i got your question right and this helps you. Otherwise it has been a good exercise since I 've been playing with pointers to member functions these days :)

UPDATE: After your comment, I think you may be looking for something like a delegate, something that encapsulates a function to call, whether it is free or member function. Maybe this thread will be helpful