Обеспечение метода вызова во время компиляции

Question

Как я могу гарантировать, что будет вызван конкретный метод во время компиляции?

Например, предположим, что у меня есть объект с 2-мя методами:

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

и я хочу, чтобы убедиться, что func1 вызывается перед вызовом func2, то есть:

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 
} 

Answer 1

Нет реального способа обеспечить соблюдение t его во время компиляции. Это то, что сам объект должен будет обеспечивать с помощью контроля времени выполнения

Answer 2

Хотя любопытно, почему вы это делаете, общее замечание, что вы должны подвергать пользователя интерфейс, который не может быть использован неправильно. Кишки идут частные:

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(), пользователи всегда забывают освободить память и утечки и т. д.

Answer 3

Один из способов, который приходит на ум, состоит в том, чтобы вернуть 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(); 
    } 
}; 

Answer 4

Компилятор может t обеспечить соблюдение порядка вызовов функций, поскольку в целом это можно определить только во время выполнения. Но он может обеспечить инициализацию объекта до того, как объект будет использоваться. Таким образом, лучший способ получить проверку времени компиляции - сделать то, что делает func1 в конструкторе - либо часть конструктора Foo, либо вспомогательный объект, который необходимо создать для вызова func2.

Answer 5

Я действительно не предлагаю это сделать, но если вам это нужно в целях отладки, вы можете попробовать следовать. Изменить каждый вызов func1() для

#define FLAG 
func1(); 

и func2() в

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

Таким образом, вы получите ошибку компиляции, если func2() будет упомянуто выше в тексте, то func1. Это не значит, что он будет действительно вызван раньше во время исполнения.