หลีกเลี่ยงคำสั่ง if ภายใน for loop หรือไม่?

ฉันมีคลาสที่เรียกWriterว่ามีฟังก์ชันwriteVectorดังนี้:

void Drawer::writeVector(vector<T> vec, bool index=true)
{
    for (unsigned int i = 0; i < vec.size(); i++) {
        if (index) {
            cout << i << "\t";
        }
        cout << vec[i] << "\n";
    }
}

ฉันพยายามไม่ให้มีรหัสซ้ำในขณะที่ยังคงกังวลเกี่ยวกับประสิทธิภาพ ในฟังก์ชั่นฉันทำการif (index)ตรวจสอบทุกรอบของfor-loop แม้ว่าผลลัพธ์จะเหมือนกันเสมอ ซึ่งถือเป็นการ "กังวลเกี่ยวกับประสิทธิภาพการทำงาน"

ฉันสามารถหลีกเลี่ยงสิ่งนี้ได้อย่างง่ายดายโดยวางเช็คไว้ด้านนอกfor-loop ของฉัน อย่างไรก็ตามฉันจะได้รับรหัสซ้ำมากมาย:

void Drawer::writeVector(...)
{
    if (index) {
        for (...) {
            cout << i << "\t" << vec[i] << "\n";
        }
    }
    else {
        for (...) {
            cout << vec[i] << "\n";
        }
    }
}

ดังนั้นนี่จึงเป็นทางออกที่ "แย่" สำหรับฉัน สิ่งที่ฉันคิดคือฟังก์ชันส่วนตัวสองฟังก์ชันหนึ่งในนั้นอยู่นอกดัชนีแล้วเรียกอีกฟังก์ชันหนึ่ง อีกอันมีค่าเพียงเล็กน้อยเท่านั้น อย่างไรก็ตามฉันไม่สามารถหาวิธีใช้กับโปรแกรมของฉันได้ฉันยังต้องการการifตรวจสอบเพื่อดูว่าจะเรียกใช้โปรแกรมใด ...

ตามปัญหาความหลากหลายดูเหมือนเป็นวิธีแก้ปัญหาที่ถูกต้อง แต่ฉันไม่เห็นว่าฉันควรใช้ที่นี่อย่างไร อะไรคือวิธีที่ดีที่สุดในการแก้ปัญหาประเภทนี้?

นี่ไม่ใช่โปรแกรมจริงฉันแค่สนใจที่จะเรียนรู้ว่าควรแก้ไขปัญหาประเภทนี้อย่างไร

ส่งผ่านในร่างกายของลูปเป็น functor ได้รับการอินไลน์ในเวลาคอมไพล์ไม่มีการลงโทษด้านประสิทธิภาพ

แนวคิดในการส่งผ่านสิ่งที่แตกต่างกันนั้นแพร่หลายใน C ++ Standard Library เรียกว่ารูปแบบกลยุทธ์

หากคุณได้รับอนุญาตให้ใช้ C ++ 11 คุณสามารถทำสิ่งนี้:

#include <iostream>
#include <set>
#include <vector>

template <typename Container, typename Functor, typename Index = std::size_t>
void for_each_indexed(const Container& c, Functor f, Index index = 0) {

    for (const auto& e : c)
        f(index++, e);
}

int main() {

    using namespace std;

    set<char> s{'b', 'a', 'c'};

    // indices starting at 1 instead of 0
    for_each_indexed(s, [](size_t i, char e) { cout<<i<<'\t'<<e<<'\n'; }, 1u);

    cout << "-----" << endl;

    vector<int> v{77, 88, 99};

    // without index
    for_each_indexed(v, [](size_t , int e) { cout<<e<<'\n'; });
}

รหัสนี้ไม่สมบูรณ์แบบ แต่คุณได้รับแนวคิด

ใน C ++ 98 รุ่นเก่าจะมีลักษณะดังนี้:

#include <iostream>
#include <vector>
using namespace std;

struct with_index {
  void operator()(ostream& out, vector<int>::size_type i, int e) {
    out << i << '\t' << e << '\n';
  }
};

struct without_index {
  void operator()(ostream& out, vector<int>::size_type i, int e) {
    out << e << '\n';
  }
};


template <typename Func>
void writeVector(const vector<int>& v, Func f) {
  for (vector<int>::size_type i=0; i<v.size(); ++i) {
    f(cout, i, v[i]);
  }
}

int main() {

  vector<int> v;
  v.push_back(77);
  v.push_back(88);
  v.push_back(99);

  writeVector(v, with_index());

  cout << "-----" << endl;

  writeVector(v, without_index());

  return 0;
}

