Wie kann ich überprüfen, ob eine als String gespeicherte Zahl (double type) eine gültige doppelte Zahl in C++ ist?

Question

Ich habe ein Problem mit einem Programm, an dem ich in C++ arbeite. Ich bitte den Benutzer, eine gültige Nummer einzugeben. Ich nehme es als eine Zeichenkette auf, weil die bestimmte Aufgabe, die ich mache, es auf lange Sicht einfacher macht. Für die grundlegende Fehlerprüfung möchte ich überprüfen, ob die eingegebene Nummer eine gültige Nummer ist. Beispiel:

Enter number: 3.14 
This would be valid 

Enter number: 3.1456.365.12 
This shouldn't be valid 

Answer 1

Ich denke, boost :: lexical_cast Sie hier

Answer 2

helfen sollten Wenn Sie keine Schub haben, können Sie immer strtod

Answer 3

Ah verwenden können, ich liebte diese Zuordnungen. Ein guter alter Hand geschriebener Lexer ist der Weg zu gehen (da Sie noch in den Anfangstagen sind - versuchen Sie nicht, boost gerade noch zu verwenden). Sie sind schnell, einfach zu schreiben und extrem lustig zu spielen. Wenn Sie eine Kopie von Levines Buch über Lex/Yacc erhalten können, schauen Sie sich die ersten paar Kapitel für Ideen an.

Answer 4

können Sie verwenden strtoX (wobei X f für Schwimmer, l für lange, ul für unsigned long, etc.), für die Art der Nummer wählen Sie wollen. Einer der Parameter, die Sie angeben, ist ein "end pointer", der auf das erste Zeichen in der Zeichenfolge verweist, das in den Zielnummerntyp nicht konvertiert werden konnte.

In Ihrem Fall suchen Sie offenbar, dass der Endzeiger am Ende der Zeichenfolge stehen muss, um anzuzeigen, dass alle Zeichen in der Zeichenfolge in den Zieltyp konvertiert wurden.

Edit: Sorry, habe nicht bemerkt, dass du "double" im Titel erwähnt hast (aber nicht die Frage selbst). In diesem Fall würden Sie strtod verwenden, wie ein paar andere auch empfohlen haben.

Answer 5

Der beste Weg ist, einen tatsächlichen Versuch zu machen, um Ihre Zeichenfolge double unter Verwendung eines beliebigen der Standard- und/oder idiomatische Weise wandeln die Umwandlung zu tun, und danach auf Fehler überprüfen. In C wären das Funktionen aus der strto... Gruppe (die natürlich auch in C++ perfekt verwendbar sind). In C++ können Sie Stream-basierte Konvertierungssprache verwenden.

Eine Sache, auf die man achten sollte, ist, dass die übliche Konvention in Standardkonvertierungsmethoden darin besteht, "so viel wie möglich" zu konvertieren und keine zusätzlichen Zeichen als Fehler zu betrachten. Zum Beispiel wird eine Zeichenkette "123abc" normalerweise als gültige Eingabe betrachtet, wobei nur der Teil "123" umgewandelt wird. Alle verwendbaren Methoden bieten Ihnen die Möglichkeit, die Tatsache zu erkennen, dass nach der tatsächlichen Zahl noch etwas vorhanden ist, wenn Sie diese Situation als Fehler behandeln wollen. Es liegt jedoch an Ihnen, die zusätzlichen Schritte zur Durchführung dieser Überprüfung durchzuführen.

Answer 6

Verwenden Sie strtod, das eine Zeichenfolge in ein Double konvertiert und alle Zeichen zurückgibt, die nicht als Teil des Double interpretiert werden konnten.

double strtod(const char* nptr, char** endptr) 

So:

char* input = "3.1456.365.12"; 
char* end; 

strtod(input, &end); 
if (*input == '\0') 
{ 
    printf("fail due to empty string\n"); 
} 
if (end == input || *end != '\0') 
{ 
    printf("fail - the following characters are not part of a double\n%s\n", end); 
} 

Answer 7

