blocks|key|4788229|text|这取决于您使用的编译器。我使用的是DevStudio+2005，在联机帮助中有这个编译器命令行选项：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4788230|钩子/Gh+(启用_penter钩子功能)|4788231|导致在每个方法或函数开始时调用_penter函数。|4788232|_penter函数不是任何库的一部分，您可以为_penter提供定义。|4788233|除非您计划显式调用_penter，否则不需要提供原型。该函数必须看起来像具有以下原型，并且必须在进入时推送所有寄存器的内容，并在退出时弹出未更改的内容：|4788234|4788235|void+__declspec(naked)+_cdecl+_penter(+void+);|code-block|syntax|javascript|4788236|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|T|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|V|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|K|3|L|5|M|7|X|8|@]|9|@]|A|$N|O]]|$1|P|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|Q|$]]

It depends on the compiler you're using. I'm using DevStudio 2005 and, from the online help there's this compiler command line option:

<blockquote>
 /Gh (Enable _penter Hook Function) 
 
 Causes a call to the _penter function at the start of every method or function.
 
 The _penter function is not part of any library and it is up to you to provide a definition for _penter.
 
 Unless you plan to explicitly call _penter, you do not need to provide a prototype. The function must appear as if it had the following prototype, and it must push the content of all registers on entry and pop the unchanged content on exit:
</blockquote>

<pre><code>void __declspec(naked) _cdecl _penter( void );
</code></pre>

blocks|key|1910407|text|相当多的分析器(和类似的工具)可以/将做这样的事情。实际上，在二进制级别上比在源代码级别上更容易。在源代码级别，这是非常困难的，对于大多数实际目的，您不妨将其视为不可能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1910408|根据您使用的编译器，很有可能它有一个标志来支持这样的插入--通常主要是为了支持分析器以及我上面提到的诸如此类的东西。|1910409|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

A fair number of profilers (and similar tools) can/will do things like this. It's actually easier at the binary level than the source code level. At the source code level, it's sufficiently difficult that for most practical purposes you might as well treat it as impossible.

Depending on the compiler you're using, there's a pretty fair chance that it has a flag to support such insertions -- usually present primarily to support the profilers and such I mentioned above.

blocks|key|4788347|text|根据您希望实现的结果，您可以使用包装实际调用的函数器对象在C%2B%2B中创建一些东西(对于自由函数或静态成员函数来说很容易)，例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4788348|#include+<iostream>

template<void+f(void)>
struct+Wrap+{
+++void+operator()()+const+{
++++++std::cout+<<+"Pre+call+hook"+<<+std::endl;
++++++f();
+++}
};

namespace+{
+++void+test_func()+{
++++++std::cout+<<+"Real+function"+<<+std::endl;
+++}
}

const+Wrap<&test_func>+wrapped_test_func+=+{};

int+main()+{
+++wrapped_test_func();
+++return+0;
}|code-block|syntax|javascript|4788349|显然，这需要做更多的工作才能足够通用，例如C%2B%2B0x可变模板或大量重载。让它与成员函数很好地协同工作也更加繁琐。|4788350|我也为成员函数勾勒出了一种(非侵入式的)方式：|4788351|#include+<iostream>

template<class+C,+void+(C::*F)()>
class+WrapMem+{
+++C&+inst;
public:
+++WrapMem(C&+inst)+:+inst(inst)+{}

+++void+operator()()+{
++++++std::cout+<<+"Pre+(method)+call+hook"+<<+std::endl;
++++++((inst).*(F))();
+++}

+++void+operator()()+const+{
++++++std::cout+<<+"Pre+(method,+const)+call+hook"+<<+std::endl;
++++++((inst).*(F))();
+++}
};

class+Foo+{
public:
+++void+method()+{+std::cout+<<+"Method+called"+<<+std::endl;+}
+++void+otherstuff()+{}
};

class+FooWrapped+:+private+Foo++{
public:
+++FooWrapped()+:+method(*this)+{}
+++using+Foo::otherstuff;
+++WrapMem<Foo,&Foo::method>+method;
};

