需要有关多重继承和覆盖C ++的可选函数的建议

Question

I've got a problem I'm trying to solve where I'd like to have some abstract base class, that inherits from multiple classes, where derivations can optionally have their methods overridden without declaring an additional class. I'll give an example here of what I'm trying to achieve:

#include <iostream>

using namespace std;

class A
{
    public:
        virtual void foo() = 0;

    protected:
        A() {}
};

class A1 : public A
{
    public:
        A1() : A() {}

        void foo() { cout << "A1 foo" << endl; };
};

class A2 : public A
{
    public:
        A2() : A() {}

        void foo() { cout << "A2 foo" << endl; };
};

class B
{
    public:
        virtual void bar() { cout << "B bar: " << endl; }
};

class B1 : public B
{
    public:
        void bar()
        {
            cout << "B1 bar wrapper begin" << endl;
            B::bar();
            cout << "B1 bar wrapper end" << endl;
        }
};

/*
  ???
  pure virtual class C
  enforce derived classes to inherit something of type A
  enforce derived classes to inherit something of type B

  class C1 : public A1, either B or B1 ??? templates???
  {

  }

  class C2 : public A2, either B or B1 ??? templates???
  {

  }

  Can this be done without having to define classes CA1B, CA2B, CA1B1, CA2B1, etc.?
*/

int main(int argc, char *argv[])
{
    A1 a1;
    a1.foo();
    A2 a2;
    a2.foo();

/*
    C1 c1b with type B
    C1 c1b1 with type B1
    C2 c2b with type B
    C2 c2b1 with type B1

    put c1b, c1b1, c2b, c2b1 in a list named "combinations"

    cout << "Printing combinations" << endl;
    for (auto i : combinations)
    {
        i->foo();
        i->bar();
    }
*/

    return 0;
}

In theory the output would be:

A1 foo
A2 foo
Printing combinations
A1 foo
B bar
A1 foo
B1 bar wrapper begin
B bar
B1 bar wrapper end
A2 foo
B bar
A2 foo
B1 bar wrapper begin
B bar
B1 bar wrapper end

If there's a way to accomplish this through some design pattern, or I'm using a bad approach, please let me know. I'm using C++11.

Answer 1

Your use case screams "templates with constraints". What you are missing is how to check and encode that the template parameters inherit from the correct classes. You can do that with std::is_base_of

template<class A_, class B_,
         typename std::enable_if<std::is_base_of<A, A_>::value>, int>::type = 0,
         typename std::enable_if<std::is_base_of<B, B_>::value>, int>::type = 0>
class C : public A_, public B_
{

};

Here's how it works:

std::enable_if will have a type (an int as in our case), iff the boolean expression it is fed is true. Otherwise there is no type there, and the template will not compile. If there is a type there, then we obtained a non-type template parameter, which we give the default value of 0 to. Assigning the default is what makes us able to instantiate the template with two arguments.

You'll find these utilities, and more, in the <type_traits> header.

Answer 2

I was interested in this subject a while back so I have some strategies. I think a socket program is the perfect demonstration of this type of abstraction. One of the easiest things to do is declare a base header with functions and variables you want available in any object of the class you declare. Then create classes that inherit from the base class when ITSELF is set as the template argument. For Example:

template<class P> class Socket {
  protected:
   int sock;
   char datagram[4096];
   struct sockaddr_in server;
   struct sockaddr_in b;
  public:
   void dport(int port){server.sin_port=htons(port);}
   int CONNECT(){return connect(sock , (struct sockaddr *)&server , sizeof(server));};
  template <class Dst> inline void dst(Dst d){server.sin_addr.s_addr=inet_addr(d);}
  template <class Src> void src(Src s){b.sin_addr.s_addr=inet_addr(s);}  
  int LISTEN(int port){b.sin_port=htons(port); return bind(sock,
  (sockaddr*)&b, sizeof(b));}

There are several ways you can specialize at this point. My favorite would be to create new classes that inherit by passing their own name as the template argument to base.

class UDP : public Socket<UDP> {
public:
    UDP(){server.sin_family=AF_INET;
    this->sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);}
    template <class Msg> int SEND(Msg m, int length){
    return sendto(this->sock, m, length, MSG_DONTWAIT, (sockaddr*)&this-
    >server, sizeof(this->server));}
    void RECV(void* buf, size_t size){socklen_t fromlen = sizeof(sockaddr);
    ssize_t i = recvfrom(this->sock, buf, size, MSG_WAITALL,
    (sockaddr*)&this->b, &fromlen);}
};

class TCP : public Socket<TCP> {
public:
 TCP(){this->sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); this-
 >server.sin_family=AF_INET;}
 int SEND(std::string buf){return send(this->sock, buf.c_str(), buf.size(), 0);}   //TODO: Error Handling
 void RECV(){char cur; while (read(this->sock, &cur, 1) > 0 ) {cout << cur;}}};

Now UDP sockets use recvfrom() and sendto() while TCP sockets use send() and read(). All of these calls are now valid:

Socket<TCP> t1;
Socket<UDP> u1;
TCP t2;
UDP u2;

I could not figure out any way to write specializations of the base class without duplicating code with each one. It's easier to create derived classes.