C++菱形问题 - 如何仅调用一次基方法

这很可能是一个 XY 问题。但。。。只是不要叫它两次。

#include <iostream>
class Creature
{
public:
virtual void identify()
{
std::cout << "I'm a creature" << std::endl;
}
};
class Swimmer : public virtual Creature
{
public:
virtual void identify() override
{
Creature::identify();
tell_ability();
std::cout << "I'm a swimmern";
}
virtual void tell_ability()
{
std::cout << "I can swimn";
}
};
class Flier : public virtual Creature
{
public:
virtual void identify() override
{
Creature::identify();
tell_ability();
std::cout << "I'm a fliern";
}
virtual void tell_ability()
{
std::cout << "I can flyn";
}
};
class Duck : public Flier, public Swimmer
{
public:
virtual void tell_ability() override
{
Flier::tell_ability();
Swimmer::tell_ability();
}
virtual void identify() override
{
Creature::identify();
tell_ability();
std::cout << "I'm a duckn";
}
};
int main()
{
Creature c;
c.identify();
std::cout << "------------------n";
Swimmer s;
s.identify();
std::cout << "------------------n";
Flier f;
f.identify();
std::cout << "------------------n";
Duck d;
d.identify();
std::cout << "------------------n";
}

输出：

I'm a creature
------------------
I'm a creature
I can swim
I'm a swimmer
------------------
I'm a creature
I can fly
I'm a flier
------------------
I'm a creature
I can fly
I can swim
I'm a duck
------------------

我们可以让基类跟踪属性：

#include <iostream>
#include <string>
#include <vector>
using namespace std::string_literals;
class Creature
{
public:
std::string const attribute{"I'm a creature"s};
std::vector<std::string> attributes{attribute};
virtual void print()
{
for (auto& i : attributes)
std::cout << i << std::endl;
}
};
class Swimmer : public virtual Creature
{
public:
Swimmer() { attributes.push_back(attribute); }
std::string const attribute{"I can swim"s};
};
class Flier : public virtual Creature
{
public:
Flier() { attributes.push_back(attribute); }
std::string const attribute{"I can fly"s};
};
class Duck : public Flier, public Swimmer
{
public:
Duck() { attributes.push_back(attribute); }
std::string const attribute{"I'm a duck"s};
};
int main()
{
Duck d;
d.print();
}

同样，如果我们追求的不仅仅是打印，而是函数调用，那么我们可以让基类跟踪函数：

#include <iostream>
#include <functional>
#include <vector>
class Creature
{
public:
std::vector<std::function<void()>> print_functions{[this] {Creature::print_this(); }};
virtual void print_this()
{
std::cout << "I'm a creature" << std::endl;
}
void print()
{
for (auto& f : print_functions)
f();
}
};
class Swimmer : public virtual Creature
{
public:
Swimmer() { print_functions.push_back([this] {Swimmer::print_this(); }); }
void print_this()
{
std::cout << "I can swim" << std::endl;
}
};
class Flier : public virtual Creature
{
public:
Flier() { print_functions.push_back([this] {Flier::print_this(); }); }
void print_this()
{
std::cout << "I can fly" << std::endl;
}
};
class Duck : public Flier, public Swimmer
{
public:
Duck() { print_functions.push_back([this] {Duck::print_this(); }); }
void print_this()
{
std::cout << "I'm a duck" << std::endl;
}
};
int main()
{
Duck d;
d.print();
}

一个简单的方法是创建一堆帮助程序类，这些类模仿主层次结构的继承结构，并在其构造函数中执行所有打印。

struct CreaturePrinter {
CreaturePrinter() { 
std::cout << "I'm a creaturen";
}
};
struct FlierPrinter: virtual CreaturePrinter ... 
struct SwimmerPrinter: virtual CreaturePrinter ...
struct DuckPrinter: FlierPrinter, SwimmerPrinter ...

然后，主层次结构中的每个打印方法只创建相应的帮助程序类。 无需手动链接。

