标签: multiple-inheritance

我正在经历钻石问题,思想会在各种情况下发挥作用.这是我正在研究的其中一个.

#include <iostream> 
using namespace std;
class MainBase{

    public:
    int mainbase;
    MainBase(int i):mainbase(i){}
    void geta()
    {
        cout<<"mainbase"<<mainbase<<endl;
    }
};
class Derived1: public MainBase{

    public:
    int derived1;
    int mainbase;
    Derived1(int i):MainBase(i),derived1(i) {mainbase = 1;}
    public:
    void getderived1()
    {
        cout<<"derived1"<<derived1<<endl;
    }

};
class Derived2: public MainBase{

    public:
    int derived2;
    int mainbase;
    Derived2(int i):MainBase(i),derived2(i){mainbase = 2;}
    public:
    void getderived2()
    {
        cout<<"derived2"<<derived2<<endl;
    }
};
class Diamond: public Derived1, public Derived2{

    public:
    int diamond;
    int mainbase;
    Diamond(int i,int j, int x):Derived1(j),Derived2(x),diamond(i){mainbase=3;}
    public:
    void getdiamond()
    { …

我已经阅读了解释C#中没有多重继承的问题/答案,我们甚至不需要它,并且它会导致太多问题.

现在,我正在开发一个项目,我不知道如何在没有多重继承的情况下执行操作,而无需重复代码.

这是情况.有一个主页和其他页面继承自主页(主页不继承)的网站.页面和母版页都在执行一些操作:自定义登录,统计,加载用户自定义设置等.目前,解决方案很糟糕,因为这些任务的源代码只是被复制了两次.

主页类继承自Page.另一方面,母版页继承自Masterpage.从逻辑上讲,从公共类继承也很棒,但它是多重继承,所以这是不可能的.

那又怎么办呢？

我想过几种方法,但不喜欢它们:

• 创建一个独立的类,它将从page/masterpage类中调用.所以,例如,而不是写作bool isDisplayingTips = this.CurrentUser.IsDisplayingTips,我会写bool isDisplayingTips = this.SharedObjects.CurrentUser.IsDisplayingTips.我不喜欢它,因为它写的时间更长.

• 创建一个"真实的"空的公共母版页,并从中继承主页和母版页.它不仅需要编写更多代码来访问母版页参数,而且还会减慢速度,每次请求都需要额外的母版页.

任何的想法？

为什么以下继承结构在C++中不合法？

• Son1来自Father1
• Son2派生自Father1
• GrandSon1来自Son1和Son2

如果可能存在合法的情况(也许如果所有类都是纯虚拟的,除了GrandSon1),它们是什么以及为什么会这样？

我已经创建了一个类,其中包含一个带有我的应用程序徽标的自定义标题栏.这种方法很有效,但对于我的大多数类,我需要能够继承该功能以及ListActivity的功能.该怎么办？

任何帮助赞赏.

"假设以下代码:

public class MultiplasHerancas
{
    static GrandFather grandFather = new GrandFather();
    static Father father = new Father();
    static Child child = new Child();

    public static void Test() 
    {
        grandFather.WhoAreYou();
        father.WhoAreYou();
        child.WhoAreYou();

        GrandFather anotherGrandFather = (GrandFather)child;
        anotherGrandFather.WhoAreYou(); // Writes "I am a child"
    }

}

public class GrandFather
{
    public virtual void WhoAreYou() 
    {
        Console.WriteLine("I am a GrandFather");
    }
}

public class Father: GrandFather
{
    public override void WhoAreYou()
    {
        Console.WriteLine("I am a Father");
    }
}

public class Child : Father …

我正在努力使用可变参数模板进行多重继承.

到目前为止这是我的代码:

template <typename U>
    class id_map {
    public:
    std::vector<U> vec_;
};

现在我想初始化另一个类,它从id_map继承多次,如下所示:

template<typename ... T>
class constant_allkey_map : public id_map<T> ... {
private:
public:
    template <typename U>
    void push_back(U i) {
        id_map<U>::vec_.push_back(i);
    }
};

这有效,我可以很好地访问它:

constant_allkey_map<int, long> cakm;
cakm.push_back<int>(1);

当我尝试这样的事情时,它失败了:

constant_allkey_map<int, int> cakm;

有错误

"duplicate base type id_map<int> invalid".

我做了一些阅读,似乎我应该用id参数扩展id_map模板:

template <size_t i_, typename U>
class id_map ...

但我不知道如何在继承部分传递该id:

template<typename ... T>
class constant_allkey_map : public id_map<T> ... {

有人可以帮帮我吗？如果我这样做完全错了,请指出正确的方向？

我有一个关于继承类中ISerializable的正确实现的问题.

我有两个课程AbstractBaseClass及其实施BaseClass.的实施后FinalClass从派生BaseClass,我发现了CA警告:

CA2236 ISerializable类型的调用基类方法应修改方法'FinalClass.FinalClass(SerializationInfo,StreamingContext)'以调用其基类实现.

我不明白的是为什么我应该调用基类如果提取info.GetString("FileName")并且info.GetString("Password")足以创建实例FinalClass？

问题:

1)有人可以向我解释一下吗？

2)如果我按原样保留并且只是压制警告,我是否有任何设计问题？

谢谢

简化的代码示例是:

public abstract class AbstractBaseClass : ISerializable
{
    [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
    public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        info.AddValue ...
        //...
    }

