C++ gerade oder ungerade Anzahl Programm funktioniert nicht richtig

Question

Ich bin neu in C++, und ich tat die Übung hier:

http://www.learncpp.com/cpp-tutorial/32-arithmetic-operators/

ich tat Quiz 2, die mir ein Programm co schaffen erzählt, dass empfängt eine Ganzzahl von user und gibt den Wert true für diese Ganzzahl gerade aus. Also habe ich den folgenden Code erstellt:

#include "stdafx.h" 
#include <iostream> 

int getInteger() 
{ 
    std::cout << "Insert an integer" << "\n"; 

    int8_t x; 

    std::cin >> x; 

    return x; 
} 

bool isEven(int8_t x) 
{ 
    bool b; 
    b = false; 

    std::cout << x % 2 << "\n"; 

    if(x%2 == 0) 
     { 
      b = true; 
     } 

    return b; 
} 

void printResult(bool b) 
{ 
    std::cout << std::boolalpha; 
    std::cout << b << "\n"; 
} 

int main() 
{ 
    int8_t x; 
    x = getInteger(); 

    bool b; 
    b = isEven(x); 

    printResult(b); 

    return 0; 
} 

Also, hier ist das Problem. Wenn ich etwas nicht vermisse, sollte das funktionieren, oder? Und es tut, aber nur für Ganzzahlen, die ich von 0 bis 10 eingib. Aus irgendeinem Grund, wenn ich 10 oder 12 gebe, druckt es falsch, aber es funktioniert gut mit 2, 4, 6 und 8. Warum passiert das ?

Answer 1

Sie haben folgenden Code:

int8_t x; 
std::cin >> x; 

int8_t ist nur ein Alias ​​für char für Ihre Plattform und std::istream Wenn der Typ char als Argument eingegeben wird, wird ein Zeichen, keine ganze Zahl eingegeben. Also wäre die Lösung, den Typ int zu verwenden, und Sie sollten es von Anfang an verwenden, da es in diesem Fall überhaupt keinen Grund gibt, int8_t zu verwenden.

Answer 2

Diese Funktion gibt einen anderen Typ als die es zurückgeben soll:

int getInteger() 
{ 
    std::cout << "Insert an integer" << "\n"; 

    int8_t x; 

    std::cin >> x; 

    return x; 
} 

int sollte in Ordnung statt int8_t arbeiten und sehen Sie hier, warum Documentation

Answer 3

Wie haben Sie es getInteger() nimmt Textzeichen übersetzt Eingang, keine Zahlen, da int8_t erweitert tatsächlich char

Um dass eine ganze Zahl im 1. Platz und Guss zur int8_t Art nehmen zu beheben.

int getInteger() 
{ 
    std::cout << "Insert an integer" << "\n"; 

    int x; // <<<< 
    std::cin >> x; 
    return x; 
} 

---

x = (int8_t)getInteger(); 

Answer 4

Der Grund, dass Alex auf learncpp.com gibt an, dass es für uns besser ist, Die Ganzzahlen mit fester Breite sind, weil die Ergebnisse des Programms nicht variieren, wenn es auf verschiedenen Compilern kompiliert wird. Dies ist nicht der Fall bei integrierten Typen mit fester Breite wie char und int, da die Größe des Typs zwischen Compilern variieren wird. Wie @Slava darauf hinweist, int8_t ist ein Integral-Typ mit fester Breite für char, so dass beide mit Variablen verwendet werden, die nur ein einzelnes Zeichen im Speicher speichern.

Verwenden Sie Ganzzahlen mit fester Breite, wenn das Programm in einem anderen Compiler oder einer anderen Maschine verwendet werden kann, und es ist wichtig, dass die Ergebnisse compiler- und plattformunabhängig sind. Da das Programm nach einer Benutzereingabe für eine Ganzzahl fragt, um eine Ganzzahl mit fester Breite zu verwenden, ist es am besten, int32_t zu verwenden. int8_t und 'char' wäre geeignet, um Ziffern zu erhalten (d. H. 0-9). int16_t ist geeignet für ganze Zahlen zwischen -2^16/2 (was -2^15 entspricht) und 2^15-1 (d. H. Zwischen -32 768 und 32 767). 'int32_t' ist geeignet für ganze Zahlen zwischen -2^31 und 2^31-1 (d. h. zwischen -2 147 483 648 und 2 147 483 647).

Wie Alex später in 5.10 — std::cin, extraction, and dealing with invalid text input erklärt, ist es wichtig, alle möglichen ungültigen Benutzereingaben zu behandeln.

Hier einige aktualisierte Code, der Griff ungültige Benutzereingaben arbeiten, und Schleife um den Benutzer zu fragen, ob sie, ob eine andere Zahl überprüfen möchten gerade oder ungerade ist, und so tun:

// StackOverflow C++ Even or Odd number program.cpp : Defines the entry point for the console application. 
 
