如何確保輸入是C編程語言中的雙精度

Question

我如何確保我有雙倍而不是其他東西？

int main() { 
    int flagOk = 0; 
    double number; 
    while(!flagOk) { 
     printf("Put in a double"); 
     scanf("%lf", &number); 
     if(number == "%lf"); //this want make sure 
     flagOk = 1; 
    } 
} 

Answer 1

你可能需要一個代碼片段更是這樣的：

double number; 
do { 
    printf("Enter a double: "); 
    scanf("%*c"); // burn stdin so as not to buffer up responses 
} while (1 != scanf("%lf", &number)); 

但是喬納森指出，一些更好的行由行解析可能會更好。這種方式直接從stdin掃描對用戶來說並不直觀。

Answer 2

檢查來自scanf（）的返回值;它會告訴您有多少轉換成功。

在上下文中，如果轉換失敗，您會得到0;如果成功，你得到1.

錯誤恢復需要考慮。我通常發現使用fgets（）讀取一行數據更容易 - 並且永遠不會獲取（）！ - 然後用sscanf（）處理它。如果轉換失敗，很容易丟棄錯誤的數據。

Answer 3

如果你想確保用戶期待值由字符串傳遞給ATOF（STR）返回的值一致 - 包括指數符號 - 然後將下面的代碼工作。

您可以使用fgets（str，size，stdin）獲得輸入，並且在將字符串傳遞給解析器之前，甚至不必刪除結尾的換行符。

此外，如果存在解析錯誤，函數會將有罪人物的位置報告給作爲附加參數傳遞的指針。

有一個長形式 - 更容易閱讀，簡短的形式 - 更容易打字。

朗形式：

/* 
    Copyright (C) 2010 S. Randall Sawyer 

This code is in the public domain. It is intended to be usefully illustrative. 
It is not intended to be used for any particular application. If this code is 
used in any application - whether open source or proprietary, then please give 
credit to the author. 

*/ 

#include <ctype.h> 

#define FAILURE (0) 
#define SUCCESS (!FAILURE) 

enum { 
    END_EXPRESSION  = 0x00, 
    ALLOW_POINT   = 0x01, 
    ALLOW_NEGATIVE  = 0x02, 
    REQUIRE_DIGIT   = 0x04, 
    ALLOW_EXPONENT  = 0x08, 
    HAVE_EXPONENT   = 0x10, 
    EXPECT_EXPRESSION  = ALLOW_POINT | ALLOW_NEGATIVE | REQUIRE_DIGIT, 
    EXPECT_INTEGER  = ~ALLOW_POINT, 
    EXPECT_POS_EXPRESSION = ~ALLOW_NEGATIVE, 
    EXPECT_POS_INTEGER = EXPECT_INTEGER & EXPECT_POS_EXPRESSION, 
    EXPECT_EXPONENT  = EXPECT_INTEGER^HAVE_EXPONENT, 
    EXPONENT_FLAGS  = REQUIRE_DIGIT | ALLOW_EXPONENT | HAVE_EXPONENT 
} DoubleParseFlag; 

int double_parse_long (const char * str, const char ** err_ptr) 
{ 
    int ret_val, flags; 
    const char * ptr; 

    flags = EXPECT_EXPRESSION; 
    ptr = str; 

    do { 

    if (isdigit (*ptr)) { 
     ret_val = SUCCESS; 
     /* The '+' here is the key: It toggles 'ALLOW_EXPONENT' and 
      'HAVE_EXPONENT' successively */ 
     flags = (flags + (flags & REQUIRE_DIGIT)) & EXPECT_POS_EXPRESSION; 
    } 
    else if ((*ptr & 0x5f) == 'E') { 
     ret_val = ((flags & (EXPONENT_FLAGS)) == ALLOW_EXPONENT); 
     flags = EXPECT_EXPONENT; 
    } 
    else if (*ptr == '.') { 
     ret_val = (flags & ALLOW_POINT); 
     flags = (flags & EXPECT_POS_INTEGER); 
    } 
    else if (*ptr == '-') { 
     ret_val = (flags & ALLOW_NEGATIVE); 
     flags = (flags & EXPECT_POS_EXPRESSION); 
    } 
    else if (iscntrl (*ptr)) { 
     ret_val = !(flags & REQUIRE_DIGIT); 
     flags = END_EXPRESSION; 
    } 
    else { 
     ret_val = FAILURE; 
     flags = END_EXPRESSION; 
    } 

    ptr++; 

    } while (ret_val && flags); 

    if (err_ptr != NULL) 
    *err_ptr = ptr - 1; 

    return ret_val; 
} 

簡稱：

/* 
    Copyright (C) 2010 S. Randall Sawyer 

This code is in the public domain. It is intended to be usefully illustrative. 
It is not intended to be used for any particular application. If this code is 
used in any application - whether open source or proprietary, then please give 
credit to the author. 

*/ 

#include <ctype.h> 

int double_parse_short (const char * str, const char ** err_ptr) 
{ 
    int ret_val, flags; 
    const char * ptr; 

    flags = 0x07; 
    ptr = str; 

    do { 

    ret_val = (iscntrl (*ptr)) ? !(flags & 0x04) : (
       (*ptr == '.') ? flags & 0x01 : (
       (*ptr == '-') ? flags & 0x02 : (
       ((*ptr & 0x5f) == 'E') ? ((flags & 0x1c) == 0x08) : (
       (isdigit (*ptr)) ? 1 : 0)))); 

    flags = (isdigit (*ptr)) ? 
       (flags + (flags & 0x04)) & 0x1d : (
       ((*ptr & 0x5f) == 'E') ? 0x0e : (
       (*ptr == '-') ? flags & 0x1d : (
       (*ptr == '.') ? flags & 0x1c : 0))); 

    ptr++; 

    } while (ret_val && flags); 

    if (err_ptr != NULL) 
    *err_ptr = ptr - 1; 

    return ret_val; 
} 

我希望這有助於！