Eine einfache Möglichkeit ist, die sscanf-Funktion:

const char * num_as_str = "3.1416"; 
double num; 

if(std::sscanf(num_as_str, "%lg", &num) == 1) 
{ 
    std::cout << "You correctly entered the number " << num << "\n"; 
} 

Wenn Sie Lust bekommen möchten, können Sie istringstream verwenden:

std::istringstream iss(num_as_str); 
if(iss >> num) 
{ 
    std::cout << "You correctly entered the number " << num << "\n"; 
} 

Wenn Sie e xtra-fancy können Sie boost des lexical_cast verwenden:

try 
{ 
    num = boost::lexical_cast<double>(num_as_str); 
} 
catch(boost::bad_lexical_cast &) 
{ 
    std::cout << "What you entered is not a proper number" << num << "\n"; 
} 

Answer 8

Ein Beispiel unter Verwendung von nur Standard C++:

#include <sstream> 

// ... 

double dbl = 0.0; 
std::istringstream num("3.1456.365.12"); 

num >> dbl; 

if(!num.fail() && 
    num.eof()) // This second test is important! This makes sure that the entire string was converted to a number 
{ 
    // success 
} 
else 
{ 
    // failure 
} 

Bonus generische Template-Funktion Version:

#include <sstream> 
#include <string> 
#include <exception> 

// Version that throws an exception on a bad parse: 

template <typename T> 
T parse(const std::string& str) 
{ 
    T value; 
    std::istringstream parser(str); 
    parser >> value; 

    if(!parser.fail() && parser.eof()) 
    { 
     return value; 
    } 
    else 
    { 
     throw "bad lexical cast"; 
    } 
} 

// usage: 

double foo = parse<double>("3.14234"); 

// Non-exception, error code version 

template <typename T> 
bool parse(const std::string& str, T& value) 
{ 
    std::istringstream parser(str); 
    parser >> value; 

    return (!parser.fail() && parser.eof()); 
} 

// usage: 

double foo = 0.0; 
bool success = parser<double>("3.11234", foo); 

Answer 9

Wie AndreyT erwähnt, ist die beste So wird versucht, die Zeichenfolge in einen Gleitkommawert zu konvertieren und nach einem Fehler zu suchen. Persönlich würde ich std :: istringstream verwenden, da Sie C++ verwenden. So etwas wie die folgenden funktionieren sollte:

float ff; 
std::istringstream istr; 
std::string input("1234.5678"); 

// set the stream to have your string as its base 
istr.str(input); 

// now try to read the number: 
istr >> ff; 
if (istr.fail()) 
{ 
    // some error in the parsing 
} 

istringstream Teil der STL ist, so dass Sie keine zusätzlichen Bibliotheken benötigen, und es wird auch mit Ausnahmen, wenn das ist Ihre Wahl. Weitere Informationen finden Sie hier: http://www.cplusplus.com/reference/iostream/istringstream/

Answer 10

Sie könnten reguläre Ausdrücke verwenden. Da Sie bereits eine Zeichenfolge haben, wäre es leicht sein, dass mit diesem regulären Ausdruck vergleichen:

/^\d+(\.\d+)?$/ 

Die Bibliothek regex.h Ihnen hier helfen kann. Siehe dazu: regex.h

Answer 11

Dies ist mein schneller Hack :)

#include <iostream> 
#include <string> 
#include <sstream> 
using namespace std; 

template <typename T> 
bool fromStr(const std::string& str, T& var) 
{ 
    std::stringstream convertor; 
    convertor << str; 
    convertor >> var; 

    if(convertor.fail()) 
     return false; 

    char c = static_cast<char>(convertor.get()); 

    return convertor.eof() || c == '\n' || c == ' ' || c == '\t'; 
} 

int main() 
{ 
    double d; 
    std::string str = "5.04146.55"; 

    if(fromStr<double>(str, d)) 
    { 
     std::cout << "Valid conversion!, d = " << d; 
    } 
    else 
    { 
     std::cout << "Invalid conversion!"; 
    } 
}