标签: derived-class

在C#中,我有基类Product和派生类Widget.

产品包含静态方法MyMethod().

我想从静态方法Widget.MyMethod()调用静态方法Product.MyMethod().

我不能使用base关键字,因为它只适用于实例方法.

我可以显式地调用Product.MyMethod(),但如果我稍后将Widget更改为从另一个类派生,我必须修改该方法.

C#中有一些类似于base的语法允许我从派生类的静态方法中调用基类的静态方法吗？

我的问题是我想将一个对象传递给派生类,但它必须在基类构造函数之前完成,因为基类将立即调用派生类Start()使用该对象的方法.

以下是基类的摘录(为方便起见,从BarcodeScanner重命名).

public abstract class MyBase
{    
    public MyBase()
    {
        if (Initialize())
            this.Start();
    }

    public abstract bool Initialize();
    public abstract void Start();
}

这是我正在创建的派生类.

class MyDerived : MyBase
{
    private string sampleObject;

    public MyDerived (string initObject)
    {
        sampleObject = initObject;
    }

    public override bool Initialize() 
    { 
        return GetDevice();
    }
    public override void Start() 
    { 
        Console.WriteLine("Processing " + sampleObject.ToString()); 
    }
}

我怀疑你可以让C#在基础构造函数之前执行派生构造函数; 所以我真的只是在寻找一个解决方案,在使用对象之前将对象传递给派生类.

我通过在MyDerived构造函数中放置Initialize/Start if块来解决这个问题.但是,还有其他类派生自基类; 所以我最终不得不在每个派生类中重复这个Initialize/Start代码块.我想看一个修改基类的替代方法.

public class SuperCar: Car
{
     public bool SuperWheels { get {return true; } }
}

public class Car 
{
     public bool HasSteeringWheel { get {return true;} }
}

如何设置派生Supercar的基类？

例如,我想简单地设置SuperCars基类,如下所示:

public void SetCar( Car car )
{
SuperCar scar = new SuperCar();
car.Base = car; 
}

基本上,如果我有Car对象,我不想手动遍历汽车的每个属性以设置SuperCar对象,我认为这是你可以做到的唯一方法,但如果你能以另一种方式做到这一点会好得多.

当一个方法virtual在类中声明时,它的派生类中的覆盖也会被自动考虑virtual,并且C++语言virtual在这种情况下使该关键字成为可选:

class Base {
    virtual void f();
};
class Derived : public Base {
    void f(); // 'virtual' is optional but implied.
};

我的问题是:选择的理由是什么virtual？

我知道编译器并不是绝对必要的,但我认为如果编译器强制执行这样的约束,开发人员将会受益.

例如,有时当我阅读其他人的代码时,我想知道一个方法是否是虚拟的,我必须追踪它的超类来确定它.而一些编码标准(谷歌)使得将virtual关键字放在所有子类中是"必须的" .

我正在尝试用C++学习模板,我有以下代码:

#include <stack>

template<typename T>
class   myClass : public std::stack<T>{
public:
    myClass(void);
    myClass(myClass const & src);
    virtual ~myClass(void);
    myClass &   operator=(myClass const & rhs);
};

template<typename T>
myClass::myClass(void) : std::stack<T>(){
}

但是当我尝试编译时,我无法弄清楚为什么会得到以下内容:

