Tránh câu lệnh if bên trong vòng lặp for?

Tôi có một lớp được gọi là Writercó chức năng writeVectornhư vậy:

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";
    }
}

Tôi đang cố gắng không có mã trùng lặp trong khi vẫn lo lắng về hiệu suất. Trong hàm này, tôi đang if (index)kiểm tra mọi vòng for-loop của mình , mặc dù kết quả luôn giống nhau. Điều này chống lại "lo lắng về hiệu suất".

Tôi có thể dễ dàng tránh điều này bằng cách đặt séc bên ngoài for-loop của mình . Tuy nhiên, tôi sẽ nhận được vô số mã trùng lặp:

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

Vì vậy, đây là cả hai giải pháp "không tồi" đối với tôi. Những gì tôi đang nghĩ, là hai hàm riêng tư, một trong số chúng vượt quá chỉ mục và sau đó gọi hàm kia. Cái còn lại chỉ vượt quá giá trị. Tuy nhiên, tôi không thể tìm ra cách sử dụng nó với chương trình của mình, tôi vẫn cần ifkiểm tra xem nên gọi cái nào ...

Theo vấn đề, đa hình có vẻ là một giải pháp đúng. Nhưng tôi không thể thấy làm thế nào tôi nên sử dụng nó ở đây. Cách ưa thích để giải quyết loại vấn đề này là gì?

Đây không phải là một chương trình thực tế, tôi chỉ quan tâm đến việc tìm hiểu cách giải quyết loại vấn đề này.

Chuyền vào phần thân của vòng lặp như một cái máy quay. Nó được nội dung tại thời điểm biên dịch, không có hình phạt hiệu suất.

Ý tưởng chuyển những gì khác nhau là rất phổ biến trong Thư viện chuẩn C ++. Nó được gọi là mô hình chiến lược.

Nếu bạn được phép sử dụng C ++ 11, bạn có thể làm như sau:

#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'; });
}

Mã này không hoàn hảo nhưng bạn có được ý tưởng.

Trong C ++ 98 cũ, nó trông như thế này:

#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;
}

Một lần nữa, mã này không hoàn hảo nhưng nó cung cấp cho bạn ý tưởng.

Trong hàm này, tôi đang thực hiện kiểm tra if (chỉ mục) trên mỗi vòng lặp của tôi, mặc dù kết quả luôn giống nhau. Điều này chống lại "lo lắng về hiệu suất".

Nếu điều này thực sự là như vậy, bộ dự đoán nhánh sẽ không gặp vấn đề gì trong việc dự đoán kết quả (hằng số). Do đó, điều này sẽ chỉ gây ra chi phí nhẹ cho các sai sót trong vài lần lặp đầu tiên. Không có gì phải lo lắng về hiệu suất

Trong trường hợp này, tôi ủng hộ việc giữ thử nghiệm bên trong vòng lặp cho rõ ràng.

Để mở rộng về câu trả lời của Ali, câu trả lời là hoàn toàn chính xác nhưng vẫn trùng lặp một số mã (một phần của nội dung vòng lặp, điều này rất khó tránh khỏi khi sử dụng mẫu chiến lược) ...

Được cho là trong trường hợp cụ thể này, sự trùng lặp mã không nhiều nhưng có một cách để giảm nó nhiều hơn, điều này rất hữu ích nếu phần thân hàm lớn hơn chỉ một vài lệnh .

Chìa khóa là sử dụng khả năng của trình biên dịch để thực hiện việc loại bỏ mã gấp / chết liên tục . Chúng ta có thể làm điều đó bằng cách ánh xạ thủ công giá trị thời gian chạy của thành giá trị thời gian indexbiên dịch (dễ thực hiện khi chỉ có một số trường hợp hạn chế - trong trường hợp này là hai trường hợp) và sử dụng đối số mẫu không phải kiểu được biết đến khi biên dịch -thời gian:

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);
}

Bằng cách này, chúng tôi kết thúc với mã được biên dịch tương đương với ví dụ mã thứ hai của bạn (bên ngoài if/ bên trong for) nhưng không tự sao chép mã. Bây giờ chúng ta có thể làm cho phiên bản mẫu writeVectorphức tạp như chúng ta muốn, sẽ luôn có một đoạn mã duy nhất để duy trì.

Lưu ý cách phiên bản mẫu (sử dụng hằng số thời gian biên dịch ở dạng đối số mẫu không phải kiểu) và phiên bản không phải mẫu (nhận biến thời gian chạy làm đối số hàm) được nạp chồng. Điều này cho phép bạn chọn phiên bản phù hợp nhất tùy thuộc vào nhu cầu của mình, có cú pháp khá giống nhau, dễ nhớ trong cả hai trường hợp:

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

Trong hầu hết các trường hợp, mã của bạn đã tốt về hiệu suất và khả năng đọc. Một trình biên dịch tốt có khả năng phát hiện các bất biến của vòng lặp và thực hiện các tối ưu hóa thích hợp. Hãy xem xét ví dụ sau đây rất gần với mã của bạn:

#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));
}

Tôi đang sử dụng dòng lệnh sau để biên dịch nó:

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

Sau đó, hãy kết xuất lắp ráp:

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

Kết quả của tập hợp write_vectorlà:

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)

Chúng ta có thể thấy rằng khi hàm này bắt đầu, chúng ta kiểm tra giá trị và chuyển đến một trong hai vòng lặp có thể:

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

Tất nhiên, điều này chỉ hoạt động nếu trình biên dịch có khả năng phát hiện rằng một điều kiện là bất biến thực tế. Thông thường, nó hoạt động hoàn hảo đối với cờ và các hàm nội tuyến đơn giản. Nhưng nếu điều kiện là "phức tạp", hãy xem xét sử dụng các cách tiếp cận từ các câu trả lời khác.