标签: inline

假设我有一个functionProxy带有泛型参数的函数function并调用它operator():

template< typename Function > void functionProxy( Function function ) {
    function();
}

传递给它的对象可能是:

• 一个仿函数:

  struct Functor {
      void operator()() const {
          std::cout << "functor!" << std::endl;
      }
  };
  

  Run Code Online (Sandbox Code Playgroud)

• 功能:

  void function( ) {
      std::cout << "function!" << std::endl;
  }
  

  Run Code Online (Sandbox Code Playgroud)

• 一个(C++ 0x)lambda函数:

  [](){ std::cout << "lambda!" << std::endl; }
  

  Run Code Online (Sandbox Code Playgroud)

int main( )
{
    functionProxy( Functor() );
    functionProxy( function );
    functionProxy( [](){ std::cout << "lambda!" << std::endl; } );
    return 0;
}

编译器将能够内联function中 …

我目前正在Haskell中编写一个多模块程序.我发现了一个奇怪的问题,我的文件没有正确优化,即使我正在传入-O2等等.有问题的文件是共享的3D矢量数学模块.当单独编译为.o时,这些模块已正确优化.当使用--make编译为较大程序的一部分时,它们未正确优化.核心是完全不同的.

我在vector.hs文件中添加了一些简单的精简测试代码:

data TestVector = TestVector !Double !Double !Double !Double

addVec :: TestVector -> TestVector -> TestVector

addVec (TestVector x1 y1 z1 w1) (TestVector x2 y2 z2 w2) =
  TestVector (x1 + x2) (y1 + y2) (z1 + z2) (w1 + w2)

并从主要进口...

import Vector

这个代码的编译方式与独立的.hs文件不同,而不是在构建main.hs时使用 --make

我的命令行是:

ghc -tmpdir tmp -hidir hi -odir obj -fext-core -fexcess-precision -funbox-strict-fields -threaded -rtsopts -fwarn-missing-signatures -Wall -O2 Main.hs -o main

干杯

我注意到GHC手册说"对于自递归函数,环路断路器只能是函数本身,因此INLINE编译指示总是被忽略."

这难道不是说像普通的递归功能结构的每一个应用程序map,zip,scan*,fold*,sum,等不能被内联？

您可以随时重写所有这些功能,添加适当的严格标签,或者使用像这里推荐的"流融合"这样的花哨技术.

然而,这并不是所有这些都极大地限制了我们编写同时快速和优雅的代码的能力吗？

我有以下管理员设置,以便我可以同时添加/编辑用户及其个人资料.

class ProfileInline(admin.StackedInline):
    """
    Allows profile to be added when creating user
    """
    model = Profile


class UserProfileAdmin(admin.ModelAdmin):
    """
    Options for the admin interface
    """
    inlines = [ProfileInline]
    list_display = ['edit_obj', 'name', 'username', 'email', 'is_active',
        'last_login', 'delete_obj']
    list_display_links = ['username']
    list_filter = ['is_active']
    fieldsets = (
        (None, {
            'fields': ('first_name', 'last_name', 'email', 'username',
                'is_active', 'is_superuser')}),
        )
    ordering = ['last_name', 'first_name']
    search_fields = ['first_name', 'last_name']

admin.site.register(User, UserProfileAdmin)

问题是我在添加用户时需要配置文件内联表单中的两个字段.除非输入输入,否则内联表单不会验证.反正是否要求内联,以便它不能留空？

我使用了很多N维数组,并且编写这样的缩进代码会很麻烦,我知道一些代码可以用列表推导和内联语句替换.例如:

for x in (0,1,2,3):
    for y in (0,1,2,3):
        if x < y:
            print (x, y, x*y)

可以替换为:

print [(x, y, x * y) for x in (0,1,2,3) for y in (0,1,2,3) if x < y]

但是我怎么能改变动作而不是打印来做其他事情:

total = x+y

所以我想做的是:

[(total+=x+y) for x in (0,1,2,3) for y in (0,1,2,3) if x < y]

但这不起作用

是否有一种聪明的方法来做到这一点,而不是:

for x in (0,1,2,3):
        for y in (0,1,2,3):
            if x < y:
                total+=x+y

在函数之前使用inline关键字和在头文件中声明整个函数之间有什么区别？

所以...

int whatever() { return 4; }

VS

.H:

inline int whatever();

的.cpp:

inline int myClass::whatever()
{
    return 4;
}

就此而言,这是做什么的:

inline int whatever() { return 4; }

任何人都可以告诉我内联函数和静态内联函数之间的区别是什么？

在哪些情况下,我更喜欢静态内联而不是内联？

我问这个问题,因为我有一个内联函数,我在链接(relocation error:... symbol has been discarded with discarded section ...)期间遇到编译问题.我使它成为一个正常的功能,它工作.现在我的一些老人告诉我尝试使用静态内联.以下是我的功能:

inline void wizSendNotifier (const char* nn_name, bpDU* arg=0, int aspect = -1)
{
   wizuiNotifier* notifier = ::wizNtrKit.getNotifier (nn_name);
   notifier->notify (arg, aspect);
}

而这不是在课堂上.这是在头文件中!

我想对静态函数的调用只能在定义它的特定TU中完成.

由于我的函数是在头文件中,并且如果我将其设置为静态,是否会出现这样的情况:在哪里我包含该头文件,静态函数可以用于该翻译单元？

我正在写一个XNA游戏,我在那里进行逐像素碰撞检查.通过移位int和按位ORing来检查这种情况的循环通常难以阅读和理解.

我想添加私有方法,例如private bool IsTransparent(int pixelColorValue)使循环更具可读性,但我不希望方法调用的开销,因为这是性能敏感的代码.

有没有办法强制编译器内联这个调用,或者我是否只是希望编译器会进行这种优化？

如果没有办法强制执行此操作,是否有办法检查方法是否内联,而不是读取反汇编？如果内联并且没有其他调用者存在,该方法是否会显示在反射中？

编辑:我不能强迫它,所以我可以检测到它吗？

其中一个更快吗？

inline int ProcessByValue(int i)
{
    // process i somehow
}

inline int ProcessByReference(const int& i)
{
    // process i somehow
}

我知道整数类型应该按值传递.但是,我担心编译器可能会内联ProcessByValue以包含副本.这有规则吗？

在清洁代码(以及我遇到过的其他几本书)中,建议保持功能较小并在它们变大时将其分解.它还表明功能应该只做一件事而且只做一件事.

在C++中优化软件时, Agner Fog声称他不喜欢分解函数的规则只是因为它超过了许多行的某个阈值.他声称这会导致不必要的跳跃,从而降低性能.

首先,我理解,如果我正在处理的代码不是紧密循环并且函数很重,那么调用它们所花费的时间与函数中的代码所用的时间相比是相形见绌的.执行.但是我们假设我正在处理大多数时候由其他对象/函数使用的函数,并且执行相对简单的任务.这些函数遵循第一段中列出的建议(即,执行单个函数并且很小/可理解).然后我开始编写一个性能关键函数,它在紧密循环中利用这些其他函数,本质上是一个框架函数.最后,假设内嵌它们对性能关键功能有好处,但对任何其他功能都没有任何好处(是的,我已经对此进行了描述,尽管有很多我想避免的复制和粘贴).

马上就可以说标记函数inline并让编译器选择.但是如果我不希望所有这些函数都在` .inl文件中或暴露在标题中呢？在我目前的情况下,性能关键函数和它使用的其他函数都在同一个源文件中.

总而言之,我可以有选择地(强制)内联单个函数的函数,以便结束代码表现得像是一个大函数,而不是几个对其他函数的调用.