Почему делает (интервал) 55 == 54 в C++?

Из-за округления плавающей точки, те 55 строк вычисляют что-то как 54,99999. Кастинг вдвое большего по сравнению с интервалом усекает.99999 сразу же.

На моей машине, печатая столбец, отображающийся (currentFib-(int)currentFib) выставочные ошибки на порядке 1.42109e-14. Таким образом, это больше похоже 0.999999999999986.

Хорошо, короткий ответ что не находится ни в каких условиях, должен (интервал) 55 == 54, таким образом, необходимо начать спрашивать себя, что действительно делает связанная строка кода.

Первый вопрос: как сильно == связывает по сравнению с преобразованием типа?

Я знаю, что это не собирается помогать с Вашим реальным вопросом, но Вы упомянули изучение C++. Я рекомендовал бы сохранить максимально близко к ANSI для изучения целей. Я думаю, что это /Za на MSVC (который является тем, что Вы, вероятно, используете), или -ansi -pedantic на GCC.

, В частности, необходимо использовать одну из этих подписей для main, пока у Вас нет хорошей (определенной для платформы) причины сделать иначе:

int main(int argc, char *argv[]);
int main(int argc, char **argv); // same as the first
int main();

... вместо любой определенной для платформы версии, такой как этот пример (только для Windows):

#include <windows.h> // defines _TCHAR and _tmain
int _tmain(int argc, _TCHAR* argv[]); // win32 Unicode vs. Multi-Byte

Shog9 имеет, это правильный, с помощью типа дважды для проблемы как это не является лучший способ пойти, если Вы собираетесь бросить вещи к ints. Если Ваш компилятор поддерживает его, необходимо использовать длинное длинное или некоторый другой целый тип на 64 бита, который будет почти наверняка содержать результат суммы весь даже условия меньше чем 4 миллиона из последовательности Fibonacci.

, Если мы используем то, что последовательность Fibonacci следует за шаблоном, нечетным нечетный даже нечетный нечетный даже..., что-то следующим образом должно добиться цели.

...
unsigned int fib[3];
fib[0]=1;
fib[1]=1;
fib[2]=2;

unsigned long long sum=0;

while(fib[2]<4000000)
{
    sum+=fib[2];

    fib[0]=(fib[1]+fib[2]);
    fib[1]=(fib[2]+fib[0]);
    fib[2]=(fib[0]+fib[1]);
}

std::cout<<"The sum is: "<<sum<<". \n";
....

, который должен добиться цели, могли бы быть еще более быстрые пути, но этот является довольно прямым и легким читать.

Рассмотрение его я понимаю, что Вам могло, вероятно, сойти с рук стандартное неподписанное целое число на 32 бита как число суммы, но я оставлю его, как на всякий случай.

Дополнительно Ваш код делает большое количество вызовов функции к генерированию энной функции Числа Фибоначчи. Достойный оптимизирующий компилятор встроит эти вызовы, но если он не сделает затем вещей, то замедлится, так как вызовы функции являются более дорогими, чем другие методы.

Я согласовываю 100% с ответом shog9 - с алгоритмом, Вы раньше вычисляли Fibonacci, необходимо быть действительно осторожными со значениями с плавающей точкой. Я нашел что страница cubbi.com: числа Фибоначчи в C++ , кажется, показывают другие способы получить их.

я навел справки о хорошей идее о том, как сделать Вашу реализацию случаев дескриптора GenerateNthFibonacciNumber, куда она возвращает двойные 54.999999, но когда Вы бросаете к интервалу или длинному, Вы добираетесь 54.

я столкнулся с тем, что, кажется, разумное решение в C++, Округляющийся , который я адаптировал ниже в Вашем коде.

кроме того, Это не огромно соглашение, но можно хотеть предварительно вычислить PHI, затем или передать его в качестве параметра или сослаться на него как на глобальное - теперь Вы повторно вычисляете его каждый раз, когда Вы вызываете функцию.

double GenerateNthFibonacciNumber(const int n)
{
        //This generates the nth Fibonacci Number using Binet's Formula   
        const double PHI = (1.0 + sqrt(5.0)) / 2.0;
        double x = ((pow(PHI,n)-pow(-1.0/PHI,n)) / sqrt(5.0));
        // inspired by http://www.codingforums.com/archive/index.php/t-10827.html
        return ((x - floor(x)) >= 0.5) ? ceil(x) : floor(x);
}

Наконец, вот то, как я переписал Ваш Решать () метод так, чтобы GenerateNthFibonacciNumber (FibIndex) только назвали в одном месте в коде. Я также добавил столбец с текущим рабочим общим количеством ровных условий Fibonacci к Вашему выводу:

double Solve() {
    long FibIndex = 0;
    double result = 0.0;
    double oldresult = 0.0;
    int done = 0;
    const double PHI = (1.0 + sqrt(5.0)) / 2.0;

    while (!done)
    {
        double currentFib = GenerateNthFibonacciNumber(++FibIndex);
        if ((int)currentFib % 2 == 0)
        {
            oldresult = result;

            if (currentFib >= 4000000.0)
            {
                done = 1;
            }
            else
            {
                result += currentFib;
            }

        }
        cout << currentFib << " " << (int)currentFib << " " << (int)currentFib % 2 << " " << (int)result << "\n";       
    }
    return result;
}

Все вышеупомянутые предложения для не использования значений с плавающей точкой для целочисленной математики стоит отметить!

, Если Вы хотите целое число, "округляющееся" для положительных значений с плавающей точкой так, чтобы значения с дробным компонентом ниже 0,5 раундов к следующему самому низкому целому числу и значения с дробным компонентом 0,5 или большим раундом к следующему более высокому целому числу, например,

0.0 = 0
0.1 = 0
0.5 = 1
0.9 = 1
1.0 = 1
1.1 = 1
...etc...    

Добавили 0.5 к значению, которое Вы бросаете.

double f0 = 0.0;
double f1 = 0.1;
double f2 = 0.5;
double f3 = 0.9;

int i0 = ( int )( f0 + 0.5 );  // i0 = 0
int i1 = ( int )( f1 + 0.5 );  // i1 = 0
int i2 = ( int )( f2 + 0.5 );  // i2 = 1
int i3 = ( int )( f3 + 0.5 );  // i3 = 1

Взломайте код для generatring при плавании времен, число не ведет себя способ, которым мы думаем при использовании в долгом выражении... взламывают код и проверяют его.