อีกครั้งรหัสนั้นยังห่างไกลจากความสมบูรณ์แบบ แต่ให้แนวคิดแก่คุณ

ในฟังก์ชันนี้ฉันทำการตรวจสอบ if (ดัชนี) ทุกรอบของ for-loop แม้ว่าผลลัพธ์จะเหมือนกันเสมอ ซึ่งถือเป็นการ "กังวลเกี่ยวกับประสิทธิภาพการทำงาน"

หากเป็นเช่นนั้นจริง ๆ ตัวทำนายสาขาจะไม่มีปัญหาในการทำนายผลลัพธ์ (ค่าคงที่) ดังนั้นสิ่งนี้จะทำให้เกิดค่าใช้จ่ายเล็กน้อยสำหรับการคาดเดาที่ผิดในการทำซ้ำสองสามครั้งแรก ไม่มีอะไรต้องกังวลในแง่ของประสิทธิภาพ

ในกรณีนี้ฉันสนับสนุนให้เก็บการทดสอบไว้ในลูปเพื่อความชัดเจน

หากต้องการขยายคำตอบของ Ali ซึ่งถูกต้องสมบูรณ์ แต่ยังคงซ้ำรหัสบางส่วน (ส่วนหนึ่งของ loop body ซึ่งแทบจะไม่สามารถหลีกเลี่ยงได้เมื่อใช้รูปแบบกลยุทธ์) ...

ได้รับในกรณีนี้การทำสำเนาโค้ดไม่มากนัก แต่มีวิธีลดให้มากยิ่งขึ้นซึ่งจะมีประโยชน์หากเนื้อหาของฟังก์ชันใหญ่กว่าคำสั่งเพียงเล็กน้อยถ้าร่างกายของฟังก์ชั่นมีขนาดใหญ่กว่าเพียงไม่กี่คำแนะนำ

ที่สำคัญคือการใช้ความสามารถของคอมไพเลอร์ที่จะดำเนินการพับคงกำจัด / รหัสตาย เราสามารถทำได้โดยการแมปค่ารันไทม์ของindexกับค่าเวลาคอมไพล์ด้วยตนเอง(ทำได้ง่ายเมื่อมีกรณีจำนวน จำกัด - สองกรณีนี้) และใช้อาร์กิวเมนต์แม่แบบที่ไม่ใช่ประเภทซึ่งเป็นที่รู้จักในการคอมไพล์ -เวลา:

template<bool index = true>
//                  ^^^^^^ note: the default value is now part of the template version
//                         see below to understand why
void writeVector(const vector<int>& vec) {
    for (size_t i = 0; i < vec.size(); ++i) {
        if (index) { // compile-time constant: this test will always be eliminated
            cout << i << "\t"; // this will only be kept if "index" is true
        }
        cout << vec[i] << "\n";
    }
}

void writeVector(const vector<int>& vec, bool index)
//                                            ^^^^^ note: no more default value, otherwise
//                                            it would clash with the template overload
{
    if (index) // runtime decision
        writeVector<true>(vec);
        //          ^^^^ map it to a compile-time constant
    else
        writeVector<false>(vec);
}

ด้วยวิธีนี้เราจะจบลงด้วยโค้ดที่คอมไพล์ซึ่งเทียบเท่ากับตัวอย่างโค้ดที่สองของคุณ (ด้านนอกif/ ด้านในfor) แต่ไม่ต้องทำซ้ำโค้ดด้วยตัวเอง ตอนนี้เราสามารถสร้างเวอร์ชันเทมเพลตwriteVectorที่ซับซ้อนได้เท่าที่เราต้องการโดยจะมีโค้ดเพียงชิ้นเดียวที่ต้องดูแล

สังเกตว่าเวอร์ชันเทมเพลต (ซึ่งรับค่าคงที่เวลาคอมไพล์ในรูปแบบของอาร์กิวเมนต์แม่แบบที่ไม่ใช่ชนิด) และเวอร์ชันที่ไม่ใช่เทมเพลต (ซึ่งใช้ตัวแปรรันไทม์เป็นอาร์กิวเมนต์ของฟังก์ชัน) มากเกินไป สิ่งนี้ช่วยให้คุณสามารถเลือกเวอร์ชันที่เกี่ยวข้องมากที่สุดขึ้นอยู่กับความต้องการของคุณโดยมีไวยากรณ์ที่ค่อนข้างคล้ายกันและจำง่ายในทั้งสองกรณี:

writeVector<true>(vec);   // you already know at compile-time which version you want
                          // no need to go through the non-template runtime dispatching

writeVector(vec, index);  // you don't know at compile-time what "index" will be
                          // so you have to use the non-template runtime dispatching

