可能重复:
示例:
abstract public class AbstractDemo
{
private int ab;
public AbstractDemo()
{
ab=10;
}
public int getAb()
{
return ab;
}
public void abstractMethod()
{
//On the line below it gives error.
AbstractDemo demo=new Abstra
我试图理解这个pdf: (第61-62页)中类的类定义。下面是代码中我有问题的部分。以下是头文件:
#ifndef _TERM_STRUCTURE_CLASS_INTERPOLATED_
#define _TERM_STRUCTURE_CLASS_INTERPOLATED_
#include "term_structure_class.h"
#include <vector>
using namespace std;
class term_structure_class_interpolated : public term_structure_class {
p
我正试图完成上一个问题中描述的同样的事情:
但是,我真正的问题是:
如果f()是基类中的构造函数,怎么办?哪个g()将被调用?我不知道我是否做错了,但在我的程序中,情况似乎正好相反。
从前面的问题中提取相同的变量,一个代码显示如下
行为将如下所示:
Class Base
{
Base(){g();};
virtual void g(){//Do some Base related code;}
};
Class Derived : public Base
{
Derived(){};
virtual void g(){//Do
class A : public B
{
...
}
// case I : explicitly call the base class default constructor
A::A() : B()
{
...
}
// case II : don't call the base class default constructor
A::A() // : B()
{
...
}
情况二是否等于情况一?
对我来说,我假设基类B的默认构造函数在第二种情况下没有被调用。然而,尽管仍然持有这个假设,我已经运行了一个测试,证明了不同的情况:
class B
{
public
当我试图用一种常见的方式--使用虚拟继承--来“解决”通常的钻石问题时,出现了一个奇怪的问题:
A
/ \* both virtual
B C
\ /
D
然而,我的基类A没有默认构造函数,所以我从D手动调用它。然而,当我试图将一个类E添加到这个菱形中作为C继承时
A
/ \* both virtual
B C
\ / \
D E
仍然需要在E构造函数中手动调用A的构造函数,即C不需要从E创建A,即使没有多重继承也没有钻石A-C-E。
class A
{public:
A (int _N): N(
当时我正在阅读谷歌C++风格指南( Google ),并在部分感到困惑。在构造函数中做大量工作的缺点之一是:
如果工作调用虚拟函数,这些调用将不会被分派到子类实现。将来对类的修改可以悄悄地引入这个问题,即使您的类当前没有子类,也会造成许多混乱。
我不明白这意味着什么。有人能给出一个解释吗?为什么这会被认为是一种劣势?
可能重复:
看看这段代码。在基类的构造函数中,我们可以使用'this‘指针调用纯虚函数。现在,当我想要创建指向同一类的类型化指针并将“this”转换为同一类型时。它抛出运行时异常“纯虚拟函数调用异常”。为什么会这样?
#include <iostream>
using namespace std;
class Base
{
private:
virtual void foo() = 0;
public:
Base()
{
//Uncomment below 2 lines and it doesn't work (run tim
我对OOP比较陌生,所以想澄清几件事,
我有下面的代码
class Parent
{
public Parent()
{
Console.WriteLine("Parent Class constructor");
}
public void Print()
{
Console.WriteLine("Parent->Print()");
}
}
class Child : Parent
{
public Child()
{
按照标准,我们知道构造函数总是倾向于早期绑定它们内部的虚拟函数,因为它们不完全了解派生类层次结构的缺点。
在本例中,如果在基本构造函数中使用早期绑定,则将派生对象传递给一个完全可接受的基类指针(在这里完成向上转换)。如果使用早期绑定,则虚拟函数的选择应该基于指针的类型(这里是Base *),而不是指针的内容(指针所指向的对象,因为我们不知道所指向的确切对象)。在这种情况下,由于指针类型是Base *,在这两种情况下,我们都应该只调用基类虚拟函数。有谁能澄清一下吗?
我认为这里使用的是动态绑定,而不是早期绑定。如果我的理解有误,请纠正我。
调用基类的输出的第一行是完全正确的。
class Bas
class ClassA {
public:
ClassA() {} // when this function must be provided
virtual ~ClassA() = 0 {}
};
class ClassB : public ClassA
{
// ...
};
我想知道什么时候必须提供抽象基类的默认构造函数。
假设B和C是从A派生的。我希望能够测试从A派生的任何两个类实例是否是同一个类的实例,也就是说,A* foo和A* bar是否都指向B实例,而不使用RTTI。我目前的解决方案如下:
class A {
protected:
typedef uintptr_t Code;
virtual Code code() const = 0;
}; // class A
class B : public A {
protected:
virtual Code code() const { return Code(&identity); }
private:
可能重复:
如果我尝试这样做,你知道为什么会出现错误吗:
public class Bar
{
public Bar(Foo foo)
{
}
}
public class Foo
{
private Bar _bar = new Bar(this);
}
我收到一个错误,说:
“不能在成员初始值设定项中使用'this‘”
但是下面的方法是可行的:
public class Foo
{
private Bar _bar;
public Foo()
{
_bar = new Bar(this);
}
我知道我们不能创建抽象类实例,但我不明白为什么可以使用base调用抽象类的构造函数。
abstract class Fruit
{
public string Name { get; private set; }
public Fruit(string name)
{
Name = name;
}
}
class Apple : Fruit
{
public Apple(string name) : base(name) { }
}
Fruit f = new Fruit("Fruit"); // Coimple
public class Base {
public Base() {
foo();
}
public void foo() {
System.out.println("Base.foo()");
}
}
public class Derived extends Base {
public Derived () {}
public void foo() {
System.out.println("Derived.foo()");
}
}
然后,当我称之为:
public class Running {
p