我有一个纯虚类，它有一个应该是 const 的纯虚方法，但不幸的是不是。该接口(interface)在一个库中，该类由单独项目中的几个其他类继承。

我试图在不破坏兼容性的情况下(至少在一段时间内)使此方法成为 const，但我找不到在非 const 方法重载时产生警告的方法。

以下是到目前为止我能够生成的示例:

• 第 0 阶段:变革之前。只有 Interface::doSomething() 方法的非常量版本存在，并且它是纯虚拟的。
• 第 1 阶段:过渡期间。 Interface::doSomething() 方法的 const 和非 const 版本都存在。它们都有一个默认实现，以允许旧样式和新样式实现(在这个阶段它们不能是纯虚拟的，因为每个继承类只会覆盖其中一个)。 const 版本调用非常量版本以确保与旧实现的兼容性，非常量版本断言，因为它永远不应该被调用。
• 第 2 阶段:只有 Interface::doSomething() 方法的非 const 版本存在，并且它是纯虚拟的。

在阶段 1 中，我希望能够在类重写 Interface::doSomething() 的非常量版本时发出警告，在为了警告用户他们应该更新他们的代码，所以当我切换到 Stage 2 时，破坏其他人代码的机会非常低。 不幸的是我找不到办法做到这一点。我尝试了几种标志组合，包括 GCC 和 Clang。我唯一能做的就是让编译失败(例如，将其更改为 final)，但这不是我想要处理的方式。有没有办法产生警告？

#include <iostream>
#include <cassert>

class Interface
{
public:
    virtual ~Interface() = default;

// callDoSomething method:
// - stage 0: non const
// - stage 1-2: const
#if (STAGE == 0)
    void callDoSomething() { doSomething(); }
#else
    void callDoSomething() const { doSomething(); }
#endif

protected:

// non-const doSomething() method:
// - stage 0: pure virtual
// - stage 1: virtual with assert in default implementation (should never be called)
// - stage 2: removed
#if (STAGE == 0)
    virtual void doSomething() = 0;
#elif (STAGE == 1)
    [[deprecated("Overload const version instead")]]
    virtual void doSomething()
    {
        assert(false);
    }
#endif

// const doSomething() method
// - stage 0: N/A
// - stage 1: virtual with default implementation (calls the non-const overload)
// - stage 2: pure virtual
#if (STAGE == 1)
    virtual void doSomething() const
    {
        std::cout << __PRETTY_FUNCTION__ << '\n';
        std::cout << "  calling non const version\n";
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
        const_cast<Interface*>(this)->doSomething();
#pragma GCC diagnostic pop
    }
#elif (STAGE == 2)
    virtual void doSomething() const = 0;
#endif
};


// Old style implementation: non-const doSomething()
// Allowed only in stages 0 and 1
#if (STAGE == 0 || STAGE == 1)
class Implementation_old : public Interface
{
public:
    virtual ~Implementation_old() = default;

protected:
    virtual void doSomething() override
    {
        std::cout << __PRETTY_FUNCTION__ << '\n';
    }
};
# endif


// Old style implementation: const doSomething()
// Allowed only in stages 1 and 2
#if (STAGE == 1 || STAGE == 2)
class Implementation_new : public Interface
{
public:
    virtual ~Implementation_new() = default;

protected:
    virtual void doSomething() const override
    {
        std::cout << __PRETTY_FUNCTION__ << '\n';
    }
};
#endif


int main(int argc, char *argv[])
{
    Interface* iface = nullptr;

#if (STAGE == 0 || STAGE == 1)
    iface = new Implementation_old;
    iface->callDoSomething();
    delete iface;
#endif

#if (STAGE == 1)
    std::cout << "-------------------\n";
#endif

#if (STAGE == 1 || STAGE == 2)
    iface = new Implementation_new;
    iface->callDoSomething();
    delete iface;
#endif

    iface = nullptr;

    return 0;
}

这是使用 STAGE 的 3 个定义构建示例的 CMakeLists.txt 文件

cmake_minimum_required(VERSION 3.5)
project(test_deprecate_non_const)

set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_EXTENSIONS OFF)

add_executable(main_stage_0 main.cpp)
target_compile_definitions(main_stage_0 PRIVATE STAGE=0)

add_executable(main_stage_1 main.cpp)
target_compile_definitions(main_stage_1 PRIVATE STAGE=1)

add_executable(main_stage_2 main.cpp)
target_compile_definitions(main_stage_2 PRIVATE STAGE=2)

最佳答案

在使用已弃用的接口(interface)时发出警告会很好。然而，我的尝试和你的一样都失败了。我认为不幸的是，属性在设计时并未考虑到这一点。我认为属性适用于实体的名称，这意味着只有在按名称调用方法时才会收到警告。但是我没有研究这方面的标准。

所以，怀着悲痛的心情，我来偷一个结论this answer到一个稍微相关的帖子:

Tell your users that the function is deprecated and shouldn't be used, then move on.

关于C++:覆盖已弃用的虚拟方法时的弃用警告，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/49011990/