Menghindari pernyataan if di dalam perulangan for?

Saya memiliki kelas yang disebut Writeryang memiliki fungsi writeVectorseperti:

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

Saya mencoba untuk tidak memiliki kode duplikat, sambil tetap mengkhawatirkan kinerjanya. Dalam fungsinya, saya melakukan if (index)pengecekan pada setiap putaran saya for-loop, meskipun hasilnya selalu sama. Ini bertentangan dengan "mengkhawatirkan kinerja".

Saya dapat dengan mudah menghindari ini dengan menempatkan centang di luar for-loop saya . Namun, saya akan mendapatkan banyak kode duplikat:

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

Jadi ini adalah solusi yang "buruk" untuk saya. Apa yang saya pikirkan, adalah dua fungsi pribadi, salah satunya keluar dari indeks dan kemudian memanggil yang lain. Yang lainnya hanya mengeluarkan nilainya. Namun, saya tidak tahu bagaimana menggunakannya dengan program saya, saya masih memerlukan ifcek untuk melihat mana yang harus dihubungi ...

Berdasarkan masalah tersebut, polimorfisme sepertinya solusi yang tepat. Tetapi saya tidak dapat melihat bagaimana saya harus menggunakannya di sini. Apa cara yang lebih disukai untuk memecahkan masalah semacam ini?

Ini bukan program nyata, saya hanya tertarik untuk mempelajari bagaimana masalah seperti ini harus diselesaikan.

Lewati badan loop sebagai functor.Itu menjadi inline pada waktu kompilasi, tidak ada penalti kinerja.

Ide untuk meneruskan apa yang bervariasi ada di mana-mana di C ++ Standard Library. Itu disebut pola strategi.

Jika Anda diizinkan menggunakan C ++ 11, Anda dapat melakukan sesuatu seperti ini:

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

Kode ini tidak sempurna tetapi Anda mengerti.

Di C ++ 98 lama terlihat seperti ini:

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

Sekali lagi, kode tersebut jauh dari sempurna tetapi memberi Anda ide.

Dalam fungsinya, saya melakukan pemeriksaan if (indeks) pada setiap putaran for-loop saya, meskipun hasilnya selalu sama. Ini bertentangan dengan "mengkhawatirkan kinerja".

Jika memang demikian, branch predictor tidak akan memiliki masalah dalam memprediksi hasil (konstan). Dengan demikian, ini hanya akan menyebabkan overhead ringan untuk kesalahan prediksi dalam beberapa iterasi pertama. Tidak ada yang perlu dikhawatirkan dalam hal performa

Dalam hal ini saya menganjurkan untuk menjaga tes di dalam loop untuk kejelasan.

Untuk memperluas jawaban Ali, yang benar-benar benar tetapi masih menduplikasi beberapa kode (bagian dari badan perulangan, sayangnya hal ini hampir tidak dapat dihindari saat menggunakan pola strategi) ...

Memang dalam kasus khusus ini duplikasi kode tidak banyak tetapi ada cara untuk menguranginya lebih banyak lagi, yang berguna jika badan fungsi lebih besar dari hanya beberapa instruksi .

Kuncinya adalah menggunakan kemampuan kompiler untuk melakukan penghapusan kode lipat / mati secara konstan . Kita dapat melakukannya dengan memetakan nilai runtime secara manual ke nilai indexwaktu kompilasi (mudah dilakukan jika jumlah kasus terbatas - dua dalam kasus ini) dan menggunakan argumen template non-tipe yang dikenal pada kompilasi -waktu:

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

Dengan cara ini kita berakhir dengan kode terkompilasi yang setara dengan contoh kode kedua Anda (luar if/ dalam for) tetapi tanpa menduplikasi kode itu sendiri. Sekarang kita dapat membuat versi template writeVectorserumit yang kita inginkan, akan selalu ada satu kode yang harus dipertahankan.

Perhatikan bagaimana versi template (yang mengambil konstanta waktu kompilasi dalam bentuk argumen template non-tipe) dan versi non-template (yang menggunakan variabel runtime sebagai argumen fungsi) kelebihan beban. Ini memungkinkan Anda untuk memilih versi yang paling relevan tergantung pada kebutuhan Anda, memiliki sintaks yang agak mirip dan mudah diingat dalam kedua kasus:

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

Dalam kebanyakan kasus, kode Anda sudah bagus untuk performa dan keterbacaan. Kompilator yang baik mampu mendeteksi invarian loop dan melakukan pengoptimalan yang sesuai. Pertimbangkan contoh berikut yang sangat dekat dengan kode Anda:

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

Saya menggunakan baris perintah berikut untuk mengkompilasinya:

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

Lalu, mari kita buang perakitan:

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

Hasil perakitan write_vectoradalah:

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)

Kita dapat melihat, bahwa atas permintaan fungsi, kita memeriksa nilainya dan melompat ke salah satu dari dua kemungkinan loop:

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

Tentu saja, ini hanya berfungsi jika kompiler mampu mendeteksi bahwa suatu kondisi adalah invarian aktual. Biasanya, ini berfungsi sempurna untuk flag dan fungsi inline sederhana. Tetapi jika kondisinya "kompleks", pertimbangkan untuk menggunakan pendekatan dari jawaban lain.