Início / coding / Perguntas / 79098716
Accepted
rkc137
Asked: 2024-10-17 23:05:10 +0800 CST

é possível escrever um loop sem verificar a condição interna, sem duplicar o código

  • 772

Esta não é a primeira vez que me deparo com uma situação em que há um ciclo dentro do código que depende de circunstâncias externas.

Por exemplo:

bool is_sqrt;
std::cin >> is_sqrt;
for(auto &i : vector)
{
    do_smth_1(i);
    //...
    do_smth_n(i);
    if(is_sqrt)
        std::cout << std::sqrt(i);
    else
        std::cout << i * i;
    do_smth(i);
}

Torna-se óbvio que você pode simplesmente mover a condição para fora do loop simplesmente escrevendo uma alternativa para ela em else:

if(is_sqrt) for(auto &i : vector)
{
    do_smth_1(i);
    //...
    do_smth_n(i);
    std::cout << std::sqrt(i);
    do_smth(i);
}
else for(auto &i : vector)
{
    do_smth_1(i);
    //...
    do_smth_n(i);
    std::cout << i * i;
    do_smth(i);
}

Depois de algum tempo, o código cresce e os erros começam a aparecer por causa da necessidade de duplicar o código (e o fato da duplicação em si não é muito menos confuso). Eu vi o uso de std::function/ *functioncomo uma solução, mas obviamente ambos os métodos são piores do que a duplicação de código em termos de desempenho. Na realidade, eu realmente não preciso dessa diferença de velocidade, a questão é apenas de interesse.

Se não há solução para essa situação em C++, talvez alguém tenha visto em outras linguagens? Seria muito interessante ver.

c++

4 respostas

  1. Best Answer

    Com o modelo, você pode fazer

    template <bool B>
void doLoop(const std::vector<int>& vector /*...*/)
{
    for (auto &i : vector)
    {
        do_smth_1(i);
        //...
        do_smth_n(i);
        if constexpr (B) {
            std::cout << std::sqrt(i);
        } else {
            std::cout << i * i;
        }
        do_smth(i);
    }
}

void foo()
{
    // ...
    bool is_sqrt;
    std::cin >> is_sqrt;
    if (is_sqrt) { doLoop<true>(vector); }
    else { doLoop<false>(vector); }
}

    ou

    template <template F>
void doLoop(const std::vector<int>& vector, F&& f /*...*/)
{
    for (auto &i : vector)
    {
        do_smth_1(i);
        //...
        do_smth_n(i);
        f(i);
        do_smth(i);
    }
}

void foo()
{
    // ...
    bool is_sqrt;
    std::cin >> is_sqrt;
    if (is_sqrt) { doLoop(vector, [](int i){ std::cout << std::sqrt(i); }); }
    else { doLoop(vector, [](int i){ std::cout << i * i; }); }
}
    • 7

  2. Você pode criar um ponteiro de função que aponta para a função que você deseja chamar:

    double sqrt(double x) {
    return std::sqrt(x);
}

double square(double x) {
    return x * x;
}

    bool is_sqrt;
std::cin >> is_sqrt;

auto func = is_sqrt ? sqrt : square; // select function

for (auto &i : vector) {
    do_smth_1(i);
    //...
    do_smth_n(i);
    std::cout << func(i); // call the function
    do_smth(i);
}

    Observação: std::sqrtnão é uma função endereçável , portanto, precisa ser encapsulada por uma função que seja.

    • 3

  3. Você pode evitar std::functione usar lambdas diretamente, que a maioria dos compiladores otimiza hoje em dia, então não deve haver diferença no final para a versão totalmente duplicada do código:

    auto process = [&] (auto const& is_sqrt_) {
   using is_sqrt_t = std::decay_t<decltype(is_sqrt_)>;
   constexpr auto const is_sqrt = is_sqrt_t::value;

   for (auto& i : vector) {
       // common code
       if constexpr (is_sqrt) {
          // variant 1
       } else {
          // variant 2
       }
       // more common code
   }
};

if (is_sqrt)
    process(std::true_type{});
else
    process(std::false_type{});

    O código precisa <type_traits>ser incluído, e C++17 para if constexpr.

    Você pode generalizar isso além de verdadeiro/falso via std::integral_constant, mas precisa despachar explicitamente todos os valores possíveis que ele poderia ter. (Não escala bem se você tiver mais do que um punhado de valores possíveis que deseja despachar.)

    • 2

  4. Diretrizes básicas do C++ Per.1: Não otimize sem motivo
    Motivo:

    Se não houver necessidade de otimização, o principal resultado do esforço será mais erros e maiores custos de manutenção.

    Quanto a mim, usarei

    std::cout << (is_sqrt ? std::sqrt(i) : i*i);

    Acho que isso pode ser um pouco mais rápido e não introduz muita complexidade .

    • 0

relate perguntas