4. Frage zu Microsoft Visual C++ Meldung.

Frage zu Microsoft Visual C++ Meldung.

  • M

    Hallo zusammen.

    Nun ich versuche mich gerade in C einen Taschenrechner zu programmieren. Jetzt habe ich mit den Grundlagen angefangen und beschäftige mich gerade mit dem Einlesen von Werten. Ich verwende dazu Microsoft Visual C++ 2010 Express. Nun möchte ich mich
    soweit wie möglich an den ISO Standard halten. Nun gibt mir der Compiler eine Warnung aus, sobald ich gewisse Funktionen verwende. Der Hintergrund dieser Warnungen ist mir bekannt.

    Hier mein Code:

    [cpp]
//-----------------------------------------------------------------------------
//
//  Datei:
//
//    Tutorial.c
//
//  Beschreibung:
//
//    Implementiert Eingabefunktionen für verschiedene Typen.
//
//-----------------------------------------------------------------------------

#include <stdio.h>
#include <string.h> // Für die strchr Funktion.

// Rückgabewerte definieren.
#define S_OK           0
#define E_NULL_POINTER 1
#define E_NULL_SIZE    2
#define E_FGETS        3
#define E_INPUT        4

//-----------------------------------------------------------------------------
//
//  Funktion:
//
//    int ReadString(char* string, size_t size)
//
//  Beschreibung:
//
//    Liest eine Zeichenkette aus dem Standardeingabebuffer ein. Löscht vor
//    und nach dem Vorgang diesen um eventuell übrig gebliebene Zeichen zu
//    entfernen. Formatiert eine Nullterminierte Zeichenkette ohne Newline-
//    zeichen.
//
//  Parameter string:
//
//    Ein Zeiger auf eine Zeichenkette.
//
//  Parameter size:
// 
//    Die Grösse der übergebenen Zeichenkette sammt Nullbyte.
//
//  Rückgabewert:
//
//    S_OK           -> Funktion was Erfolgreich.
//    E_NULL_POINTER -> Der übergebene Zeiger war Null.
//    E_NULL_SIZE    -> Die übergebene Grösse war Null.
//    E_FGETS        -> Die fgets Funktion schlug fehl.
//
//-----------------------------------------------------------------------------

int ReadString(char* string, size_t size)
{
    char* newline = 0;

    if (!string) 
        return E_NULL_POINTER;

    if (!size) 
        return E_NULL_SIZE;

    fflush(stdin);

    if (!fgets(string, size, stdin))
    {
        fflush(stdin);
        return E_FGETS;
    }

    newline = strchr(string, '\n');

    if (newline) 
        (*newline) = '\0';

    fflush(stdin);    
    return S_OK;
}

//-----------------------------------------------------------------------------
//
//  Funktion:
//
//    int ReadInteger(int* value)
//
//  Beschreibung:
//
//    Liest einen Integer aus dem Standardeingabebuffer ein. 
//
//  Parameter value:
//
//    Ein Zeiger auf den Integer.
//
//  Rückgabewert:
//
//    S_OK           -> Funktion was Erfolgreich.
//    E_NULL_POINTER -> Der übergebene Zeiger war Null.
//    E_FGETS        -> Die fgets Funktion schlug fehl.
//    E_INPUT        -> Es wurde kein Integer eingegeben.
//
//-----------------------------------------------------------------------------

int ReadInteger(int* value)
{
    int result = 0;
    size_t indexA = 0;
    size_t indexB = 0;
    char bufferA[32] = {""};
    char bufferB[32] = {""};
    const size_t size = sizeof(bufferA);

    if (!value) 
        return E_NULL_POINTER;

    result = ReadString(bufferA, size);

    if (result) 
        return result;

    // Nach Ungültigen Zeichen suchen wie z.B. Buchstaben etc.
    for (indexA = 0; indexA < size; ++indexA)
    {
        if (bufferA[indexA] == '\0')
        {
            bufferB[indexB] = '\0';
            break;
        }

        // Alle Leerzeichen überspringen.
        if (bufferA[indexA] == ' ') 
            continue;

        if (bufferA[indexA] < '0' || bufferA[indexA] > '9')
            return E_INPUT;

        bufferB[indexB++] = bufferA[indexA];
    }

    // Sicherstellen dass auch eine Ziffer eingegeben wurde.
    if (bufferB[0] == '\0') 
        return E_INPUT;

#pragma warning(disable:4996) // MSVC++ sscanf unsafe ...

    // Die Zeichenkette in einen Integer konvertieren.
    sscanf(bufferB, "%d", value);

#pragma warning(default:4996)

    return S_OK;
}

//-----------------------------------------------------------------------------
//
//  Funktion:
//
//    int ReadLongDouble(long double* value)
//
//  Beschreibung:
//
//    Liest einen Gleitkommawert aus dem Standardeingabebuffer ein. 
//
//  Parameter value:
//
//    Ein Zeiger auf den Gleitkommawert.
//
//  Rückgabewert:
//
//    S_OK           -> Funktion was Erfolgreich.
//    E_NULL_POINTER -> Der übergebene Zeiger war Null.
//    E_FGETS        -> Die fgets Funktion schlug fehl.
//    E_INPUT        -> Es wurde kein Gleitkommawert eingegeben.
//
//-----------------------------------------------------------------------------

