相关疑难解决方法(0)

我有3个类A,B并C声明为

class A {
    int varA;
};
class B {
    int varB;
};
class C : public A, public B {
    void setVar(int var) {
        varA = var;
        varB = var; // <- duplicate
    }
};

现在类C将有2个变量varA和varB.在我的例子中,两个变量具有相同的含义(例如,物理对象的位置),因此总是需要相同,因为成员函数只会对自己的变量进行计算.

我想增加一个父类A和B,但后来同样的问题仍然存在:

class Parent {
public:
    int var;
};

class A : public Parent {};
class B : public Parent {};

class C : public A, public B …

我目前正在制作一个小型游戏引擎,并且遇到了一个我没想到的问题.

我有一个根类,我的引擎中的大多数类派生自,CPObject.CPObject符合CPObjectProtocol,定义一些纯虚函数的抽象类.

我创建了另一个协议,TextureProtocol以及它的具体实现SDLTexture,它也继承自CPObject.到目前为止,一切正常,我可以创建SDLTexture的实例.但是,如果我TextureProtocol继承CPObjectProtocol,clang告诉我,我无法创建抽象类的实例.

我假设一个类可以通过继承另一个类的实现来实现接口.我错了吗？

// CPObject abstract interface/protocol
class CPObjectProtocol {
public:

    virtual void retain() = 0;
    virtual void release() = 0;
    //more methods like this
};

// CPObject implementation.
class CPObject : public CPObjectProtocol {
public:

    CPObject() { _retainCount = 0; }
    virtual ~CPObject() { }

    // implementation of CPObjectProtocol
    virtual void retain() { _retain++; }
    virtual void release() {
        if(--_retainCount <= 0) …

根据下图,我编写了我的代码.

这是我写的代码:

#include<iostream>
#include<string>
using namespace std;

class person
{
private:
    int code;
    string name;
public:
    void    setCode(int c) { code=c; }
    int getCode()          { return code; }
    void setName(string s) { name=s; }
    string getName()       { return name; }
};

class account : public person
{
private:
    double pay;
public:
    void    setPay(double p) { pay=p; }
    double getPay()          { return pay; }
};

class admin : public person
{
private:
    string experience;
public:
    void setExper(string e) { experience=e; } …

有什么区别

Class A {};
Class Z: public A {};

和

Class A {};
Class Z: virtual public A{};

假设我有几个继承的类.

#include <iostream>

struct A {
    A() {std::cout << "a";}
};

struct B : A {};
struct C : A {};

struct D : B, C {};

int main {
    D d;
}

在执行程序时,正如预期的那样,我看到构造了两个A对象,一个用于B,另一个用于创建D对象时构造的C对象.谁,我怎么能不创建两个A对象？我希望使用相同的A对象来创建B和C对象.这可能吗？

我喜欢在几个类中定义良好的接口,为此我在每个类需要实现的抽象类中创建了纯虚函数.
但我面临的问题是我可以实例化类,所以我必须创建另一个继承接口类的类,所有其他类都需要从这个基类继承.以下是代码示例:

界面

class Interface
{
     virtual std::string getName() = 0;
}

class Base : public Interface
{
   virtual std::string getName(return std::string("Base") ;)
}

class A : public Base
{
  std::string getName(return std::string("A") ;)

}

class B : public Base
{
  std::string getName(return std::string("B") ;)

}

所有这些所以我可以在代码中为A和B提供相同的类型.
我可以只使用Interface没有Base类的类吗？
像这样的东西:

class A : public Interface
{
  std::string getName(return std::string("A") ;)

}

可能重复:
在C++中,什么是虚拟基类？

在此代码中创建DR对象时,字符串"Hello World"应打印4次,而不是仅打印3次.为什么会这样？据我所知,这是因为mid1和mid2实际上是遗传的. 有人可以解释一下,当我们真正继承一个类时会发生什么,更重要的是当它有用时为什么？

#include <iostream>

struct BS
{
  BS()
  {
    std::cout << "Hello World" << std::endl;
  }
  unsigned int color;
};

struct mid1 : virtual public BS { };
struct mid2 : virtual public BS { };
struct mid3 : public BS { };
struct mid4 : public BS { };

struct DR : public mid1, public mid2, 
            public mid3, public mid4 { };

int main(int argc, char** argv) 
{ 
  DR d;
  return 0; 
}

这个"基础"类构造了b,medium1和medium2.当我使用"顶级"课程时,它构建了2倍以上.完全构建5次(写入屏幕5次).

问题: 我可以在"基础"类中进行哪些更改,使其仅构建一次.

#include "stdafx.h"
#include<stdlib.h> 

class base
{
public:
    base(){x=5;printf(" %i ",x);}
    int x;
}b;

class medium1:public base{}m1;

class medium2:public base{}m2;

class top:public medium1,medium2{};


int main() {
    top ten;
    getchar();
    return 0;
}

什么是虚拟基类的陷阱？谢谢你回答我的琐碎问题.

我有这个

class Empty {};  // Empty class

class Derived : virtual public Empty
{
        char c;
};

在我的机器上,sizeof(Derived);是8,为什么？不是1因为它只有1 char吗？

当我删除虚拟继承时,sizeof(Derived);是1.