int+main()+{
+++FooWrapped+f;
+++f.otherstuff();
+++f.method();
+++return+0;
}|4788352|您也可以跳过私有继承和using来公开非包装方法，但是您需要小心析构函数，如果这样做，很容易被意外绕过。(例如，隐式强制转换以引用基类)。非侵入式方式也仅限于公共接口，也不能用于内部调用。|offset|length|style|CODE|4788353|使用C%2B%2B11，您可以获得完美的转发，还可以将包装对象的构造简化为一个简单的宏，该宏获取类和成员函数名并为您推导出其余部分，例如：|4788354|#include+<iostream>
#include+<utility>

template+<typename+Ret,+typename+...Args>
struct+Wrapper+{
++template+<class+C,+Ret+(C::*F)(Args...)>+
++class+MemberFn+{
++++C&+inst;
++public:
++++MemberFn(C&+inst)+:+inst(inst)+{}
++++MemberFn&+operator=(const+MemberFn&)+=+delete;

++++Ret+operator()(Args&&+...args)+{
++++++return+((inst).*(F))(std::forward<Args>(args)...);
++++}

++++Ret+operator()(Args&&+...args)+const+{
++++++return+((inst).*(F))(std::forward<Args>(args)...);
++++}
++};
};

template+<typename+T>
struct+deduce_memfn;
template+<typename+C,+typename+R,+typename...+Args>
struct+deduce_memfn<R+(C::*)(Args...)>+{
++template+<R(C::*F)(Args...)>+
++static+typename+Wrapper<R,+Args...>::template+MemberFn<C,+F>+make();
};

template+<typename+T>
decltype(deduce_memfn<T>())+deduce(T);

template+<typename+T>
struct+workaround+:+T+{};+//+Clang+3.0+doesn't+let+me+write+decltype(deduce(&Class::Method))::make...

#define+WRAP_MEMBER_FN(Class,+Method)+decltype(workaround<decltype(deduce(&Class::Method))>::make<&Class::Method>())+Method+=+*this

class+Foo+{
public:
++Foo(int);
++double+method(int&+v)+{+return+-(v+-=+100)+*+10.2;+}
++void+otherstuff();
};

class+WrappedFoo+:+private+Foo+{
public:
++using+Foo::Foo;+//+Delegate+the+constructor+(C%2B%2B11)
++WRAP_MEMBER_FN(Foo,+method);
++using+Foo::otherstuff;
};

int+main()+{
++WrappedFoo+f(0);
++int+i+=+101;
++std::cout+<<+f.method(i)+<<+"\n";
++std::cout+<<+i+<<+"\n";
}|4788355|(注意:这个推论不适用于重载)这是用Clang+3.0测试的。|4788356|entityMap^0|0|0|0|0|0|B|5|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|15|8|@$O|16|P|17|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|19|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Y|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|Z|$]]

Depending on what you're hoping to achieve as a result of this you can sort of make something (easily enough for free functions or static member functions) in C++ with functor objects which wrap real calls, e.g.:

<pre><code>#include &lt;iostream&gt;

template&lt;void f(void)&gt;
struct Wrap {
 void operator()() const {
 std::cout &lt;&lt; "Pre call hook" &lt;&lt; std::endl;
 f();
 }
};

namespace {
 void test_func() {
 std::cout &lt;&lt; "Real function" &lt;&lt; std::endl;
 }
}

const Wrap&lt;&amp;test_func&gt; wrapped_test_func = {};

int main() {
 wrapped_test_func();
 return 0;
}
</code></pre>

Clearly this needs some more work to be generic enough e.g. C++0x variadic templates or lots of overloads. Making it work nicely with member functions is also more fiddly.

I've sketched an outline for a (non-intrusive) way of doing this for member functions too:

<pre><code>#include &lt;iostream&gt;

template&lt;class C, void (C::*F)()&gt;
class WrapMem {
 C&amp; inst;
public:
 WrapMem(C&amp; inst) : inst(inst) {}

 void operator()() {
 std::cout &lt;&lt; "Pre (method) call hook" &lt;&lt; std::endl;
 ((inst).*(F))();
 }

 void operator()() const {
 std::cout &lt;&lt; "Pre (method, const) call hook" &lt;&lt; std::endl;
 ((inst).*(F))();
 }
};

class Foo {
public:
 void method() { std::cout &lt;&lt; "Method called" &lt;&lt; std::endl; }
 void otherstuff() {}
};

