¿Evitando la declaración if dentro de un bucle for?

Tengo una clase llamada Writerque tiene una función writeVectorcomo esta:

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

Estoy tratando de no tener un código duplicado, sin dejar de preocuparme por el rendimiento. En la función, estoy haciendo la if (index)verificación en cada ronda de mi forbucle, aunque el resultado es siempre el mismo. Esto va en contra de "preocuparse por el rendimiento".

Podría evitarlo fácilmente colocando el cheque fuera de mi forbucle. Sin embargo, obtendré un montón de código duplicado:

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

Así que estas son dos soluciones "malas" para mí. Lo que he estado pensando son dos funciones privadas, una de ellas sale del índice y luego llama a la otra. El otro solo supera el valor. Sin embargo, no puedo averiguar cómo usarlo con mi programa, todavía necesitaría el ifcheque para ver a cuál llamar ...

Según el problema, el polimorfismo parece una solución correcta. Pero no veo cómo debería usarlo aquí. ¿Cuál sería la forma preferida de resolver este tipo de problema?

Este no es un programa real, solo estoy interesado en aprender cómo se debe resolver este tipo de problema.

Pase en el cuerpo del bucle como un funtor. Se inserta en tiempo de compilación, sin penalización de rendimiento.

La idea de pasar lo que varía es omnipresente en la biblioteca estándar de C ++. Se llama patrón de estrategia.

Si se le permite usar C ++ 11, puede hacer algo como esto:

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

Este código no es perfecto pero entiendes la idea.

En el antiguo C ++ 98 se ve así:

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

Una vez más, el código está lejos de ser perfecto, pero te da la idea.

En la función, estoy haciendo la verificación if (index) en cada ronda de mi bucle for, aunque el resultado es siempre el mismo. Esto va en contra de "preocuparse por el rendimiento".

Si este es realmente el caso, el predictor de rama no tendrá problemas para predecir el resultado (constante). Como tal, esto solo causará una leve sobrecarga por errores de predicción en las primeras iteraciones. No hay nada de qué preocuparse en términos de rendimiento.

En este caso, abogo por mantener la prueba dentro del ciclo para mayor claridad.

Para ampliar la respuesta de Ali, que es perfectamente correcta pero aún duplica algo de código (parte del cuerpo del bucle, desafortunadamente, esto es difícilmente evitable cuando se usa el patrón de estrategia) ...

Concedido en este caso particular, la duplicación de código no es mucha, pero hay una manera de reducirla aún más, lo cual es útil si el cuerpo de la función es más grande que unas pocas instrucciones .

La clave es utilizar la capacidad del compilador para realizar una eliminación constante de plegado / código muerto . Podemos hacer eso asignando manualmente el valor de tiempo de ejecución de indexa un valor de tiempo de compilación (fácil de hacer cuando hay solo un número limitado de casos, dos en este caso) y usar un argumento de plantilla que no sea de tipo que se conoce en la compilación -hora:

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

De esta manera terminamos con un código compilado que es equivalente a su segundo ejemplo de código (externo if/ interno for) pero sin duplicar el código nosotros mismos. Ahora podemos hacer que la versión de la plantilla sea writeVectortan complicada como queramos, siempre habrá una sola pieza de código para mantener.

Observe cómo la versión de la plantilla (que toma una constante de tiempo de compilación en forma de un argumento de plantilla sin tipo) y la versión sin plantilla (que toma una variable de tiempo de ejecución como argumento de función) están sobrecargadas. Esto le permite elegir la versión más relevante en función de sus necesidades, teniendo una sintaxis bastante similar y fácil de recordar en ambos casos:

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

En la mayoría de los casos, su código ya es bueno para el rendimiento y la legibilidad. Un buen compilador es capaz de detectar invariantes de bucle y realizar las optimizaciones adecuadas. Considere el siguiente ejemplo que está muy cerca de su código:

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

Estoy usando la siguiente línea de comando para compilarlo:

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

Entonces, descarguemos el ensamblaje:

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

El resultado ensamblado de write_vectores:

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)

Podemos ver que al inicio de la función, verificamos el valor y saltamos a uno de los dos bucles posibles:

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

Por supuesto, esto solo funciona si un compilador es capaz de detectar que una condición es invariante real. Por lo general, funciona perfectamente para banderas y funciones en línea simples. Pero si la condición es "compleja", considere usar enfoques de otras respuestas.