标签: derived-class

当你读到这篇文章时,你会非常想提出一些建议,比如"由于以下原因,这是一个坏主意......"

忍受我.我知道还有其他方法可以解决这个问题.这个问题应该被认为是琐事.

假设您有一个"交易"类,它具有所有交易的共同属性,例如发票,采购订单和销售收据.

让我们以交易"金额"的简单示例为例,这是给定交易的最重要的货币金额.

public class Transaction
{
    public double Amount { get; set; }

    public TxnTypeEnum TransactionType { get; set; }
}

此数量可能在派生类型中具有更具体的名称...至少在现实世界中.例如,以下值实际上都是相同的:

• 交易 - 金额
• 发票 - 小计
• PurchaseOrder - 总计
• 销售收据 - 金额

所以现在我想要一个派生类"Invoice",它有一个小计而不是一般命名的Amount.理想情况下,以下两种情况都是正确的:

1. 在Transaction的实例中,Amount属性将是可见的.
2. 在Invoice的实例中,Amount属性将被隐藏,但Subtotal属性将在内部引用它.

发票看起来像这样:

public class Invoice : Transaction
{
    new private double? Amount
    {
        get
        {
            return base.Amount;
        }
        set
        {
            base.Amount = value;
        }
    }

    // This property should hide the generic property "Amount" on Transaction
    public double? SubTotal
    {
        get
        { …

我有一个角色扮演游戏的类结构,看起来像这样......

public abstract class Item
{
   public abstract string Name { get; set; }
}

public abstract class Armor : Item
{
   public override string Name { get; set; }
}

public class Helmet : Armor
{
   public override string Name { get; set; }
}

基本上,我试图强制每个派生类型包含"名称"属性.这是最好的方法吗？我知道我可以从Item.Name中删除"abstract",然后删除Armor和Helmet中的重写"Name"属性.如果我这样做,代码看起来有点干净,但我可能忘记在这些派生类中设置base.Name.

有人可以帮我告诉我最好的方法吗？

编辑:对不起,让我再澄清一下我的问题.我想确定两件事.1)Name属性存在于所有派生类中2)Name属性不为null或为空

我基本上想强制任何派生自Item(并且不是抽象)的类具有Name的值.

我在序列化包含派生对象列表的Dictionary时遇到问题.序列化输出包含

<BaseAttributes xsi:type="Turbine" Id="1975fe1f-7aa8-4f1d-b768-93ad262800cd">

我想将BaseAttributes替换为Turbine并且xsi:type不存在.

<Turbine Id="1975fe1f-7aa8-4f1d-b768-93ad262800cd">

我的整体代码如下所示.我有一个类BaseAttributes,我从中派生出一些类,例如Turbine类.这些类存储在带有BaseAttributes列表的字典中.字典是实现的可序列化字典.以下是一般的代码.

[XmlInclude(typeof(Turbine)), XmlInclude(typeof(Station)), XmlInclude(typeof(Substation))]
public class BaseAttributes {

  [XmlAttribute("Id")]
  public Guid Id;
}



public class Turbine : BaseAttributes {
  private Element windSpeed;
  public Element WindSpeed {
    get { return windSpeed; }
    set { windSpeed = value; }
  }

