标签: inheritance

为什么这段代码:

class A
{
    public: 
        explicit A(int x) {}
};

class B: public A
{
};

int main(void)
{
    B *b = new B(5);
    delete b;
}

导致这些错误:

main.cpp: In function ‘int main()’:
main.cpp:13: error: no matching function for call to ‘B::B(int)’
main.cpp:8: note: candidates are: B::B()
main.cpp:8: note:                 B::B(const B&)

B不应该继承A的构造函数吗？

(这是使用gcc)

在JavaScript中,每个对象都是实例和类.要进行继承,可以使用任何对象实例作为原型.

在Python,C++等中,有类和实例作为单独的概念.为了进行继承,您必须使用基类来创建一个新类,然后可以使用它来生成派生实例.

为什么JavaScript会朝这个方向发展(基于原型的面向对象)？基于原型的OO相对于传统的,基于类的OO有哪些优点(和缺点)？

在模块中,控制器可以从外部控制器继承属性:

var app = angular.module('angularjs-starter', []);

var ParentCtrl = function ($scope, $location) {
};

app.controller('ChildCtrl', function($scope, $injector) {
  $injector.invoke(ParentCtrl, this, {$scope: $scope});
});

示例:死链接:http://blog.omkarpatil.com/2013/02/controller-inheritance-in-angularjs.html

模块内的控制器也可以继承兄弟姐妹吗？

var app = angular.module('angularjs-starter', []);

app.controller('ParentCtrl ', function($scope) {
  //I'm the sibling, but want to act as parent
});

app.controller('ChildCtrl', function($scope, $injector) {
  $injector.invoke(ParentCtrl, this, {$scope: $scope}); //This does not work
});

第二个代码不起作用,因为$injector.invoke需要一个函数作为第一个参数,并且找不到引用ParentCtrl.

我需要在PHP中使用类构造函数调用其父级的父级(祖父级？)构造函数而不调用父构造函数.

// main class that everything inherits
class Grandpa 
{
    public function __construct()
    {

    }

}

class Papa extends Grandpa
{
    public function __construct()
    {
        // call Grandpa's constructor
        parent::__construct();
    }
}

class Kiddo extends Papa
{
    public function __construct()
    {
        // THIS IS WHERE I NEED TO CALL GRANDPA'S
        // CONSTRUCTOR AND NOT PAPA'S
    }
}

我知道这是一件很奇怪的事情,我试图找到一种味道并不难闻的手段但是,我很好奇是否有可能.

编辑

我想我应该发布所选答案的理由.原因是; 它是最优雅的解决方案,希望在保留所有值的同时调用"祖父母"的构造函数.它当然不是最好的方法,也不是OOP友好的,但这不是问题的问题.

对于以后遇到此问题的任何人 - 请找到另一种解决方案.我能够找到一种更好的方法,不会对类结构造成严重破坏.你也应该这样.

组成和继承是一样的吗？如果我想实现组合模式,我该如何在Java中实现？

我得到一些我无法弄清楚的错误.任何线索我的示例代码有什么问题？

class B:
    def meth(self, arg):
        print arg

class C(B):
    def meth(self, arg):
        super(C, self).meth(arg)

print C().meth(1)

我从"超级"内置方法的帮助下得到了示例测试代码."C"级是

这是错误:

Traceback (most recent call last):
  File "./test.py", line 10, in ?
    print C().meth(1)
  File "./test.py", line 8, in meth
    super(C, self).meth(arg)
TypeError: super() argument 1 must be type, not classobj

仅供参考,这是来自python本身的帮助(超级):

Help on class super in module __builtin__:

class super(object)
 |  super(type) -> unbound super object
 |  super(type, obj) -> bound super object; requires isinstance(obj, type)
 |  super(type, type2) -> bound …

如果下面的类不是模板,我可以简单地x在derived课堂上.但是,使用下面的代码,我必须使用this->x.为什么？

template <typename T>
class base {

protected:
    int x;
};

template <typename T>
class derived : public base<T> {

public:
    int f() { return this->x; }
};

int main() {
    derived<int> d;
    d.f();
    return 0;
}

好吧,这真的很难承认,但我现在确实有很强的诱惑力来继承std::vector.

我需要大约10个定制的矢量算法,我希望它们直接成为矢量的成员.但我自然也希望拥有剩下std::vector的界面.好吧,作为一个守法的公民,我的第一个想法是std::vector在MyVector课堂上有一个成员.但是我必须手动重新编写所有std :: vector的接口.打字太多了.接下来,我考虑了私有继承,所以我不会using std::vector::member在公共部分写一些方法而不是重新提取方法.实际上这也很乏味.

在这里,我确实认为我可以简单地从公开继承std::vector,但在文档中提供警告,不应该多态地使用此类.我认为大多数开发人员都有足够的能力去理解这不应该以多态方式使用.

我的决定绝对没有道理吗？如果是这样,为什么？你能提供一个替代方案,其他成员实际上是成员,但不会涉及重新输入所有vector的界面吗？我对此表示怀疑,但如果可以,我会很高兴.

此外,除了一些白痴可以写类似的事实

std::vector<int>* p  = new MyVector

使用MyVector 有任何其他现实危险吗？通过说现实,我放弃像想象一个带有指向矢量的指针的函数...

好吧,我已经陈述了我的情况.我犯罪了.现在由你来原谅我了不起:)

想象一下具有许多构造函数和虚方法的基类

public class Foo
{
   ...
   public Foo() {...}
   public Foo(int i) {...}
   ...
   public virtual void SomethingElse() {...}
   ...
}

现在我想创建一个覆盖虚方法的后代类:

public class Bar : Foo 
{
   public override void SomethingElse() {...}
}

而另一个后代做了更多的东西:

public class Bah : Bar
{
   public void DoMoreStuff() {...}
}

我是否真的必须将所有构造函数从Foo复制到Bar和Bah？然后,如果我在Foo中更改构造函数签名,我是否必须在Bar和Bah中更新它？

有没有办法继承构造函数？有没有办法鼓励代码重用？

我想知道为什么java构造函数不会被继承？你知道什么时候有这样的课:

public class Super {

  public Super(ServiceA serviceA, ServiceB serviceB, ServiceC serviceC){
    this.serviceA = serviceA;
    //etc
  } 

}

稍后当你继承时Super,java会抱怨没有定义默认的构造函数.解决方案显然是这样的:

public class Son extends Super{

  public Son(ServiceA serviceA, ServiceB serviceB, ServiceC serviceC){
    super(serviceA,serviceB,serviceC);
  }

}

这段代码是重复的,而不是干的和无用的(恕我直言)...所以这又带来了问题:

为什么java不支持构造函数继承？不允许这种继承有什么好处吗？