标签: abstraction

我有一个抽象类在c ++中定义一个纯虚方法:

class Base
{
Base();
~Base();

virtual bool Test() = 0;
};

我已经将其子类化了许多其他类(它们为Test()提供了一个实现),我将其称为A,B,C等.我现在想要使用这个创建任何这些类型的数组基类:

int main(int argc, char* argv[])
{
    int size = 0;
    Base* bases = new Base[10];

    bases[size++] = new A();
    bases[size++] = new B();

    for (int i = 0; i < size; i++)
    {
        Base* base = bases[i];
        base->Test();
    }
}

(请原谅我可能犯的任何错误,我正在写这篇文章提供一个简单的例子).

问题是我无法实例化数组,因为它需要创建一个Base类的实例(它不能像它的抽象那样做).但是,如果不这样做,它就没有分配分配给数组索引所需的内存,因此在尝试访问该内存时会提供分段错误.我的印象是,将new和delete与malloc和free混合起来并不是一个好习惯.

可能是我混淆了应该使用它的方式,我应该尝试使用模板或其他一些机制来做到这一点,但希望我提供了足够的信息来说明我正在尝试做什么.

那么这样做的最佳方法是什么？如何解决将内存分配给抽象类的问题？

谢谢,丹

好的,所以我有一个名为Product的抽象类.我有3个名为Items,Kits和Packages的表,它们实现了Product.产品具有公开属性,公开对象的主键.

那说我有一个表格,我通过产品.我想从新的datacontext中取出该产品,而不必编写一个反映它的类型的大开关来获得正确的表格.

我想做这样的事情,但演员阵容不会接受foo.

public BuilderInclusionsForm(Product p) : this()
        {            
            Type foo = p.GetType();
            product = db2.GetTable(p.GetType()).Cast<foo>().SingleOrDefault(a => 
                a.ProductID == p.ProductID);

或这个:

public BuilderInclusionsForm(Product p) : this()
        {            
            Type foo = p.GetType();
            product = db2.GetTable(p.GetType()).OfType<foo>().SingleOrDefault(a => 
                a.ProductID == p.ProductID);   

我有以下两个类,一个继承自另一个

Class A{
  void print(){cout << "A" << endl;}
}

Class B : A{
  void print(){cout << "B" << endl;}
}
Class C : A{
  void print(){cout << "C" << endl;}
}

然后在另一个课程中我有以下内容:

vector<A> things;
if (..)
  things.push_back(C());
else if (..)
 things.push_back(B());

things[0].print();

这总是打印A
我喜欢它打印B或C取决于我添加到向量中的哪个东西我该
怎么做？
我已经尝试过抽象,但我不完全确定如何在C++中使用它,它并没有为我工作

我有一个类,ClassA它使用我编写的客户端发送短信,TextClient通过调用静态方法发送一些短信

TextClient.Send(string text, string destination)
// where destination is a phone number

但是,我还有一个邮件客户端类MailClient,它发送具有相同签名的电子邮件:

MailClient.Send(string text, string destination)
// where destination is an email address

我想"注入"应该使用哪些客户端 - 这可能吗？

(注意:我知道当对于哪些值destination可以保持并被认为有效时有完全不同的规则可能会出现问题,但是这些值是从其他地方获取的,所以这个类不需要打扰.这就是为什么我我想首先把它抽象出来.)

这是一个例子.我有两个类,一个继承,并且都有一个具有相同名称但不同参数的函数:

public class MyClass
{
    //public class members

    public MyClass()
    {
        //constructor code
    }

    public void Copy(MyClass classToCopy)
    {
        //copy code
    } 
}

public class InheritedClass : MyClass
{
    //public class members

    public InheritedClass():base()
    {
        //constructor code
    }

    public void Copy(InheritedClass inheritedClassToCopy)
    {
        //copy code
    } 
}

我的问题是如何使基类的复制方法(MyClass.Copy)在InheritedClass中不可继承或不可见？我不想这样做:

MyClass a;
InheritedClass b;
b.Copy(a);

这是否有意义,或者我应该保留此功能吗？我甚至可以要求做什么？

我想封装一个float两个结构,例如:

struct AngleDeg {
    explicit AngleDeg(float angle):value(angle) {}
    float value;
};

struct AngleRad {
    explicit AngleRad(float angle):value(angle) {}
    float value;
};

然后在类中使用这些结构重载一个函数,例如:

...
void DoStuff(AngleRad angle);
inline void DoStuff(AngleDeg angle) { DoStuff(Deg2Rad(angle.value)); }
...

这是否与使用以下两个函数一样有效？

void DoStuffRad(float angle);
inline void DoStuffDeg(float angle) { DoStuffRad(Deg2Rad(angle)); }

我正在为OpenGL构建一个图形API,它基于基本的调用绘图图形样式.基本上,不是将数据存储到GPU中,而是使用它的句柄调用它,而是提供信息以绘制每次更新应该绘制的内容.我知道它很慢,但它很简单,适用于非性能关键应用程序.无论如何,有没有现代的glBegin/glEnd？它不需要调用每个顶点,但我可以在每次更新时发送数据,而不将顶点存储在gpu中？

我是一个旨在跨平台的程序; 因此,它将支持某些操作的多个实现.我的第一个想法是编写一个类的层次结构,具有一个通用接口,可能是每个平台的抽象工厂.

class Operation {
    DoOperation() = 0;
}

class OperationPlatform1 : public Operation {
    DoOperation();
}

class OperationPlatform2 : public Operation {
    DoOperation();
}

#ifdef USING_PLATFORM1
    Operation *op = new OperationPlatform1;
#endif

但是,我意识到将在编译时使用将要使用的实现.我试着想一想如何使用静态多态实现这一点,之后我意识到我也可以按照这些方式写一些东西:

class OperationPlatform1 {
    DoOperation();
}

class OperationPlatform2 {
    DoOperation();
}

#ifdef USING_PLATFORM1
typedef OperationPlatform1 Operation;
#endif

Operation op;

抽象多个实现的好方法是什么,其中只有一个在编译时被选中？我也对性能感兴趣,所以除非必须,否则我不想使用虚拟方法.

我目前正在我的游戏和渲染引擎之间编写一个抽象层.不幸的是,我遇到了一个问题:我似乎无法将超类(抽象接口)强制转换为子类(具体引擎的实现).这是我的代码:

IInitationSettings.h

class IInitationSettings {};

OxygineInitiationSettings.h

#include "IInitiationSettings.h"
#include "core/oxygine.h"
class OxygineInitiationSettings : public IInitationSettings, public oxygine::core::init_desc {
public:
    OxygineInitiationSettings(const char* title, bool vsync, bool fullscreen, int width, int height);
};

OxygineInitiationSettings.cpp

#include "OxygineInitiationSettings.h"
OxygineInitiationSettings::OxygineInitiationSettings(const char* title, bool vsync, bool fullscreen, int width, int height) : oxygine::core::init_desc() {
    this->title = title;
    this->vsync = vsync;
    this->fullscreen = fullscreen;
    this->w = width;
    this->h = height;
}

抽象的init方法:

static void init(IInitiationSettings& initSettings);
void GraphicsFactory::init(IInitiationSettings& initSettings){
#ifdef USE_OXYGINE_RENDERING
    OxygineInitiationSettings settings = initSettings; //Does not …

我们可以使用简单的继承或接口而不是抽象.为什么我们需要在PHP中使用抽象？我们如何使用抽象隐藏基本功能？我很困惑使用抽象和接口和继承.哪里用哪个？请帮助理解我.