为了便于维护，您可以将每个打印机类嵌套在其相应的主类中。

当然，在大多数现实世界中，您希望将对主对象的引用作为参数传递给其帮助程序的构造函数。

您对print方法的显式调用构成了问题的症结所在。

一种方法是放弃print调用，并用 say 替换它们。

void queue(std::set<std::string>& data)

您将打印消息累积到set中.然后，层次结构中的这些函数被多次调用并不重要。

然后，在Creature中以单个方法实现集的打印。

如果要保留打印顺序，则需要将set替换为另一个遵循插入顺序并拒绝重复项的容器。

如果你想要那个中产阶级方法，不要调用基类方法。最简单和最简单的方法是提取额外的方法，然后重新实现Print很容易。

class Creature
{
public:
virtual void print()
{
std::cout << "I'm a creature" << std::endl;
}
};
class Swimmer : public virtual Creature
{
public:
void print()
{
Creature::print();
detailPrint();
}
void detailPrint()
{
std::cout << "I can swim" << std::endl;
}
};
class Flier : public virtual Creature
{
public:
void print()
{
Creature::print();
detailPrint();
}
void detailPrint()
{
std::cout << "I can fly" << std::endl;
}
};
class Duck : public Flier, public Swimmer
{
public:
void print()
{
Creature::Print();
Flier::detailPrint();
Swimmer::detailPrint();
detailPrint();
}
void detailPrint()
{
std::cout << "I'm a duck" << std::endl;
}
};

没有细节，你的实际问题是什么，很难想出更好的解决方案。

使用：

template<typename Base, typename Derived>
bool is_dominant_descendant(Derived * x) {
return std::abs(
std::distance(
static_cast<char*>(static_cast<void*>(x)),
static_cast<char*>(static_cast<void*>(dynamic_cast<Base*>(x)))
)
) <= sizeof(Derived);
};
class Creature
{
public:
virtual void print()
{
std::cout << "I'm a creature" << std::endl;
}
};
class Walker : public virtual Creature
{
public:
void print()
{
if (is_dominant_descendant<Creature>(this))
Creature::print();
std::cout << "I can walk" << std::endl;
}
};
class Swimmer : public virtual Creature
{
public:
void print()
{
if (is_dominant_descendant<Creature>(this))
Creature::print();
std::cout << "I can swim" << std::endl;
}
};
class Flier : public virtual Creature
{
public:
void print()
{
if (is_dominant_descendant<Creature>(this))
Creature::print();
std::cout << "I can fly" << std::endl;
}
};
class Duck : public Flier, public Swimmer, public Walker
{
public:
void print()
{
Walker::print();
Swimmer::print();
Flier::print();
std::cout << "I'm a duck" << std::endl;
}
};

在Visual Studio 2015中，输出为：

I'm a creature
I can walk
I can swim
I can fly
I'm a duck

但是is_dominant_descendant没有可移植的定义。我希望这是一个标准概念。

您要求在函数级别上自动调用继承的函数并添加更多代码之类的东西。此外，您希望它以虚拟方式完成，就像类继承一样。伪语法：

class Swimmer : public virtual Creature
{
public:
// Virtually inherit from Creature::print and extend it by another line of code
void print() : virtual Creature::print()
{
std::cout << "I can swim" << std::endl;
}
};
class Flier : public virtual Creature
{
public:
// Virtually inherit from Creature::print and extend it by another line of code
void print() : virtual Creature::print()
{
std::cout << "I can fly" << std::endl;
}
};
class Duck : public Flier, public Swimmer
{
public:
// Inherit from both prints. As they were created using "virtual function inheritance",
// this will "mix" them just like in virtual class inheritance
void print() : Flier::print(), Swimmer::print()
{
std::cout << "I'm a duck" << std::endl;
}
};

所以你的问题的答案

有没有一些内置的方法可以做到这一点？

是否定的。这样的东西在C++中是不存在的。另外，我不知道任何其他语言有这样的东西。但这是一个有趣的想法...