writeVector(vec);         // you can even use your previous syntax using a default argument
                          // it will call the template overload directly

ในกรณีส่วนใหญ่โค้ดของคุณดีในด้านประสิทธิภาพและความสามารถในการอ่านอยู่แล้ว คอมไพเลอร์ที่ดีสามารถตรวจจับค่าคงที่ของลูปและทำการปรับแต่งที่เหมาะสมได้ ลองพิจารณาตัวอย่างต่อไปนี้ซึ่งใกล้เคียงกับโค้ดของคุณมาก:

#include <cstdio>
#include <iterator>

void write_vector(int* begin, int* end, bool print_index = false) {
    unsigned index = 0;
    for(int* it = begin; it != end; ++it) {
        if (print_index) {
            std::printf("%d: %d\n", index, *it);
        } else {
            std::printf("%d\n", *it);
        }
        ++index;
    }
}

int my_vector[] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
};


int main(int argc, char** argv) {
    write_vector(std::begin(my_vector), std::end(my_vector));
}

ฉันใช้บรรทัดคำสั่งต่อไปนี้เพื่อรวบรวม:

g++ --version
g++ (GCC) 4.9.1
Copyright (C) 2014 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
g++ -O3 -std=c++11 main.cpp

จากนั้นมาถ่ายโอนข้อมูลประกอบ:

objdump -d a.out | c++filt > main.s

การประกอบผลลัพธ์write_vectorคือ:

00000000004005c0 <write_vector(int*, int*, bool)>:
  4005c0:   48 39 f7                cmp    %rsi,%rdi
  4005c3:   41 54                   push   %r12
  4005c5:   49 89 f4                mov    %rsi,%r12
  4005c8:   55                      push   %rbp
  4005c9:   53                      push   %rbx
  4005ca:   48 89 fb                mov    %rdi,%rbx
  4005cd:   74 25                   je     4005f4 <write_vector(int*, int*, bool)+0x34>
  4005cf:   84 d2                   test   %dl,%dl
  4005d1:   74 2d                   je     400600 <write_vector(int*, int*, bool)+0x40>
  4005d3:   31 ed                   xor    %ebp,%ebp
  4005d5:   0f 1f 00                nopl   (%rax)
  4005d8:   8b 13                   mov    (%rbx),%edx
  4005da:   89 ee                   mov    %ebp,%esi
  4005dc:   31 c0                   xor    %eax,%eax
  4005de:   bf a4 06 40 00          mov    $0x4006a4,%edi
  4005e3:   48 83 c3 04             add    $0x4,%rbx
  4005e7:   83 c5 01                add    $0x1,%ebp
  4005ea:   e8 81 fe ff ff          callq  400470 <printf@plt>
  4005ef:   49 39 dc                cmp    %rbx,%r12
  4005f2:   75 e4                   jne    4005d8 <write_vector(int*, int*, bool)+0x18>
  4005f4:   5b                      pop    %rbx
  4005f5:   5d                      pop    %rbp
  4005f6:   41 5c                   pop    %r12
  4005f8:   c3                      retq   
  4005f9:   0f 1f 80 00 00 00 00    nopl   0x0(%rax)
  400600:   8b 33                   mov    (%rbx),%esi
  400602:   31 c0                   xor    %eax,%eax
  400604:   bf a8 06 40 00          mov    $0x4006a8,%edi
  400609:   48 83 c3 04             add    $0x4,%rbx
  40060d:   e8 5e fe ff ff          callq  400470 <printf@plt>
  400612:   49 39 dc                cmp    %rbx,%r12
  400615:   75 e9                   jne    400600 <write_vector(int*, int*, bool)+0x40>
  400617:   eb db                   jmp    4005f4 <write_vector(int*, int*, bool)+0x34>
  400619:   0f 1f 80 00 00 00 00    nopl   0x0(%rax)

เราจะเห็นว่าในการขอฟังก์ชั่นเราตรวจสอบค่าและข้ามไปที่หนึ่งในสองลูปที่เป็นไปได้:

  4005cf:   84 d2                   test   %dl,%dl
  4005d1:   74 2d                   je     400600 <write_vector(int*, int*, bool)+0x40>

แน่นอนว่าจะใช้งานได้ก็ต่อเมื่อคอมไพเลอร์สามารถตรวจพบว่าเงื่อนไขไม่แปรผันจริง โดยปกติแล้วจะใช้งานได้ดีกับแฟล็กและฟังก์ชันอินไลน์ง่ายๆ แต่ถ้าเงื่อนไขนั้น "ซับซ้อน" ให้พิจารณาใช้แนวทางจากคำตอบอื่น ๆ