class FooWrapped : private Foo {
public:
 FooWrapped() : method(*this) {}
 using Foo::otherstuff;
 WrapMem&lt;Foo,&amp;Foo::method&gt; method;
};

int main() {
 FooWrapped f;
 f.otherstuff();
 f.method();
 return 0;
}
</code></pre>

You could also skip the private inheritance and <code>using</code> to expose non-wrapped methods, but you need to be careful about destructors and it's easy to accidentally bypass if you do that. (e.g. implicit cast for reference to base). The non-intrusive way is also limited to only working for the public interface and not for internal calls either. 

With C++11 you can get perfect forwarding and also reduce the construction of the wrapping objects to a simple macro that takes the class and member function name and deduces the rest for you, e.g.:

<pre><code>#include &lt;iostream&gt;
#include &lt;utility&gt;

template &lt;typename Ret, typename ...Args&gt;
struct Wrapper {
 template &lt;class C, Ret (C::*F)(Args...)&gt; 
 class MemberFn {
 C&amp; inst;
 public:
 MemberFn(C&amp; inst) : inst(inst) {}
 MemberFn&amp; operator=(const MemberFn&amp;) = delete;

 Ret operator()(Args&amp;&amp; ...args) {
 return ((inst).*(F))(std::forward&lt;Args&gt;(args)...);
 }

 Ret operator()(Args&amp;&amp; ...args) const {
 return ((inst).*(F))(std::forward&lt;Args&gt;(args)...);
 }
 };
};

template &lt;typename T&gt;
struct deduce_memfn;
template &lt;typename C, typename R, typename... Args&gt;
struct deduce_memfn&lt;R (C::*)(Args...)&gt; {
 template &lt;R(C::*F)(Args...)&gt; 
 static typename Wrapper&lt;R, Args...&gt;::template MemberFn&lt;C, F&gt; make();
};

template &lt;typename T&gt;
decltype(deduce_memfn&lt;T&gt;()) deduce(T);

template &lt;typename T&gt;
struct workaround : T {}; // Clang 3.0 doesn't let me write decltype(deduce(&amp;Class::Method))::make...

#define WRAP_MEMBER_FN(Class, Method) decltype(workaround&lt;decltype(deduce(&amp;Class::Method))&gt;::make&lt;&amp;Class::Method&gt;()) Method = *this

class Foo {
public:
 Foo(int);
 double method(int&amp; v) { return -(v -= 100) * 10.2; }
 void otherstuff();
};

class WrappedFoo : private Foo {
public:
 using Foo::Foo; // Delegate the constructor (C++11)
 WRAP_MEMBER_FN(Foo, method);
 using Foo::otherstuff;
};

int main() {
 WrappedFoo f(0);
 int i = 101;
 std::cout &lt;&lt; f.method(i) &lt;&lt; "\n";
 std::cout &lt;&lt; i &lt;&lt; "\n";
}
</code></pre>

(Note: this deduction won't work with overloads)
This was tested with Clang 3.0.

blocks|key|4788377|text|对于gcc来说，对于MSVC也有一个类似的解决方案，其他人发布了一个答案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4788378|#include+<iostream>
int+depth=-1;
extern+"C"+{
++++void+__cyg_profile_func_enter+(void+*,+void+*)+__attribute__((no_instrument_function));
++++void+__cyg_profile_func_exit+(void+*,+void+*)+__attribute__((no_instrument_function));
++++void+__cyg_profile_func_enter+(void+*func,++void+*caller)
++++{
++++++++depth%2B%2B;
++++}


++++void+__cyg_profile_func_exit+(void+*func,+void+*caller)
++++{
++++++++depth--;
++++}
}

class+Foo+{
public:
++++void+bar()+{
++++++++std::cout+<<+"bar:+"+<<+depth+<<+std::endl;
++++}
};

int+main()+{
++++Foo+f;
++++f.bar();
++++return+0;
}|code-block|syntax|javascript|4788379|使用g%2B%2B+-Wall+-Wextra+-finstrument-functions编译。但是要注意，不要从工具钩子中调用插入指令的函数！(有关排除事物的方法，请参阅手册页)|offset|length|style|CODE|4788380|entityMap^0|0|0|2|14|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@$I|R|J|S|K|L]]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

For gcc there's a similar solution to the MSVC one someone else posted as an answer:

