Überprüfungsroutinen und Redundanz im Code



  • Hallo Leute,

    Gibt es eine Richtlinie, an welchen Stellen im Quellcode Werte überprüft werden sollten? Wenn ich z.B. Objekte oder Funktionen habe, die gewisserweise einen bestimmten Wert durchschleifen, wo sollte ich dann überprüfen, ob dieser Wert korrekt ist?

    Hier mal ein Beispiel:

    funktion2(int Wert)
    {
    	if (isValueValid(Wert) == false)
    	{
    		// error
    	}
    
    	// ...irgendwelcher code ...
    }
    
    funktion1(int Wert)
    {
    	if (isValueValid(Wert) == false)
    	{
    		// error
    	}
    
    	funktion2(Wert);
    }
    
    main()
    {
    	int meinWert = 123;
    
    	if (isValueValid(meinWert) == false)
    	{
    		// error
    	}
    
    	funktion1(meinWert);
    }
    

    Ist 'meinWert' ungültig, so wird sich der Fehler in der main-Schleife äußern. Ist dieser Wert korrekt, so wird dieser trotzden noch 2 mal in den unteren Funktionsebenen geprüft. Das ist Redundant, führt zu mehr Code und höhreren Einbußen der Performance. Theoretisch würde es wohl reichen, wenn die Überprüfung da stattfindet, wo der Wert explizit gebraucht wird (in funktion2).

    Mein Problem: Ist der Wert nun fehlerhaft, so wird der Code nun bis zur funktion2 ausgeführt, bevor es zum Erkennen des Fehlers kommt. Bis dahin könnten die Übergeordneten Funktionen z.B. andere Funktionen aufrufen oder Objekte anlegen. Daher frage ich mich erstmal ob es Performancetechnisch überhaupt effizienter ist. Die zweite Sache ist folgendes: Kann ich mich in den höheren Funktionen darauf verlassen, dass der Wert auf Fehler überprüft wird? Auch wenn man seinen eigenen Code schreibt, ist der Fehlerteufel allgegenwärtig 😉

    Wie geht ihr bei sowas vor?

    viele Grüße,
    SBond


  • Mod

    Exceptions bzw. die Devise "Let it crash" sind dir beide bekannt?



  • achja... 😞

    Ich bin wohl blind. ...exception in der untersten Funktionsebene werfen. ...ich habe mich wohl irgendwie selbst verwirrt.

    Nichts für ungut.



  • SBond schrieb:

    Wie geht ihr bei sowas vor?

    Exceptions sind hier sehr praktisch um zu verhindern das du mit ungültigen Werten zu tief wanderst.

    Was die Prüfung selbst angeht, hast du natürlich auch die Möglichkeit die Prüfungspflicht weiterzugeben, oder auszulagern. Dafür hast du 2 Optionen. Du machst entweder klar das deine Funktion gültige Werte erwartet (gibts in einigen APIs) und der Aufrufer selbst prüfen muß wenn er denkt es wäre notwendig, oder du baust 2 Funktionen, eine mit und eine ohne Prüfung.

    //value muß immer gütltig sein
    void f1(value)
    {
        code;
    };
    
    //value wird geprüft bevor f1 aufgerufen wird
    inline f1MitTest(value)
    {
        if (value == wrong)
            throw;
        else
            f1(value);
    };
    

    In diesem Fall würdest du f1 nehmen wenn du weisst das dein Wert gültig ist und f1MitTest wenn du weisst das der Wert möglicherweise fehlerhaft ist. Du kannst natürlich f1MitTest auch weglassen und jeder Aufrufer muß seine Werte komplett alleine Prüfen.


Log in to reply