полезное использование множественного наследования [closed]

Представьте, вам нужен зашифрованный и gzed файловый поток. как это сделать на большинстве языков? по примеру в фиктивном Java.

var f=new filestream("myfile")
var e=new encryperstream(f);
var z=new gzipstream(e);

охууууууу …

здесь мы можем воспользоваться полезным преимуществом множественного наследования cpp

... code context...
class cmystrm=
 public filestream, 
 public encstream, 
 public zipstream, 
 public stdstreamop{} //cpp multi inheritance stuff 
 mystrm; // <-- object creation
...
mystrm.open("file"); // <- filestream
mystrm.setkey("1234"); // <- encstream
mystrm.setratio(9); // <-zipstream
mystrm.write("hello kitty");
mystrm.close();
...

следите за отрывком из моей незавершенной работы

#include <iostream>

using namespace std;

class stm{};
typedef int(stm::*tdio)(char** buf,long sz);
struct struct_stm{
    stm *ctx;
    tdio w;
    tdio r;
} stm_cur;

class stds{
    protected:
        struct_stm my;
    public:
        stds(){
            cout << "stds::"<<endl;
            my.ctx=stm_cur.ctx;
            my.w=stm_cur.w;
            my.r=stm_cur.r;
        }
        int write(char** buf, long sz){
            cout << "stds::write"<<endl;
            return(my.ctx->*my.w)(buf,sz);
        };
        int read(char** buf,long sz){
            cout << "stds::read"<<endl;
            return(my.ctx->*my.r)(buf,sz);
        }
};

class fils:public stm{
    protected:
        string filename;
        int fwrite(char** buf, long sz){
            cout << "fils::fwrite fn=" << filename << endl;
            return 0;
        }
        int fread(char** buf, long sz){
            cout << "fils::fread fn=" << filename << endl;
            return 0;
        }
    public:
        fils(){
            cout << "fils::"<<endl;
            stm_cur.ctx=this;
            stm_cur.w=(tdio)&fils::fwrite;
            stm_cur.r=(tdio)&fils::fread;
        }
        int open(string fn){
            filename=fn;
            return 0;
        }
};

class mods:public stm{
    protected:
        struct_stm old;
        virtual int _write(char** buf, long sz){
            cout << "mods::write" << endl;
            return (old.ctx->*old.w)(buf,sz);
        };
        virtual int _read(char** buf, long sz){
            cout << "mods::read" << endl;
            return (old.ctx->*old.r)(buf,sz);
        }
    public:
        mods(){
            cout <<"mods::"<<endl;
            old.ctx=stm_cur.ctx;
            old.w=stm_cur.w;
            old.r=stm_cur.r;
            
            stm_cur.ctx=this;
            stm_cur.w=(tdio)&mods::_write;
            stm_cur.r=(tdio)&mods::_read;
        }
};

class encs:public mods{
    protected:
        string key;
        virtual int _write(char** buf, long sz){
            cout << "encs::write key=" << key << endl;
            return mods::_write(buf,sz);
        }
    public:
        int setkey(string k){
            key=k;
            return 0;
        }      
};

int main(int argc,char** argv){
    class mys1:public fils, public encs, public stds{} s1;
    s1.open("test.tst");
    s1.setkey("1234");
    s1.write(NULL,0);
}

(будьте осторожны при создании объекта, это не потокобезопасно)

это прекрасно работает …

ТАК … мой вопрос …

Я попробовал

class a{
 static string s;
}
class b:a{
 b(){a.s="tst"}
}
class c:a{
 c(){a.s="tst2"}
}

class multi:b,c;

Ошибка компиляции g ++ (много французских клингонских строк)

как я понимаю LD не справляется …

Зачем ?

извините за мой плохой английский и мои навыки наклона cpp 30h …