<pre><code>#include &lt;iostream&gt;
int depth=-1;
extern "C" {
 void __cyg_profile_func_enter (void *, void *) __attribute__((no_instrument_function));
 void __cyg_profile_func_exit (void *, void *) __attribute__((no_instrument_function));
 void __cyg_profile_func_enter (void *func, void *caller)
 {
 depth++;
 }


 void __cyg_profile_func_exit (void *func, void *caller)
 {
 depth--;
 }
}

class Foo {
public:
 void bar() {
 std::cout &lt;&lt; "bar: " &lt;&lt; depth &lt;&lt; std::endl;
 }
};

int main() {
 Foo f;
 f.bar();
 return 0;
}
</code></pre>

Compile with <code>g++ -Wall -Wextra -finstrument-functions</code>. Be careful not to call an instrumented function from within the instrument hooks though! (See the man page for ways of excluding things)

blocks|key|1910464|text|正如有人在评论中所说，这是方面/功能编程的典型用例。您可以尝试在c%2B%2B中使用aspect+/+feature编程的this。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1910465|my2c|1910466|entityMap|0|LINK|mutability|MUTABLE|url|http://wwwiti.cs.uni-magdeburg.de/iti_db/forschung/fop/featurec/^0|1L|4|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

As someone said in a comment, it is a typical use case of aspect / feature programming. You can try <a href="http://wwwiti.cs.uni-magdeburg.de/iti_db/forschung/fop/featurec/" rel="nofollow">this</a> to use aspect / feature programming with c++. 

my2c

blocks|key|1121814|text|你正在寻找的是所谓的“代码插装”，我在2012年的GDC2012上做了一个关于manual+and+compiler-automated+instrumentation的演讲(点击here查看代码示例)。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1121815|有许多方法可以做你想做的事情。Wrapper+functions、Detour和Trampolines，或者是其他答案中提到的_penter()+/+__cyg_profile_func_enter()方法。|1121816|所有这些以及其他一些工具方法在上面链接的PDF中都有详细介绍。|1121817|entityMap|0|LINK|mutability|MUTABLE|url|http://twvideo01.ubm-us.net/o1/vault/gdc2012/slides/Programming%2520Track/Adisak_Pochanayon_CPU_Instrumentation_Presentation.pdf|1|http://twvideo01.ubm-us.net/o1/vault/gdc2012/slides/Programming%2520Track/Adisak_Pochanayon_CPU_Instrumentation_Handouts.pdf^0|13|19|0|2I|4|1|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@$A|S|B|T|1|U]|$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|C|$]]|$1|F|3|G|5|6|7|Z|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|C|$]]]|I|$J|$5|K|L|M|C|$N|O]]|P|$5|K|L|M|C|$N|Q]]]]

What you are looking for is called "code instrumentation" and I gave a talk at GDC 2012 on <a href="http://twvideo01.ubm-us.net/o1/vault/gdc2012/slides/Programming%20Track/Adisak_Pochanayon_CPU_Instrumentation_Presentation.pdf" rel="noreferrer">manual and compiler-automated instrumentation</a> (click <a href="http://twvideo01.ubm-us.net/o1/vault/gdc2012/slides/Programming%20Track/Adisak_Pochanayon_CPU_Instrumentation_Handouts.pdf" rel="noreferrer">here</a> for code samples).

There are a number of ways to do what you want. Wrapper functions, Detours and Trampolines, or CAI (compiler-automated instrumentation) which is _penter() / __cyg_profile_func_enter() methods mentioned in other answers.

All of these as well as some other instrumentation methods are detailed in the PDF's linked above.

I want to add some code before every function call to do some checking. The only way I know is:

<pre><code>#define SOME_CODE printf("doing something...");

class testObject
{
void function1()
{
 SOME_CODE
 ...
}
void function2()
{
 SOME_CODE
 ...
}
}
</code></pre>

Is there a cleaner way to achieve this? I'm looking for a method so I don't have add "SOME_CODE" to every function manually.

How to add code at the entry of every function?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想在每次函数调用之前添加一些代码来做一些检查。我知道的唯一方法是：#define SOME_CODE printf("doing something...");class testObject{void function1(){ SOME_CODE ...}void function2(){ SOME_CODE .....

问如何在每个函数的入口处添加代码？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在每个函数的入口处添加代码？EN