假设我没有使用多重继承或虚拟继承,C++标准是否保证如果我将Derived*转换为Base*,两个指针将具有完全相同的值?例如,即使Derived和/或Base具有虚函数,以下代码是否始终调用success()?
Derived* d = new Derived;
Base* b = d;
if (((void*)b) == ((void*)d))
success();
else
failure();
我想使用C++11 override说明符,并注意到它可以与virtual一起使用。这有什么不同吗?考虑以下类:
class Base
{
virtual void fct() = 0;
};
class Derived1 : public Base
{
void fct() override {}
};
class Derived2 : public Base
{
virtual void fct() override {}
};
Derived1和Derived2在技术上有区别吗?
在C#中,基类的虚方法可以被它的派生类覆盖或隐藏,例如
using System;
class A {
public virtual void M() {
System.Console.WriteLine("A");
}
}
class B: A {
public override void M() {
System.Console.WriteLine("B");
}
}
class C: A {
public new void M() {
System.Console.WriteLine("C");
}
}
cl
public class Shapes
{
public virtual void Color()
{
Console.WriteLine("Shapes");
}
}
public class Square : Shapes
{
public void Color()
{
Console.WriteLine("Square");
}
}
public class Test
{
public static void main()
{
Shapes s1 = new Shapes();
s1.C
class a //my base class
{
public:
a()
{
foo();
}
virtual void foo() = 0;
};
class b : public a
{
public:
void foo()
{
}
};
int main()
{
b obj; //ERROR: undefined reference to a::foo()
}
为什么它会给我错误?定义了纯虚拟foo。我需要在代码中进行哪些更改才能使其正常工作?我需要在它的构造函数中调用来自基类的纯虚方法。
当我运行这段代码时,由于后期绑定的原因,输出如预期的那样是"This is due 2“,因为我们在基类中使用了虚函数。
#include <iostream>
using namespace std;
class Base {
public :
virtual void show() {
cout<<"This is base class"<<endl;
}
};
class Derived : public Bas
如果我从A派生B,从B派生C,如下所示:
A
|
B
|
C
我很可能在A中有一个或多个虚函数。现在,我意外地忘记了在B的函数声明中放入关键字virtual。但令我惊讶的是,它的工作原理就像在B中也设置了virtual一样:
#include <iostream>
using std::cout;
using std::endl;
class A
{
public:
virtual void foo(){cout << "A\n";};
};
class B : public A
{
public:
void foo(){cout
当至少有一个类方法是虚的时,每个人都说析构函数应该是虚的。
我的问题是,在使用向上转换时,析构函数应该是虚拟的,这不是正确的吗?
class A {
public:
~A(){
cout << "Destructor in A" << endl;
}
};
class B: public A
{
public:
~B(){
cout << "Destructor in B" << endl;
}
};
int main()
{
A* a
考虑下面的代码片段:
class BaseClass
{
public void SayHi()
{
Console.WriteLine("Hi from base class");
}
public virtual void SayHello()
{
Console.WriteLine("Hello from base class");
}
}
class DerivedClass : BaseClass
{
public void SayHi()
{
我在派生类中有一个函数d(),它将在基类函数b()中调用。我试图通过在基类中创建一个具有相同名称的虚函数来做到这一点(以满足编译器并强制执行后期绑定)。我将始终使用派生类的对象调用b()。但问题是编译进行得很好,但链接器返回一个错误:
undefined symbol <baseclass_name>::d in module main.cpp
奇怪的是,d()甚至没有在main.cpp中被调用。它在另一个文件中定义和调用。
我被困在这里了。有人能给出任何可能的解释或建议一个更好的方法吗?
(我需要从基类调用d(),否则它会使我的代码更加庞大……)
我正在尝试做的是创建一个基类,从它派生的任何东西都将自动注册到另一个类,例如:
class System;
class Object
{
public:
Object()
{
System sys;
sys.AddObject(this);
}
virtual ~Object()
{
System sys;
sys.RemoveObject(this);
}
};
class System
{
public:
// Some other processing function
当我试图用一种常见的方式--使用虚拟继承--来“解决”通常的钻石问题时,出现了一个奇怪的问题:
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(
我认为解释我的问题的最简单的方法是展示一个简单的例子来说明我正在尝试做的事情。
我正在使用一个有基类的库作为例子,如下所示。
class base {
void function();
}
现在,派生类是库的一部分,所有派生类都包含相同的函数。
class derived1 : public base {
void derivedFunction();
}
class derived2 : public base {
void derivedFuction();
}
在我创建的函数中,我定义了几个派生类,并构建了一个包含基类的结构。然后,我在数组中设置了几个值,