我有以下接口(interface):

class T {
public:
    // Called in parallel
    virtual unsigned validate () = 0;

    // Called with a lock taken out
    virtual unsigned update () = 0;
};

template <typename DataType>
class Cache {
public:
    // Gets the requested object.
    // If it doesn't exist in memory, go to SQL.
    unsigned fetch (DataType &data);


    // Gets the requested object.
    // If it's not in memory, returns NOT_FOUND.
    unsigned find (DataType &data);
};

我想要实现的目标: 如果在 update 期间调用了 fetch，我希望能够使编译失败。实际上，我想根据调用站点静态禁用该功能。类似的东西，

std::enable_if <callsite_is_not_implementation_of_T_update, unsigned> 
fetch (DataType &data);

用法是这样的:

class A_T : public T {
public:
    virtual unsigned validate () {
        global_cache.fetch (object); // OK
    }

    virtual unsigned update () {
        global_cache.find (object); // Also OK

        global_cache.fetch (object); // FAIL!
    }
};

背景

在我的项目中大约有 500 个 T 的实现。

应用程序在许多线程中循环，并为许多 T 实例并行调用 validate。然后取出全局锁，调用update。因此，更新的速度至关重要。一般的态度是在 validate 期间花费您需要的任何时间，但 update 应该尽可能精简。

我的问题与缓存的使用有关。 Cache 基本上是来自 SQL 的数据对象的内存缓存。

策略是永远不要在 update 期间调用 Cache::fetch，因为在持有锁的同时可能存在 SQL 往返。我们都在努力在团队中培养这种心态。不幸的是，其中一些仍然潜入，并通过了代码审查。我们只有在系统负载很重并且一切都停止时才会注意到它们。

我想建立一个安全网，防止这种事情发生。如果从 T::update 调用 Cache::fetch，我想要实现的是让编译失败。

我不介意它是否可以变通。关键是把它作为障碍；唯一可能犯错的方法就是故意犯错。

到目前为止我得到了什么

我已经做到了一点点，虽然不是我真正想要的。例如，我宁愿不必更改对 fetch 的每次调用。

template <typename Impl>
class cache_key  {
    cache_key() { }
    friend unsigned Impl::validate();
};

#define CACHE_KEY cache_key<std::remove_pointer<decltype(this)>::type> ()

所以现在 Cache::fetch 看起来像:

unsigned fetch (DataType &object, const cache_key &key);

T 的实现可能如下所示:

class A_T : public T {
public:
    virtual unsigned validate () {
        global_cache.fetch (object, CACHE_KEY); // OK
    }

    virtual unsigned update () {
        global_cache.fetch (object, CACHE_KEY); // Can't do it!
    }
};

最佳答案

我不知道编译时错误的生成，但可以通过仅更新基类来生成运行时错误。

一种方法是通过基类中的非虚拟代理函数调用更新，这会将状态设置为基类以检测我们正在更新，因此不应调用 fetch。

class updateWatcher()
{
public:
updateWatcher(bool *valIn) : val(valIn) {*val=true;}
~updateWatcher() {*val=false;}
private:
bool* val;
}

class T {
public:
    // Called in parallel
    virtual unsigned validate () = 0;

    unsigned updateProxy()
    {
         updateWatcher(&inUpdate); //exception safe tracker we are in update
         return update();
    }

    void
protected:
    // Called with a lock taken out
    virtual unsigned update () = 0;

    bool inUpdate; // tells if we are in update or not
};

class A_T : public T {

public:
    virtual unsigned validate () {
        global_cache.fetch (object,inUpdate); // OK
    }

    virtual unsigned update () {
        global_cache.find (object); // Also OK

        global_cache.fetch (object,inUpdate); // FAIL (put assert in global_cache.fetch) !
    }
};

这不会产生编译但会产生运行时错误，好处是不需要更新任何实现(除了将所有 global_cache.fetch(...); 替换为 global_cache.fetch(...,inUpdate);并调用 update() 到 updateProxy(); 在所有实现中，都可以有效地自动化)。 然后，您可以将一些自动化测试集成为构建环境的一部分以捕获断言。

关于c++ - 我可以静态地阻止一个函数调用另一个函数吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/20896265/