    protected AbstractBaseClass() {  }
    protected AbstractBaseClass(SerializationInfo info, StreamingContext context)
    {
        if (info.GetInt32("Version") >= 1)
        {
            //...
        }
    }
}

public class BaseClass : AbstractBaseClass, ISerializable
{
    public BaseClass() : base() { }

    public …

是否可以创建一个继承自多个实例的类namedtuple,或者创建具有相同效果的类(具有组合基类型字段的不可变类型)？我还没有找到办法.

这个例子说明了这个问题:

>>> class Test(namedtuple('One', 'foo'), namedtuple('Two', 'bar')):
>>>    pass

>>> t = Test(1, 2)
TypeError: __new__() takes 2 positional arguments but 3 were given

>>> t = Test(1)
>>> t.foo
1
>>> t.bar
1

问题似乎是namedtuple不super用于初始化其基类,如创建一个时可以看到:

>>> namedtuple('Test', ('field'), verbose=True)
[...]    
class Test(tuple):
[...]
    def __new__(_cls, field,):
        'Create new instance of Test(field,)'
        return _tuple.__new__(_cls, (field,))

即使我考虑编写自己的版本namedtuple来解决这个问题,但如何做到这一点并不明显.如果namedtuple类的MRO中有多个实例,则它们必须共享基类的单个实例tuple.要做到这一点,他们必须协调namedtuple使用基本元组中哪个索引范围.

有没有更简单的方法来实现与namedtuple类似或类似的多重继承？有人已经在某处实现了吗？

我最近遇到了强制转换和多重继承的问题:我需要转换为Base*to Unrelated*,因为特定的Derived类派生了Unrelated类.

这是一个简短的例子:

#include <iostream>

struct Base{
    virtual ~Base() = default; 
};

struct Unrelated{
    float test = 111;    
};

struct Derived : Base,Unrelated{};

int main(){
    Base* b = new Derived;
    Unrelated* u1 = (Unrelated*)b;
    std::cout << u1->test << std::endl; //outputs garbage
    Unrelated* y = dynamic_cast<Unrelated*>(b);
    std::cout << y->test << std::endl; //outputs 111
}

第一个演员显然不起作用,但第二个演员确实有效.我的问题是:为什么第二次演员工作？难道dynamic_cast只适合投射到相关的类类型吗？我认为Unrelated在运行时没有任何关于它的信息,因为它不是多态的.

编辑:我使用colirus gcc作为示例.

我有以下代码使用多重继承.目的是在派生类中使用两个接口作为一个接口:

struct InterfaceA
{
    virtual void register_stuff();
    virtual void on_state_changed( const State state ) = 0;
};

struct InterfaceB
{
    virtual void register_stuff();
    virtual void on_state_changed( const State state ) = 0;
};

struct Derived : InterfaceA, InterfaceB
{
    void register_stuff() override
    {
        InterfaceA::register_stuff();
        InterfaceB::register_stuff();
    }

    void on_state_changed( const State state ) override
    {
        // how can I know who is responding?
    }
};

注册接口将导致异步调用on_state_changed.是否有可能辨别哪个接口正在调用它？