Вбудована версія функції повертає інше значення, ніж невбудована версія

Як дві версії однієї і тієї ж функції, що відрізняються лише тим, що вона вбудована, а інша - ні, можуть повертати різні значення? Ось деякий код, який я написав сьогодні, і я не впевнений, як він працює.

#include <cmath>
#include <iostream>

bool is_cube(double r)
{
    return floor(cbrt(r)) == cbrt(r);
}

bool inline is_cube_inline(double r)
{
    return floor(cbrt(r)) == cbrt(r);
}

int main()
{
    std::cout << (floor(cbrt(27.0)) == cbrt(27.0)) << std::endl;
    std::cout << (is_cube(27.0)) << std::endl;
    std::cout << (is_cube_inline(27.0)) << std::endl;
}

Я би очікував, що всі результати будуть рівні 1, але насправді це виводить (g ++ 8.3.1, без прапорів):

1
0
1

замість

1
1
1

Редагувати: clang ++ 7.0.0 виводить це:

0
0
0

та g ++ -швидше це:

1
1
1

Пояснення

Деякі компілятори (зокрема GCC) використовують більшу точність при обчисленні виразів під час компіляції. Якщо вираз залежить лише від постійних входів та літералів, він може обчислюватися під час компіляції, навіть якщо вираз не призначений змінній constexpr. Відбудеться це чи ні, залежить від:

• Складність виразу
• Поріг, який компілятор використовує як граничний показник при спробі виконати оцінку часу компіляції
• Інші евристики, що використовуються в особливих випадках (наприклад, коли дзвін лунає)

Якщо вираз надано явно, як у першому випадку, воно має меншу складність, і компілятор, ймовірно, оцінить його під час компіляції.

Подібним чином, якщо функція позначена як вбудована, компілятор, швидше за все, оцінить її під час компіляції, оскільки вбудовані функції підвищують поріг, при якому може відбутися оцінка.

Більш високі рівні оптимізації також збільшують цей поріг, як у прикладі -Ofast, де всі вирази оцінюються як істинні для gcc завдяки вищій точності оцінки часу компіляції.

Ми можемо спостерігати таку поведінку тут у провіднику компілятора. При компіляції з -O1 під час компіляції обчислюється лише функція, позначена вбудованим, але при -O3 обидві функції оцінюються під час компіляції.

• -O1: https://godbolt.org/z/u4gh0g
• -O3: https://godbolt.org/z/nVK4So

NB: У прикладах компілятора-дослідника я використовую printfзамість iostream, оскільки це зменшує складність основної функції, роблячи ефект більш помітним.

Демонстрація, що inlineне впливає на оцінку роботи

Ми можемо гарантувати, що жоден з виразів не обчислюється під час компіляції, отримуючи значення зі стандартного вводу, і коли ми це робимо, усі 3 вирази повертають false, як показано тут: https://ideone.com/QZbv6X

#include <cmath>
#include <iostream>

bool is_cube(double r)
{
    return floor(cbrt(r)) == cbrt(r);
}
 
bool inline is_cube_inline(double r)
{
    return floor(cbrt(r)) == cbrt(r);
}

int main()
{
    double value;
    std::cin >> value;
    std::cout << (floor(cbrt(value)) == cbrt(value)) << std::endl; // false
    std::cout << (is_cube(value)) << std::endl; // false
    std::cout << (is_cube_inline(value)) << std::endl; // false
}

На відміну від цього прикладу , де ми використовуємо ті самі налаштування компілятора, але надаємо значення під час компіляції, що призводить до більш точної оцінки часу компіляції.

Як зазначалося, використання ==оператора для порівняння значень з плаваючою комою призвело до різних результатів з різними компіляторами та на різних рівнях оптимізації.

Одним хорошим способом порівняння значень з плаваючою точкою є тест відносного допуску, описаний у статті: Допуски з плаваючою комою переглянуті .

Спочатку ми обчислюємо значення Epsilon( відносного допуску ), яке в цьому випадку буде:

double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();

А потім використовуйте його як для вбудованих, так і для не вбудованих функцій таким чином:

return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);

Зараз функціями є:

bool is_cube(double r)
{
    double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();    
    return (std::fabs(std::floor(std::cbrt(r)) - std::cbrt(r)) < Epsilon);
}

bool inline is_cube_inline(double r)
{
    double Epsilon = std::max(std::cbrt(r), std::floor(std::cbrt(r))) * std::numeric_limits<double>::epsilon();
    return (std::fabs(std::round(std::cbrt(r)) - std::cbrt(r)) < Epsilon);
}

Тепер результат буде таким, як очікувалось ( [1 1 1]) з різними компіляторами та на різних рівнях оптимізації.

Демо в прямому ефірі