test.cpp:17:1: error: 'myClass' is not a class, namespace, or enumeration
myClass::myClass(void) : std::stack<T>(){
^
test.cpp:8:9: note: 'myClass' declared here
class   myClass : public std::stack<T>{
        ^
1 error generated.

它看起来像函数的定义导致错误,但我不知道为什么我得到这个错误,它看起来对我好(即使我猜它不是真的好),只是一个语法错误？

我用clang ++ -Wall -Werror -Wextra -c编译.

什么可能导致此错误？

我不知道这是否可行,但我试图从Derived Class中获取Base Class实例.在C#中,我可以使用base关键字来访问Base Class的属性和方法(当然),但我想使用base本身.尝试这样做会导致"使用关键字'base'在此上下文中无效"错误.

示例代码

public class SuperParent
{
    public int SPID;

    public SuperParent()
    {
    }
}

public class SubChild : SuperParent
{
    public SubChild(int pSPID)
    {
        base.SPID = pSPID;
    }

    public int BaseSPID
    {
        get
        {
            SuperParent sp = base;
            return sp.SPID;
        }
    }
}

如果我有一个基类,只有基类的虚方法和2个派生类,那么实现了这些虚方法.

我如何能:

 // causes C2259
 BaseClass* base = new BaseClass[2];

 BaseClass[0] = new FirstDerivedClass;
 BaseClass[1] = new SecondDerivedClass;

要么:

// causes "base is being used without being initialized"
BaseClass* base;
// causes CC59 again
BaseClass* base = new BaseClass;

base[0] = FirstDerivedClass();
base[1] = SecondDerivedClass();

(或类似的东西)

...所以我可以BaseClass通过它访问s方法DerivedClass,但是通过指针和指针是一个DerivedClasss 的数组？

我有一个参数化的hibernate dao执行基本的crud操作,并且当参数化被用作委托来完成给定dao的基本crud操作时.

public class HibernateDao <T, ID extends Serializable> implements GenericDao<T, ID>

我希望能够在运行时从T派生Class以在Hibernate中创建条件查询,这样:

public T findByPrimaryKey(ID id) {
    return (T) HibernateUtil.getSession().load(T.getClass(), id);
}

我知道:

T.getClass()

不存在,但有没有办法在运行时从T派生正确的Class对象？

我看过泛型和反思,但没有找到合适的解决方案,也许我错过了一些东西.

谢谢.

我有一个声明和定义构造函数的基类,但由于某种原因,我公开派生的类没有看到那个构造函数,因此我必须在派生类中显式声明转发构造函数:

class WireCount0 {
protected:
    int m;
public:
    WireCount0(const int& rhs) { m = rhs; }
};

class WireCount1 : public WireCount0 {};

class WireCount2 : public WireCount0 {
public: 
  WireCount2(const int& rhs) : WireCount0(rhs) {}
};

int dummy(int argc, char* argv[]) {
    WireCount0 wireCount0(100);
    WireCount1 wireCount1(100);
    WireCount2 wireCount2(100);
    return 0;
}

在上面的代码中,我的WireCount1 wireCount1(100)声明被编译器拒绝("没有匹配函数来调用'WireCount1 :: WireCount1(int)'"),而我wireCount0和wireCount2声明都没问题.

我不确定我理解为什么我需要提供显示的显式构造函数WireCount2.是因为编译器为其生成了默认构造函数WireCount1,并且该构造函数隐藏了WireCount0构造函数？

作为参考,编译器是i686-apple-darwin10-gcc-4.2.1 (GCC) 4.2.1 (Apple Inc. build 5659).

我想bind()从派生类到我的基类的函数版本.该功能在基础中标记为受保护.当我这样做时,代码在Clang(Apple LLVM编译器4.1)中快速编译,但在g ++ 4.7.2和Visual Studio 2010中都出错.错误是:"'Base :: foo':不能访问受保护的成员."

这意味着参考的上下文实际上在bind()其中,当然这个函数被视为受保护.但是不应该bind()继承调用函数的上下文 - 在这种情况下,Derived::foo()- 因此将基本方法看作是可访问的？

以下程序说明了该问题.

struct Base
{
protected: virtual void foo() {}
};

struct Derived : public Base
{
protected:
    virtual void foo() override
    {
        Base::foo();                        // Legal

        auto fn = std::bind( &Derived::foo, 
            std::placeholders::_1 );        // Legal but unwanted.
        fn( this );

        auto fn2 = std::bind( &Base::foo, 
            std::placeholders::_1 );        // ILLEGAL in G++ 4.7.2 and VS2010.
        fn2( this );
    }
};

为什么行为上的差异？哪个是对的？错误提供编译器有哪些可用的解决方法？