"虚拟"继承的含义是什么？
我看到以下代码,并且virtual在以下上下文中不理解关键字的含义:
class A {};
class B : public virtual A;
class Base{
public:
void counter();
....
}
class Dervied: public Base{
public:
....
}
void main()
{
Base *ptr=new Derived;
ptr->counter();
}
为了识别基类指针指向派生类并使用派生成员函数,我们使用"虚拟".
同样,我们可以使派生数据成员"虚拟"吗？(数据成员是公开的)
我有一个关于c ++中虚拟继承的问题:
class A {
};
class B: virtual public A {
};
class C: virtual public A {
};
class D: public B,public C, virtual public A {
};
如果D继承B和C虚拟继承可以确保D中只包含一个A副本,那么D再次使用虚拟公共A继承A,就像上面的代码一样？
那么A类子对象的数量是1还是2？
好的,谢谢你的答案,我理解.但我仍然把一些表达与虚拟继承混淆.例如:
#include <iostream>
using namespace std;
class A {
public:
A() {std::cout<<"A ";}
};
class B: A {
public:
B() {std::cout<<"B ";}
};
class AToo: virtual A {
public:
AToo() {
std::cout<<"AToo ";
}
};
class ATooB: virtual AToo, virtual B {
public:
ATooB() {
std::cout<<"ATooB ";
} …我有一个抽象基类Node，它是从抽象Interface类派生的IObservable。有几个实现抽象的类IObservable：SingleObservable和MultiObservable
我想创建一个ObservableNode从基Node类派生的类，并在其声明中指定用于IObservable接口实现的类。
我已经using ...为IObservable实现类中的每个方法添加了每个纯虚方法的语句，但仍然收到错误消息，说这ObservableNode是一个抽象类，缺少的实现notifyObservers(IObject*)。
如果将参数添加IObject*到using语句中，则会得到“期望的';'” 在'（'令牌“错误之前
我该如何解决？
class IObservable {
public:
virtual ~IObservable() {};
virtual void notifyObservers(IObject*) = 0;
};
class SingleObservable: public IObservable {
public:
virtual ~SingleObservable() {};
void notifyObservers(IObject*) override {
//some implementaiton
};
};
class MultiObservable: public IObservable {
public:
virtual ~MultiObservable() {};
void notifyObservers(IObject*) override {
//some other implementaiton …当"虚拟"在"Foo类:公共虚拟栏"中而不是"虚拟空白frob()"时,它意味着什么？
对于给定的方法,有8个案例源于以下三个位置存在或不存在虚拟.
我想我理解数字1和3如何相互作用,但数字2似乎是多余的.是吗？我不明白的是什么？
#include <iostream>
using namespace std;
class Empty
{};
class Derived : virtual public Empty
{
char c;
};
int main()
{
cout << "sizeof(Empty) " << sizeof(Empty) << endl;
cout << "sizeof(Derived) " << sizeof(Derived) << endl;
return 0;
}
为什么尺寸即将到来8我认为它应该是9,如果我将'c'声明为整数然后它即将到来的8 Cany你请解释我的逻辑
为什么打印20000？代码在继承序列中一直显式调用特定的基础构造函数,但忽略指定的构造函数并使用默认构造函数.
#include <iostream>
struct Car
{
Car() : price(20000) {}
Car(double b) : price(b*1.1) {}
double price;
};
struct Toyota : public virtual Car
{
Toyota(double b) : Car(b) {}
};
struct Prius : public Toyota
{
Prius(double b) : Toyota(b) {}
};
int main(int argc, char** argv)
{
Prius p(30000);
std::cout << p.price << std::endl;
return 0;
}
(这是关于未定义行为(UB)的另一个问题.如果这个代码在某些编译器上"起作用",那么在UB的土地上就没有任何意义.这是可以理解的.但正好在下面的哪一行我们会进入UB？)
(关于SO已经有很多非常相似的问题了,例如(1) 但是我很好奇在取消引用它们之前可以用指针安全地完成什么.)
从一个非常简单的Base类开始.没virtual办法.没有继承.(也许这可以扩展到任何POD？)
struct Base {
int first;
double second;
};
然后是一个简单的扩展,添加(非virtual)方法,不添加任何成员.没有virtual继承.
struct Derived : public Base {
int foo() { return first; }
int bar() { return second; }
};
然后,考虑以下几行.如果与定义的行为有一些偏差,我很想知道确切地知道哪些行.我的猜测是我们可以安全地对指针执行大部分计算.是否有可能这些指针计算中的一些,如果没有完全定义,至少会给我们某种"不确定/未指定/实现定义"的值,这些值并非完全没用？
void foo () {
Base b;
void * vp = &b; // (1) Defined behaviour?
cout << vp << endl; // (2) I hope this isn't a 'trap value'
cout << &b << endl; // (3a) Prints the same as …在现代C++中是否有一种方法可以防止类被虚拟继承,同时允许定期继承？现在对我来说似乎不可能,但这种语言中有太多东西似乎是不可能的.