現在的C++編譯器內聯函數只能調用一次嗎？

Question

如，說我的頭文件是：

class A 
{ 
    void Complicated(); 
} 

我的源文件

void A::Complicated() 
{ 
    ...really long function... 
} 

我可以將源文件拆分成

void DoInitialStuff(pass necessary vars by ref or value) 
{ 
    ... 
} 
void HandleCaseA(pass necessary vars by ref or value) 
{ 
    ... 
} 
void HandleCaseB(pass necessary vars by ref or value) 
{ 
    ... 
} 
void FinishUp(pass necessary vars by ref or value) 
{ 
    ... 
} 
void A::Complicated() 
{ 
    ... 
    DoInitialStuff(...); 
    switch ... 
     HandleCaseA(...) 
     HandleCaseB(...) 
    ... 
    FinishUp(...) 
} 

完全是爲了可讀性和沒有任何恐懼對性能的影響？

Answer 1

您應該標記函數static，以便編譯器知道它們對於該翻譯單元是本地的。

沒有static編譯器不能假設（禁止LTO/WPA）該函數只被調用一次，因此不太可能將其內聯。

演示使用LLVM Try Out頁面。

這就是說，代碼的可讀性首先，微優化（並且這樣調整是微優化）應該僅在性能測量之後出現。

---

例子：

#include <cstdio> 

static void foo(int i) { 
    int m = i % 3; 
    printf("%d %d", i, m); 
} 

int main(int argc, char* argv[]) { 
    for (int i = 0; i != argc; ++i) { 
    foo(i); 
    } 
} 

產生一個與static：

; ModuleID = '/tmp/webcompile/_27689_0.bc' 
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" 
target triple = "x86_64-unknown-linux-gnu" 

@.str = private constant [6 x i8] c"%d %d\00"  ; <[6 x i8]*> [#uses=1] 

define i32 @main(i32 %argc, i8** nocapture %argv) nounwind { 
entry: 
    %cmp4 = icmp eq i32 %argc, 0     ; <i1> [#uses=1] 
    br i1 %cmp4, label %for.end, label %for.body 

for.body:           ; preds = %for.body, %entry 
    %0 = phi i32 [ %inc, %for.body ], [ 0, %entry ] ; <i32> [#uses=3] 
    %rem.i = srem i32 %0, 3       ; <i32> [#uses=1] 
    %call.i = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([6 x i8]* @.str, i64 0, i64 0), i32 %0, i32 %rem.i) nounwind ; <i32> [#uses=0] 
    %inc = add nsw i32 %0, 1      ; <i32> [#uses=2] 
    %exitcond = icmp eq i32 %inc, %argc    ; <i1> [#uses=1] 
    br i1 %exitcond, label %for.end, label %for.body 

for.end:           ; preds = %for.body, %entry 
    ret i32 0 
} 

declare i32 @printf(i8* nocapture, ...) nounwind 

沒有static：

; ModuleID = '/tmp/webcompile/_27859_0.bc' 
target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64" 
target triple = "x86_64-unknown-linux-gnu" 

@.str = private constant [6 x i8] c"%d %d\00"  ; <[6 x i8]*> [#uses=1] 

define void @foo(int)(i32 %i) nounwind { 
entry: 
    %rem = srem i32 %i, 3       ; <i32> [#uses=1] 
    %call = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([6 x i8]* @.str, i64 0, i64 0), i32 %i, i32 %rem) ; <i32> [#uses=0] 
    ret void 
} 

declare i32 @printf(i8* nocapture, ...) nounwind 

define i32 @main(i32 %argc, i8** nocapture %argv) nounwind { 
entry: 
    %cmp4 = icmp eq i32 %argc, 0     ; <i1> [#uses=1] 
    br i1 %cmp4, label %for.end, label %for.body 

for.body:           ; preds = %for.body, %entry 
    %0 = phi i32 [ %inc, %for.body ], [ 0, %entry ] ; <i32> [#uses=3] 
    %rem.i = srem i32 %0, 3       ; <i32> [#uses=1] 
    %call.i = tail call i32 (i8*, ...)* @printf(i8* getelementptr inbounds ([6 x i8]* @.str, i64 0, i64 0), i32 %0, i32 %rem.i) nounwind ; <i32> [#uses=0] 
    %inc = add nsw i32 %0, 1      ; <i32> [#uses=2] 
    %exitcond = icmp eq i32 %inc, %argc    ; <i1> [#uses=1] 
    br i1 %exitcond, label %for.end, label %for.body 

for.end:           ; preds = %for.body, %entry 
    ret i32 0 
} 

Answer 2

取決於別名（指向該函數的指針）和函數長度（分支內嵌的大函數可能會將另一分支從緩存中移出，從而傷害性能）。

讓有關編譯器擔心，你擔心你的代碼:)

Answer 3

一個複雜的功能可能有它的速度在函數內部操作爲主;即使沒有內聯，函數調用的開銷也不會顯着。

對函數的內聯沒有太多的控制，知道的最好方法就是嘗試一下並找出答案。

編譯器的優化器可能對代碼較短的代碼更有效，所以即使它沒有內聯，也可能會發現它變得更快。

Answer 4

如果將代碼拆分爲邏輯分組，編譯器將執行它認爲最好的操作：如果代碼簡短，編譯器應該將其內聯並且結果相同。但是，如果代碼複雜，那麼創建額外的函數調用實際上可能比執行所有內聯工作更快，因此您可以讓編譯器選擇這樣做。最重要的是，對於維護人員來說，邏輯上的分離代碼可以更容易地避免將來的錯誤。

Answer 5

我建議你創建一個輔助類來打破你的complica將函數轉換爲方法調用，就像您提出的那樣，但沒有將參數傳遞給每個這些小函數的漫長，無聊和不可讀的任務。通過使它們成爲輔助類的成員變量，只傳遞一次這些參數。

，不要着眼於優化在這一點上，確保您的代碼是可讀的，你會的時間細99％。