  public Turbine(float windSpeed){
    this.windSpeed= new Element(windSpeed.ToString(),"ms");
  }
  //used for xmlserilization
  private Turbine(){}
}



public class CollectionOfBaseAttributes {
  public SerilizableUnitsDictionary<DateTime, List<BaseAttributes>> units;
}

[XmlRoot("dictionary")]
public class SerilizableUnitsDictionary<TKey, TValue>
: Dictionary<TKey, TValue>, IXmlSerializable {

  public System.Xml.Schema.XmlSchema GetSchema() …

我是C++的新手,但我遇到了一个似乎无法解决的问题.我将使用汽车来说明问题,只是为了让事情变得更容易.好的,我可以说我有一个基类Car,我有不同的品牌继承自该类.像这样:

class Car
{
    public:
       Car();
};

class Ford: public Car
{
    public:
        Ford();
        void drive();
        void park();
};

整个想法是将所有这些不同的汽车放在一起,形成一个Car类型的矢量.像这样:

vector<Car*> cars;
cars.push_back(new Ford());
cars.back()->drive(); //this won't work

如何在基类实例上调用派生函数？请注意,我想将这些全部放在一个向量中.这背后的原因是因为我只想使用已经添加的最后一个派生汽车类实例.(在这种情况下,派生汽车类是福特).另请注意,所有车型都具有相同的功能.

我有一个基类和两个派生类,我需要将一个指向派生类对象的指针复制到另一个类中,就像示例一样.

class Base
{
public:
    Base(const Base& other);
}

class Derived1 :public Base
{
public:
    Derived1(const Derived& other): Base(other){...};
}

class Derived2: public Base
{
public:
    Derived2(const Derived& other): Base(other){...};
}

main()
{
    Derived 1 d1;
    Derived2 d2(d1)
}

我尝试从Derived 1 ti base(允许向上转换)传递,然后到*dynamic_cast*Base到Derived2并调用复制构造函数,但它不起作用.我只需要在两个派生对象之间复制两个对象的Base部分.

假设 A、B、C 派生自 AbstractBaseClass，并且它们都是同一个 java 项目的一部分，是以下形式的包结构...

 package com.whatever.###
 AbstractBaseClass.java

 package com.whatever.###.###
 A.java
 B.java
 C.java

...通常优于以下形式的封装结构...

 package com.whatever.###.###
 AbstractBaseClass.java
 A.java
 B.java
 C.java

？

...或者很少有人会关心？

考虑以下模板类:

template <typename T> class Function {
public:
    virtual float eval( const T &x, const T &y ) = 0;
};

由于'eval'函数不应该修改两个输入'x'和'y'的值,我把它们设为'const'.然后我创建从Function派生的以下类

class Foo1 : public Function <float*> {
public:
    Foo1() : Function <float*> () {}
    virtual float eval( const float* &x, const float* &y ) { ... }
};

当我用g ++编译时,我收到以下警告:

hidden overloaded virtual function 'Function<float *>::eval' declared here: type mismatch at 1st parameter
      ('float *const &' vs 'const float *&')
        virtual float eval( const T &x, const T …

我正在尝试为我正在编写的程序实现良好的设计模式。我有一个这样的班级结构。

abstract class SomeBase
{
     public SomeObject obj { get; protected set; } 

     protected SomeBase(SomeObject x)
     {
           obj = x;
     }

     //Other methods and fields...
}

public class SomeDerived : SomeBase
{

     public SomeDerived() : base(new SomeObject(this))
     {

     }

}

现在我确定您知道，您不能在基本构造函数中传递 this，因为此时对象尚未初始化。无论如何，我真的希望有一个解决方法。允许SomeDerived()处理基类字段的设置对我来说不是最佳实践。我想将这个新对象向上传递。

派生类的构造函数返回基类的实例.

以下代码解释了我的问题:

// Vector is defined by an external module (Unreal.js)
class TestB extends Vector {
    constructor() {
        super();
    }
    Log() {
        console.log("" + this);
    }
}
console.log(new TestB() instanceof TestB) // returns false !!! why ??? 
console.log(new TestB() instanceof Vector) // returns true...

class TestA extends Array {
    constructor() {
        super();
    }
    Log() {
        console.log("" + this);
    }
}
console.log(new TestA() instanceof TestA); // returns true, all is good

这怎么可能？

[class.access/1] 中的 C++ 标准规定（强调我的）：

一个类的成员可以是

• 私人的; 也就是说，它的名字只能被声明它的类的成员和朋友使用。
• 受保护；也就是说，它的名称只能由声明它的类的成员和朋友、从该类派生的类及其朋友使用（参见 [class.protected]）。
• 民众; 也就是说，它的名字可以在任何地方使用而不受访问限制。

那么为什么编译器会在下面的 C++ 程序中引发这个错误呢？

#include <iostream>

class B {
  protected:
    static int const i = 1;
};

class D: public B {
  public:
    void f();
    friend void g();
};

void D::f() {
  B b;
  std::cout << b.i;  // OK
}

void g() {
  B b;
  std::cout << b.i;  // error: 'i' is a protected member of 'B'
}

int main() {
  D d;
  d.f();
  g();
  return 0;
} …