确保编译时的调用方法

Ensuring a call method at compile time

本文关键字：调用 方法 编译 确保      更新时间：2023-10-16

如何确保在编译时调用特定方法？

例如，假设我有一个包含 2 个方法的对象：

struct Foo
{
   ... func1(...);
   ... func2(...);
};

我想确保在调用 func2 之前调用 func1，即：

int main()
{
   Foo f;
   ...
   f.func1(...);
   f.func2(...);
   f.func2(...); // and so on
}

但是如果我做这样的事情，我想生成编译错误：

int main()
{
   Foo f;
   ...
   f.func2(...);  // generate a compile error due the fact that func1 must be called first
   f.func1(...);
   f.func2(...); // and so on
}

虽然很好奇为什么要这样做，但一般注意事项是您必须向用户公开一个不能错误使用的界面。胆量私有化：

struct Foo
{
public:
    void callme()
    {
        func1();
        func2();
    }
private:
    ... func1(...);
    ... func2(...);

};
int main()
{
    Foo f;
    f.callme();
}

如果需要强制一次性初始化对象，请在构造函数中执行此操作：

struct Foo
{
public:
    Foo()
    {
        func1();
    }
    func2(...);
private:
    ... func1(...);
};
int main()
{
    Foo f; // func1() called automagically
    f.func2();
}

在设计类接口时，你必须考虑最糟糕的事情：用户从不阅读文档，用户总是忘记调用foo.initialize()，用户总是忘记释放内存和泄漏，等等。

在

编译时没有真正的方法来强制执行。 这是对象本身需要通过运行时检查强制执行的<</p>

div class="answers> 我想

到的一个方法是让返回 func1（） 一个对象，它的作用类似于 func2（） 的代理：

class Foo {
public:
    Proxy func1();   
private:
    void func2();
    friend class Proxy;
};
class Proxy {
private:
    explicit Proxy(Foo& f) : f_(f) {}
public:
    void func2() {
        f_.func2();
    }
    friend class Foo;
};
Foo f;
f.func1().func2();

另一种方法（也是我最喜欢的）是让 func1（） 成为构造函数或使用另一个类，在其构造函数中调用 func1（）：

class Foo
{
private:
    void func1(), func2();
    friend class FooUser;
};
class FooUser
{
public:
    explicit Proxy(FooUser& f) : f_(f) {
        f.func1();
    }
    void func2() {
        f_.func2();
    }
};

编译器无法强制执行函数调用的顺序，因为通常只能在运行时确定。但它可以在使用对象之前强制对象初始化。因此，获得编译时检查的最佳方法是执行func1在构造函数中执行的任何操作 - Foo构造函数的一部分，或者您需要创建的帮助程序对象才能调用func2。

我真的不建议这样做，但是如果您需要它进行调试，可以尝试以下操作。将每个调用 func1（） 更改为

#define FLAG
func1();

和 func2（） 到

#ifdef FLAG
func2();
#else
#error func1 should be called first!
#endif

因此，如果 func2（） 将在文本中提到，则 func1，您将收到编译时错误。这并不意味着在执行过程中会更早地调用它。

相关文章：