C++ быстрее, если инструкции else

Question

Я новый пользователь C++ и написал код, который работает вместе с другими функциями. Мне нужно было внести изменения в код с помощью if & else if, которые привели к завершению всего кода 4.6333 мин, по сравнению с 0,61 мин до модификации (обратите внимание, что эти длительности относятся ко всему коду, а не к примеру, который был вставлен ниже).

Ниже приведено «только» измененная часть в качестве примера (которая может выполняться в C++ отдельно).

У кого-нибудь есть предложение получить этот код быстрее?

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

int main() 
{ 
    static const double InflVecVals001[9] = { 100.0, 200.0, 300.0, 400.0, 500.0, 600.0, 700.0, 800.0, 900.0 }; 
    int FloorMnodeTagscol1[6] = { 11, 12, 13, 14, 15, 16 }; int FloorMnodeTagscol6[6] = { 61, 62, 63, 64, 65, 66 }; 
    int FloorMnodeTagscol2[6] = { 21, 22, 23, 24, 25, 26 }; int FloorMnodeTagscol7[6] = { 71, 72, 73, 74, 75, 76 }; 
    int FloorMnodeTagscol3[6] = { 31, 32, 33, 34, 35, 36 }; int FloorMnodeTagscol8[6] = { 81, 82, 83, 84, 85, 86 }; 
    int FloorMnodeTagscol4[6] = { 41, 42, 43, 44, 45, 46 }; int FloorMnodeTagscol9[6] = { 91, 92, 93, 94, 95, 96 }; 
    int FloorMnodeTagscol5[6] = { 51, 52, 53, 54, 55, 56 }; 

    int tagNode = 91; 
    double fact; 

    if ((tagNode == FloorMnodeTagscol1[0]) || (tagNode == FloorMnodeTagscol1[1]) || (tagNode == FloorMnodeTagscol1[2]) || (tagNode == FloorMnodeTagscol1[3]) || (tagNode == FloorMnodeTagscol1[4]) || (tagNode == FloorMnodeTagscol1[5])) 
    { 
     fact = InflVecVals001[0]; 
    } 
    else if ((tagNode == FloorMnodeTagscol2[0]) || (tagNode == FloorMnodeTagscol2[1]) || (tagNode == FloorMnodeTagscol2[2]) || (tagNode == FloorMnodeTagscol2[3]) || (tagNode == FloorMnodeTagscol2[4]) || (tagNode == FloorMnodeTagscol2[5])) 
    { 
     fact = InflVecVals001[1]; 
    } 
    else if ((tagNode == FloorMnodeTagscol3[0]) || (tagNode == FloorMnodeTagscol3[1]) || (tagNode == FloorMnodeTagscol3[2]) || (tagNode == FloorMnodeTagscol3[3]) || (tagNode == FloorMnodeTagscol3[4]) || (tagNode == FloorMnodeTagscol3[5])) 
    { 
     fact = InflVecVals001[2]; 
    } 
    else if ((tagNode == FloorMnodeTagscol4[0]) || (tagNode == FloorMnodeTagscol4[1]) || (tagNode == FloorMnodeTagscol4[2]) || (tagNode == FloorMnodeTagscol4[3]) || (tagNode == FloorMnodeTagscol4[4]) || (tagNode == FloorMnodeTagscol4[5])) 
    { 
     fact = InflVecVals001[3]; 
    } 
    else if ((tagNode == FloorMnodeTagscol5[0]) || (tagNode == FloorMnodeTagscol5[1]) || (tagNode == FloorMnodeTagscol5[2]) || (tagNode == FloorMnodeTagscol5[3]) || (tagNode == FloorMnodeTagscol5[4]) || (tagNode == FloorMnodeTagscol5[5])) 
    { 
     fact = InflVecVals001[4]; 
    } 
    else if ((tagNode == FloorMnodeTagscol6[0]) || (tagNode == FloorMnodeTagscol6[1]) || (tagNode == FloorMnodeTagscol6[2]) || (tagNode == FloorMnodeTagscol6[3]) || (tagNode == FloorMnodeTagscol6[4]) || (tagNode == FloorMnodeTagscol6[5])) 
    { 
     fact = InflVecVals001[5]; 
    } 
    else if ((tagNode == FloorMnodeTagscol7[0]) || (tagNode == FloorMnodeTagscol7[1]) || (tagNode == FloorMnodeTagscol7[2]) || (tagNode == FloorMnodeTagscol7[3]) || (tagNode == FloorMnodeTagscol7[4]) || (tagNode == FloorMnodeTagscol7[5])) 
    { 
     fact = InflVecVals001[6]; 
    } 
    else if ((tagNode == FloorMnodeTagscol8[0]) || (tagNode == FloorMnodeTagscol8[1]) || (tagNode == FloorMnodeTagscol8[2]) || (tagNode == FloorMnodeTagscol8[3]) || (tagNode == FloorMnodeTagscol8[4]) || (tagNode == FloorMnodeTagscol8[5])) 
    { 
     fact = InflVecVals001[7]; 
    } 
    else if ((tagNode == FloorMnodeTagscol9[0]) || (tagNode == FloorMnodeTagscol9[1]) || (tagNode == FloorMnodeTagscol9[2]) || (tagNode == FloorMnodeTagscol9[3]) || (tagNode == FloorMnodeTagscol9[4]) || (tagNode == FloorMnodeTagscol9[5])) 
    { 
     fact = InflVecVals001[8]; 
    } 
    else 
    { 
     fact = 1.0; 
    } 
    //cout << "\n tagnode:" << tagNode << endl; 
    //cout << "\n factor:" << fact << endl; 

    cin.get(); 
    return 0; 
} 

Answer 1

С вашего образца кода, вы можете просто

if ((tagNode - 1) % 10 < 6 && 11 <= tagNode && tagNode <= 96) { 
    fact = (tagNode/10) * 100.; 
} else { 
    fact = 1.; 
} 

Но если предположить, значения не просто диапазон, как в вашем примере, и что вы должны сделать отображение несколько раз, вы можете сделать что-то как:

static const std::map<int, double> m = { 
    { 11, 100.}, {12, 100.}, {13, 100.}, {14, 100.}, {15, 100.}, {16, 100.}, 
    { 21, 200.}, {22, 200.}, {23, 200.}, {24, 200.}, {25, 200.}, {26, 200.}, 
    { 31, 300.}, {32, 300.}, {33, 300.}, {34, 300.}, {35, 300.}, {36, 300.}, 
    { 41, 400.}, {42, 400.}, {43, 400.}, {44, 400.}, {45, 400.}, {46, 400.}, 
    { 51, 500.}, {52, 500.}, {53, 500.}, {54, 500.}, {55, 500.}, {56, 500.}, 
    { 61, 600.}, {62, 600.}, {63, 600.}, {64, 600.}, {65, 600.}, {66, 600.}, 
    { 71, 700.}, {72, 700.}, {73, 700.}, {74, 700.}, {75, 700.}, {76, 700.}, 
    { 81, 800.}, {82, 800.}, {83, 800.}, {84, 800.}, {85, 800.}, {86, 800.}, 
    { 91, 900.}, {92, 900.}, {93, 900.}, {94, 900.}, {95, 900.}, {96, 900.} 
}; 

auto it = m.find(tagNode); 

fact = ((it != m.end()) ? it-> second : 1.); 

Demo

Какие есть

• N log N для построения карты (сделано один раз).
• log(N) сложность поиска.

вместо вашего линейного поиска.