int ReadLongDouble(long double* value)
{
    int pointFlag = 0;
    int result = 0;
    size_t indexA = 0;
    size_t indexB = 0;
    char bufferA[32] = {""};
    char bufferB[32] = {""};
    const size_t size = sizeof(bufferA);

    if (!value) 
        return E_NULL_POINTER;

    result = ReadString(bufferA, size);

    if (result) 
        return result;

    // Nach Ungültigen Zeichen suchen wie z.B. Buchstaben etc.
    for (indexA = 0; indexA < size; ++indexA)
    {
        if (bufferA[indexA] == '\0')
        {
            bufferB[indexB] = '\0';
            break;
        }

        // Alle Leerzeichen überspringen.
        if (bufferA[indexA] == ' ') 
            continue;

        if (bufferA[indexA] < '0' || bufferA[indexA] > '9')
        {
            // Das Punktzeichen nur einmal einlesen.
            if (bufferA[indexA] != '.' || pointFlag)
                return E_INPUT;

            pointFlag = 1;
        }

        bufferB[indexB++] = bufferA[indexA];
    }

    // Sicherstellen dass auch eine Ziffer eingegeben wurde.
    if (bufferB[0] == '.' || bufferB[0] == '\0') 
        return E_INPUT;

#pragma warning(disable:4996) // MSVC++ sscanf unsafe ...

    // Die Zeichenkette in einen Gleitkommawert konvertieren.
    sscanf(bufferB, "%lf", value);

#pragma warning(default:4996)

    return S_OK;
}

//-----------------------------------------------------------------------------
//
//  Funktion:
//
//    void TestStringFunction()
//
//  Beschreibung:
//
//    Testet die ReadString Funktion.
//
//-----------------------------------------------------------------------------

void TestStringFunction()
{
    char string[64] = {""};

    for (;;)
    {
        printf("Enter string: ");   

        switch (ReadString(string, sizeof(string)))
        {
        case S_OK:
            printf("Input: %s\n\n", string);
            break;

        default:
            printf("ReadString failed!\n");
            return;
        }
    }
}

//-----------------------------------------------------------------------------
//
//  Funktion:
//
//    void TestIntegerFunction()
//
//  Beschreibung:
//
//    Testet die ReadInteger Funktion.
//
//-----------------------------------------------------------------------------

void TestIntegerFunction()
{
    int value = 0;

    for (;;)
    {
        printf("Enter integer: ");    

        switch (ReadInteger(&value))
        {
        case S_OK:
            printf("Input: %d\n\n", value);
            break;

        case E_INPUT:
            printf("Please enter valid integer!\n\n");
            break;

        default:
            printf("ReadInteger failed!\n");
            return;
        }
    }
}

//-----------------------------------------------------------------------------
//
//  Funktion:
//
//    void TestLongDoubleFunction()
//
//  Beschreibung:
//
//    Testet die ReadLongDouble Funktion.
//
//-----------------------------------------------------------------------------

void TestLongDoubleFunction()
{
    long double value = 0;

    for (;;)
    {
        printf("Enter floating point number: ");    

        switch (ReadLongDouble(&value))
        {
        case S_OK:
            printf("Input: %lf\n\n", value);
            break;

        case E_INPUT:
            printf("Please enter valid floating point number!\n\n");
            break;

        default:
            printf("ReadLongDouble failed!\n");
            return;
        }
    }
}

//-----------------------------------------------------------------------------
//
//  Funktion:
//
//    int main()
//
//  Beschreibung:
//
//    Der Haupteinstiegspunkt der Anwendung.
//
//  Rückgabewert:
//
//    0    -> Die Funktion war Erfolgreich.
//    != 0 -> Ein Fehlercode.
//
//-----------------------------------------------------------------------------

int main()
{    
    // TestStringFunction();
    // TestIntegerFunction();
    TestLongDoubleFunction();

    return 0;
}
[/cpp]

    Nun meine Frage ist, ob die Zeile #pragma warning(disable:4996) irgendwelche Probleme verursachen wird, sobald ich z.B. den Code mit dem GCC Compiler übersetzen möchte. Eigentlich ist das ja eine Präprozessoranweisung und sollte keinerlei Auswirkungen haben oder?

    Vielen Dank schon mal im Voraus.

    PS: Solltet ihr irgendwelche Fehler in meinem Code entdecken, bitte mitteilen, bin noch ganz neu in C.

    LG

    0
  • O

    Als kleine Hilfe schonmal hier lesen...

    0
  • M

    Oh, Danke. Habe ich nicht gefunden.

    Ist es den sinvoll, alle Warnungen zu deaktivieren?

    Welche der beiden Varianten würdet ihr empfehlen?

    1: #define _CRT_SECURE_NO_WARNINGS
    2: #pragma warning ...

    LG

    0
  • M

    Mabuntu schrieb:

    Ist es den sinvoll, alle Warnungen zu deaktivieren?

    Nein.

    Mabuntu schrieb:

    Welche der beiden Varianten würdet ihr empfehlen?

    Keine. Ich würde das in den Projekteinstellungen machen, nicht im Code.

    0
  • C

    Dieser Thread wurde von Moderator/in rüdiger aus dem Forum ANSI C in das Forum MFC (Visual C++) verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.

    0
  • _

    Bevor du fragst: du kannst Präprozessordefinitionen in den Projekteinstellungen unter C/C++ => Präprozessor festlegen. Pack da ein _CRT_SECURE_NO_WARNINGS rein und gut is'. 😉

    0

  • Ich bevorzuge

    #pragma warning(disable:4996)

    einmalig im Code. (Nicht mehrfach hin/her schalten),

    da bei Weitergabe der Sourcen ohne Projektdatei der Nutzer nicht nochmal dasgleiche Geraffel durchmachen muss wie du. Gleiches gilt für die Weitergabe einer Projektdatei für andere/ältere VStudio-Zielversionen. Sourcecode interpretieren können sie alle, Projektdateien interpretieren nicht unbedingt.

    0
  • M

    Danke für die schnellen Antworten.

    0
Anmelden zum Antworten