// 
 

 
#include "stdafx.h" 
 
#include <iostream> // for cin and cout 
 
//include <cmath> \t // pow is no longer used and is commented out below. 
 
#include <cstdint> // std::int32_t 
 

 
// I changed the variable output for the function to int32_t, since that is the type being returned. 
 
std::int32_t getInteger() 
 
{ 
 
\t /* If you don't understand some parts, like do-while loops and 
 
\t handling invalid user input, come back to it after learning it, 
 
\t and just focus on what you can understand. 
 
\t */ 
 

 
\t // Use int32_t since the user input could potentially be a very large number. 
 
\t std::int32_t x{ 0 }; 
 
\t bool notInt32t = 1; 
 
\t bool cinFail{1}; 
 
\t do 
 
\t { 
 
\t \t // Don't use an '/n' character when getting user input, it makes more sense to get it on the same line as the prompt. 
 
\t \t std::cout << "Enter an integer: "; 
 

 
\t \t std::cin >> x; 
 

 
\t \t cinFail = std::cin.fail(); 
 

 
\t \t if (cinFail) 
 
\t \t { 
 
\t \t \t std::cin.clear(); 
 
\t \t \t std::cin.ignore(32767, '\n'); 
 
\t \t \t std::cout << "Oops, that input is invalid. This may be because you entered a number larger \n"; 
 
\t \t \t std::cout << "than 2147483647 (which equals 2^31-1), or less than -2147483648 (which equals -2^31); \n"; 
 
\t \t \t std::cout << "or you did not enter an integer only. Please try again.\n"; 
 
\t \t } 
 
\t \t // remove any extraneous input, which would otherwise be left in the buffer, causing unexpected results. 
 
\t \t else 
 
\t \t \t std::cin.ignore(32767,'\n'); 
 

 
\t \t /*Commented out because this will not work, it will fail to extract. Left in the code for education purposes. 
 
\t \t notInt32t = ((x > (pow(2.0, 31.0) - 1)) || (x < -pow(2.0, 31.0)) || !(x % 1 == 0)); 
 
\t \t if (notInt32t) 
 
\t \t \t std::cout << "Oops, you entered incorrectly!\n"; 
 
\t \t */ 
 
\t } while (cinFail); 
 

 
\t return x; 
 
} 
 

 
bool isEven(std::int32_t x) 
 
{ 
 
\t bool isEven; 
 

 
\t isEven = (x % 2 == 0) ?(true):(false); 
 

 
\t return isEven; 
 
} 
 

 
/* I have commented this out and rewrote it, as it is ambiguous. 
 
void printResult(bool b) 
 
{ 
 
\t std::cout << std::boolalpha; 
 
\t std::cout << b << "\n"; 
 
}*/ 
 

 
void printIsEven() 
 
{ 
 
\t auto x = getInteger(); 
 

 
\t if (isEven(x)) 
 
\t \t std::cout << x << " is an even integer.\n"; 
 
\t else 
 
\t \t std::cout << x << " is an odd integer.\n"; 
 
} 
 
void printIsEvenLoop() 
 
{ 
 
\t std::int8_t yOrN{}; 
 
\t bool isLoop{ true }; 
 
\t bool cinFail{ false }; 
 
\t bool isYOrN{ false }; 
 
\t while (isLoop) 
 
\t { 
 
\t \t do 
 
\t \t { 
 
\t \t \t std::cout << "Would you like to check whether another integer is even or odd?\n"; 
 
\t \t \t std::cout << "Enter y or n (yes or no): "; 
 
\t \t \t std::cin >> yOrN; 
 

 
\t \t \t cinFail = std::cin.fail(); 
 

 
\t \t \t if (cinFail) 
 
\t \t \t { 
 
\t \t \t \t std::cin.clear(); 
 
\t \t \t \t std::cin.ignore(32767, '\n'); 
 
\t \t \t \t std::cout << "Oops, that input is invalid! Please try again.\n"; 
 
\t \t \t } 
 
\t \t \t // remove any extraneous input, which would otherwise be left in the buffer, causing unexpected results. 
 
\t \t \t else 
 
\t \t \t \t std::cin.ignore(32767, '\n'); 
 

 
\t \t \t isYOrN = ((yOrN == 'y' || yOrN == 'n')); 
 
\t \t \t if (!isYOrN) 
 
\t \t \t \t std::cout << "Oops, you entered incorrectly! Please try again.\n"; 
 

 
\t \t } while (cinFail || !isYOrN); 
 

 
\t \t if (yOrN == 'y') 
 
\t \t { 
 
\t \t \t isLoop = true; 
 
\t \t \t printIsEven(); 
 
\t \t } 
 
\t \t else 
 
\t \t \t isLoop = false; 
 
\t } 
 
\t 
 
} 
 
int main() 
 
{ 
 
\t printIsEven(); 
 
\t 
 
\t printIsEvenLoop(); 
 

 
\t return 0; 
 
}