标签: diamond-problem

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

#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()
    { …

为了好玩,我正在为Windows的XUL实现工作.在XUL中,UI元素可以用XML编写,如下所示:

<window width="800" height="600"></window>

我正在考虑一个获取和设置元素属性的系统.它工作得很好,但我不确定钻石继承的使用是否有潜在危险.我在下面发布了一个完整的代码示例:

#include <boost/lexical_cast.hpp>
#include <string>
#include <map>


class Attribute
{
public:
    virtual void get(std::string & outValue) = 0;
    virtual void set(const std::string & inValue) = 0;

    static int String2Int(const std::string & inString)
    {
        return boost::lexical_cast<int>(inString);
    }

    static std::string Int2String(int inValue)
    {
        return boost::lexical_cast<std::string>(inValue);
    }
};


class Width : public Attribute
{
public:
    Width(){}

    virtual void get(std::string & outValue)
    {
        outValue = Int2String(getWidth());
    }

    virtual void set(const std::string & inValue)
    {
        setWidth(String2Int(inValue));
    }

    virtual int getWidth() const …

请不要在这里对这段代码中真正奇怪的工人层级提出质疑,我不知道为什么有人会想要这样的东西,但我决定给自己一个多重继承的练习,只是为了确保我完全理解它.所以这是结果.

using namespace std;

class Employee
{
protected:
    string name;
public:
    string getname()
    {
        return name;
    }
    void setname(string name2)
    {
        name = name2;
    }
    Employee(string name2)
    {
        name = name2;
    }
    Employee(){}
};

class Manager : public Employee
{
public:
    string getname()
    {
        return ("Manager" + name);
    }
    Manager(string name2) : Employee(name2){}
    Manager() : Employee(){}
};

class Supervisor : public Manager,public Employee
{
public:
    Supervisor(string name2) : Manager(name2) , Employee(name2){}
    Supervisor() : Manager() , Employee(){}
    string getname()
    {
        return …

为什么Java不支持多重继承,尽管默认情况下所有java方法都是虚拟的？为什么Java会出现钻石问题？

我正在使用许多抽象类,它们只定义纯虚函数和虚拟(非纯)析构函数.

没有使用虚拟继承,是否仍然可以使用钻石继承结构？(我想确保即使某些程序员不知道他应该使用虚拟继承也没有问题.)什么是一个很好的资源,它提供了一个简短而完整的主题概述？

谢谢!

简单的问题:这个层次结构会导致DP吗？

//Abstract base class
class A {
    //Implement pure virtual methods with a default definition.
    //Pure virtual methods are still declared pure virtual.
};

//Abstract derived class
class B : public A {
    //Define pure virtual methods with a default definition.
    //Pure virtual methods are still declared pure virtual.
};

//Abstract base class
class C {
    //Define pure virtual methods with a default definition.
    //Pure virtual methods are still declared pure virtual.
};

//Concrete class
class D : public B, …

请考虑以下代码:

class A(object):
    def __init__(self):
        print("A.__init__")
        super(A, self).__init__()          # 1
        print("A.__init__ finished")

class B(A):
    def __init__(self):
        print("B.__init__")
        super(B, self).__init__()          # 2
        print("B.__init__ finished")

class C(A):
    def __init__(self):
        print("C.__init__")
        super(C, self).__init__()
        print("C.__init__ finished")

class D(B, C):
    def __init__(self):
        print("D.__init__")
        print("Initializing B")
        B.__init__(self)                   # 3
        print("B initialized")
        print("Initializing C")
        C.__init__(self)                   # 4
        print("C initialized")
        print("D.__init__ finished")

D()

# D.__init__
# Initializing B
# B.__init__
# C.__init__
# A.__init__
# A.__init__ finished
# C.__init__ finished
# B.__init__ finished
# B initialized
# Initializing …

考虑以下:

#include <string>

struct animal
{
public:
    virtual std::string speak() = 0;
};

struct bird : public animal
{
public:
    std::string speak()
    {
        return "SQUAK!";
    }
};

struct landAnimal : public animal
{
    virtual int feet() = 0;
};


struct sparrow : public bird, public landAnimal
{
    int feet() { return 2; }
    // This solves it, but why is it necessary, doesn't bird provide this?
    // std::string speak(){ return this->speak(); } 
};

int main()
{
    sparrow tweety = sparrow(); …