drucken Anzahl in umgekehrter

aufgrund von: return false; - ich überlasse es Ihnen, herauszufinden, der rest..

In C++, die Sie nicht verwenden void main().
Ein 0 denn wenn Sie return false, ist das Ergebnis vom Typ bool implizit in einen int-Wert und wird gedruckt auf der Linie cout<<reverseNum(enternum);

Auch, In dieser Zeile double enternum = 0; Sie möchten eine Ganzzahl int.

Ihrem Programm sollte eine Funktion haben, die akzeptiert und integer und gibt eine Ganzzahl zurück in umgekehrter

Ihre reverseNum Funktion zurückgeben soll, die umgekehrte integer, nicht falsch. und es sollte nicht drucken die Anzahl wie auch, es sind die Anrufer, die angeblich um es zu drucken.

wenn man es tut:

i = reverseNum(1234);

dann sollte ich enthalten 4321 als ganze Zahl (NICHT als string).

der Grund Sie halten, immer 0 ist, denn false ist äquivalent zu 0 als integer.

Für viel Spaß, ich habe versucht, eine generische Implementierung, die unterstützt jede Integrale - oder floating-point - Typ unterstützt von Ihrem compiler.

Seien Sie gewarnt, es gibt eine Reihe von Fragen:

• Rückwärtsfahren eine floating-point-Zahl ist nicht gut definiert, semantisch (wie position der dezimal-separator? Wie gehen wir mit der exponentiellen Schreibweise?)
• floating-point-Typen sind Häufig ungenau (zumindest die gängigen IEEE-Formate sind) und damit die Skalierung der Eingabe wird die Einführung der künstlichen Nachkommastellen. Ich habe nicht viel Mühe zu tun, die richtige Rundung, so dass einige zahlen umkehren wird in seltsame Dinge (z.B. 123.0 umkehren könnten in 992.1 statt 321.0 (ungetestet für diesen Eingang, einige versuchen sich))
• die Umsetzung ist lachhaft Vorlage-glücklich. Denken Sie daran, wie der didaktische Teil dieses spielerische Antwort.

Oh, entfernen Sie den DEBUGTRACE-definition zu bekommen ... die debug-Ablaufverfolgung 🙂

Sehen Leben hier _{[klicken Sie auf]^TM}

#include <cmath>
#include <limits>
#include <iostream>

#define MAX_DECIMAL_FRACTION 5
#define DEBUGTRACE(x) //do { std::cerr << x; } while (false)

template <typename T, bool is_integer> struct reverse_impl;

template <typename T>
    struct reverse_impl<T, true>
{
    static T reverse(T input)
    {
        T output;

        for (output = 0; input; input/=10)
            output = (output * 10) + input % 10;

        return output;
    }
};

template <typename T>
    struct reverse_impl<T, false>
{
    static T reverse(T input)
    {
        if (std::abs(input) <= std::numeric_limits<T>::epsilon())
            return T(0);

        //scale input
        int log10 = (int) (std::log(input)/std::log(T(10)));
        input *= std::pow(10, MAX_DECIMAL_FRACTION);
        input = std::floor(input);
        input /= std::pow(10, log10+MAX_DECIMAL_FRACTION);

        DEBUGTRACE("debug: scaled " << input << " digits: ");

        int iteration = std::max(log10+MAX_DECIMAL_FRACTION, MAX_DECIMAL_FRACTION);

        if (std::floor(input) < 1)
        {
            input *= 10;
            iteration--;
        }

        T output;
        for (output = T(0); 
             iteration-- && std::floor(input) >= 1; 
             input-=std::floor(input), input*=T(10))
        {
            output = (output / T(10)) + std::floor(input);
            DEBUGTRACE(std::floor(input));
        }

        DEBUGTRACE(std::endl);
        return output * std::pow(10, log10);
    }
};

template <typename T>
    T reverse(T input)
{ 
    return reverse_impl<T, std::numeric_limits<T>::is_integer>::reverse(input); 
}

int main()
{
    std::cout << reverse(-123l) << std::endl;
    std::cout << reverse(123ul) << std::endl;

    std::cout << reverse(123456.0) << std::endl;
    std::cout << reverse(0.027f) << std::endl;

    return 0;
}