标签: base-class

class Material
{
public:
 void foo()
 {
  cout << "Class Material";
 }
};

class Unusual_Material : public Material
{
public:
 void foo()
 {
  cout << "Class Unusual_Material";
 }
};

int main()
{
 Material strange = Unusual_Material();
 strange.foo(); //outputs "Class Material" 

 return 0;
}

我希望这导致"Class Unusual_Material"显示在控制台上.有没有办法实现这个目标？在我的程序中,我有一个类材料,从中可以得到其他更具体的材料.方法Material :: foo()表示Material中适用于大多数材料的方法,但是在某种程度上,需要为具有不寻常属性的材料定义另一个foo().

程序中的所有对象都包含一个Material字段.如果他们被分配了一个不寻常的材料,我希望调用派生的,不寻常的foo.

这可能要么很简单,要么不可能,但无论如何我无法弄明白.

谢谢

struct B { int b1, b2;  B(int, int); };
struct D : B {
  int d1, d2;
// which is technically better ?
  D (int i, int j, int k, int l) : B(i,j), d1(k), d2(l) {} // 1st Base
// or
  D (int i, int j, int k, int l) : d1(k), d2(l), B(i,j) {} // last Base
};

以上只是伪代码.实际上我想知道调用基础构造函数的顺序是否重要？ 是否有任何不良行为(特别是拐角案件)由任何案件引起？我的问题是更多的技术方面,而不是编码风格.

如果一个类总是要继承,那么构造函数protected是否有意义？

class Base
{
protected:
    Base();
};

class Child : protected Base
{
public:
    Child() : Base();
};

谢谢.

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

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

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

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

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
        { …

我觉得这是不可能的,例如: 在C++中的其他一些指令之后调用基类的构造函数
但是下面的程序运行并生成两行"Constructor Person":

#include <iostream>

class Person
{
public:
    Person() 
    { 
        std::cout << "Constructor Person" << std::endl; }
    };

class Child : public Person
{
public:
    Child() 
    { 
        c = 1; 
        Person(); 
    }
    int c;
};

int main() 
{
    Child child;
    return 0;
}

第一个是默认构造函数的隐式调用,这是明确的.第二个怎么样 - 这是否意味着标题中描述的行为是合法的？我使用Visual C++ 2010.

我在使用Microsoft Visual C++ 2015时遇到了一些困难,并且能够通过一个小程序复制该问题.鉴于以下课程:

class BaseClass {
public:
    BaseClass()
        : mValue( 0 )
        , mDirty( true )
    {}
    virtual ~BaseClass() {}
    virtual int getValue() const { if( mDirty ) updateValue(); return mValue; }

protected:
    virtual void updateValue() const = 0;

    mutable bool mDirty;
    mutable int  mValue;
};

class DerivedClass : public BaseClass {
public:
    DerivedClass() {}

protected:
    void updateValue() const override
    {
        mValue++;
        mDirty = false;
    }
};

class Impersonator {
public:
    Impersonator() {}

    // conversion operator
    operator DerivedClass() const …

3.9/2:

对于普通可复制类型T的任何对象(基类子对象除外),无论对象是否保持类型T的有效值,构成对象的基础字节(1.7)都可以复制到char或者数组中.无符号的字符.

3.9/3:

对于任何平凡复制的类型T,如果两个指针至T指向不同T对象OBJ1和OBJ2,其中既不 OBJ1 也不 OBJ2是一个 基类的子对象,如果OBJ1被复制到OBJ2底层字节(1.7)组成,OBJ2应随后保持与obj1相同的值.

我正式理解这些规则,但我感兴趣的是这些限制的重点是什么？

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

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()处理基类字段的设置对我来说不是最佳实践。我想将这个新对象向上传递。

基于我读过的其他帖子,似乎这可能是不可能的,但我想我会发布我想要做的事情,看看是否有人知道解决方案.

我正在尝试向Telerik Open Access域模型生成的类添加"Clone()"方法.没问题.我能够弄清楚如何将基类添加到生成的实体模型中,以便我可以通过它们的基类来识别这些类.(所有实体都从基类继承)

我希望所有这些实体模型类能够克隆自己.我也找到了解决方案.(深度克隆对象)

现在我有一个基类,我想在每个从该基类派生的类中添加一个Clone()函数.所以......似乎基类是放置它的自然场所......对吗？

public abstract class DBEntityBase
{
    /// <summary>
    ///     Gets a COPY of the instance in it's current state
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <returns></returns>
    protected T Clone<T>()
    {
        return JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(this));
    }
}

我添加了受保护的泛型Clone()方法,因为在基类级别我们不知道我们正在克隆的类型.Clone()方法需要由实体模型本身实现,以便提供克隆的特定类型.

public partial class DeliverableEntity
{
    public new DeliverableEntity Clone()
    {
        return this.Clone<DeliverableEntity>();
    }
}

这工作正常,但不保证派生类将公开公开Clone()方法,因此我向基础添加了一个抽象Clone()方法,这将要求派生类实现公共Clone()方法.

public abstract class DarkRoomDBEntityBase
{
    /// <summary>
    ///     Gets a COPY of the …

我正在使用Stroustrup的C++编程语言第4版进行练习.其中一项任务是这样制定的:

考虑使用类Exception作为用作异常的所有类的基础.它应该是什么样的？该如何使用？这有什么用呢？要求使用这样的课程可能会有什么缺点？

答案看起来很像std::exception,除了缺点部分 - 我能想象的唯一一个__vptr通常被认为可以忽略不计的成本.我在这里错过了什么？