我想和你们分享一个我偶然发现的奇怪的例子，这让我思考了两天。

要让这个例子正常工作，您需要:

• 三角形虚继承(成员函数getAsString())
• 模板类的成员函数特化(此处为 Value<bool>::getAsString())覆盖虚函数
• (自动)由编译器内联

你从一个模板类开始，它实际上继承了一个公共(public)接口(interface)——即一组虚函数。稍后，我们将特化其中一个虚函数。内联可能会导致我们的特化被忽视。

// test1.cpp and test2.cpp
#include <string>

class ValueInterface_common
{
public:
  virtual ~ValueInterface_common() {}
  virtual const std::string getAsString() const=0;
};

template <class T>
class Value :
  virtual public ValueInterface_common
{
public:
  virtual ~Value() {}
  const std::string getAsString() const;
};

template <class T>
inline const std::string Value<T>::getAsString() const
{
  return std::string("other type");
}   

接下来我们要继承这个Value Parameter 中的类和接口(interface)本身也需要模板化的类:

// test1.cpp
template <class T>
class Parameter :
  virtual public Value<T>,
  virtual public ValueInterface_common
{
public:
  virtual ~Parameter() {}
  const std::string getAsString() const;
};

template<typename T>
inline const std::string Parameter<T>::getAsString() const
{
  return Value<T>::getAsString();
}

现在，不要(!)给出 Value 特化的前向声明对于类型等于 bool ...

// NOT in: test1.cpp
template <>
const std::string Value<bool>::getAsString() const;

而是像这样简单地给出它的定义......

// test2.cpp
template <>
const std::string Value<bool>::getAsString() const
{
  return std::string("bool");
}

.. 但在另一个模块中(这很重要)!

最后，我们有一个 main()函数来测试正在发生的事情:

// test1.cpp
#include <iostream>

int main(int argc, char **argv)
{
  ValueInterface_common *paraminterface = new Parameter<bool>();
  Parameter<int> paramint;
  Value<int> valint;
  Value<bool> valbool;
  Parameter<bool> parambool;

  std::cout << "paramint is " << paramint.getAsString() << std::endl;
  std::cout << "parambool is " << parambool.getAsString() << std::endl;
  std::cout << "valint is " << valint.getAsString() << std::endl;
  std::cout << "valbool is " << valbool.getAsString() << std::endl;
  std::cout << "parambool as PI is " << paraminterface->getAsString() << std::endl;

  delete paraminterface;

  return 0;
}

如果您按如下方式编译代码(我将其放入名为 test1.cpp 和 test2.cpp 的两个模块中，后者仅包含特化和必要的声明):

g++ -O3 -g test1.cpp test2.cpp -o test && ./test

输出是

paramint is other type
parambool is other type
valint is other type
valbool is bool
parambool as PI is other type

如果使用 -O0 编译或者只是 -fno-inline - 或者如果您确实给出了特化的前向声明 - 结果变为:

paramint is other type
parambool is bool
valint is other type
valbool is bool
parambool as PI is bool

很有趣，不是吗？

到目前为止，我的解释是:内联在第一个模块 (test.cpp) 中起作用。所需的模板函数被实例化，但一些最终被内联在对 Parameter<bool>::getAsString() 的调用中。 .另一方面，对于 valbool这没有用，但模板被实例化并用作函数。链接器然后找到实例化的模板函数和第二个模块中给出的专用函数，并决定使用后者。

你怎么看？

• 您认为这种行为是错误吗？
• 为什么内联适用于 Parameter<bool>::getAsString()但不适用于 Value<bool>::getAsString()虽然两者都重写了一个虚函数？

最佳答案

我推测您遇到了 ODR 问题，因此猜测为什么某些编译器优化的行为与其他编译器设置不同是没有意义的。

本质上，单一定义规则规定同一实体应 在整个应用程序中具有完全相同的定义，否则 效果未定义。

根本问题是，看不到类模板成员函数的专用版本的代码可能仍然可以编译、链接，有时甚至可以运行。这是因为在没有显式特化(前向声明)的情况下，非特化版本开始出现，可能会实现也适用于您的特化类型的通用功能。

因此，如果您幸运的话，您会收到有关缺少声明/定义的编译器错误，但如果您真的不走运，您会得到“工作”代码，但它并不是您想要的。

修复:始终包含(转发)所有模板特化的声明。最好将它们放在一个 header 中，并包含所有调用您的类的客户端的 header 以获取任何可能的模板参数。

// my_template.hpp
#include "my_template_fwd.hpp"
#include "my_template_primary.hpp"
#include "my_template_spec_some_type.hpp" 

// my_template_fwd.hpp
template<typename> class my_template; // forward declaration of the primary template

// my_template_primary.hpp
#include "my_template_fwd.hpp"
template<typename T> class my_template { /* full definition */ };

// my_template_spec_some_type.hpp
#include "my_template_fwd.hpp"
template<> class my_template<some_type> { /* full definition */ };

// some_client_module.hpp
#include "my_template.hpp" // no ODR possible, compiler will always see unique definition

显然，您可以通过为模板特化创建子目录并相应地更改包含路径来重新组织命名。

关于c++ - 内联导致覆盖虚函数的模板类的专门成员函数被忽略，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/14264855/