lokale Variablen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • lokale Variablen

    Hi Leute ich habe volgendes Problem:

    Lokale Variablen sollten ja unabhängig von einander agieren. Ich verstehe also nicht wieso als Ausgabe "Dort ist der Wert von v 35" raus kommt. Auch wenn ich für die Variable v(void dort Funktion) eine anderen variablen Namen nehme wie zb. "k" bekomm ich die gleiche Ausgabe und zwar "Dort ist der Wert von k 35".

    Kann mir wer helfen?



    Quellcode

    1. #include <stdio.h>
    3. void hier(void);
    4. void dort(void);
    6. int main()
    7. {
    8. hier();
    9. dort();
    11. system("PAUSE");
    12. return 0;
    13. }
    15. void hier()
    16. {
    17. int v;
    19. v=6*5;
    20. printf("Hier ist der Wert von v %i\n\n", v);
    22. }
    24. void dort()
    25. {
    26. int v;
    28. v+=5;
    29. printf("Dort ist der Wert von v %i\n\n", v);
    31. }
    Alles anzeigen

  • Das Phänomen hat wenig damit zu tun wie die variablen heißen, die du benutzt (das hast du ja selber festgestellt). Das Problem ist, dass du die Variablen nicht initialisierst. Nichtinitialisierte Variablen haben keinen definierten Wert, dieser kann alles mögliche sein, je nachdem was an der Stelle im Speicher steht, an der jetzt die Variable liegt.

    Lokale Variablen liegen auf dem Stack (de.wikipedia.org/wiki/Stapelspeicher#Mikroprozessoren). Jedesmal wenn eine Funktion aufgerufen wird, wird ein neuer Bereich für diese oben auf dem Stack angefangen und sobald das Programm die Funktion verlassen hat wird der Speicher wieder freigegeben.
    D.h. wenn du in die Funktion hier() reingehst wird oben auf dem Stack die Variable v abgelegt und ihr der Wert 30 gegeben. Dann ist die Funktion zuende und der Speicher auf dem Stack freigegeben. Wenn du jetzt dort() aufrufst, befindet diese Methode sich im gleichen Bereich auf dem Stack wie eben hier() und wenn du jetzt ein neues v auf den Stack legst, liegt es exakt an der gleichen Stelle wie das alte v. Und da diese Speicherstelle bei der Deklaration der Variablen nicht überschrieben wird, steht da halt immernoch die 30 drin, und wenn du mit v weiterrechnest benutzt er diese 30.

    Wenn du jetzt z.B. sowas machst, wird etwas völlig anderes passieren, weil hier jetzt k an der Stelle des alten v liegt:

    Quellcode

    1. #include <stdio.h>
    3. void hier(void);
    4. void dort(void);
    6. int main()
    7. {
    8. hier();
    9. dort();
    11. system("PAUSE");
    12. return 0;
    13. }
    15. void hier()
    16. {
    17. int v;
    19. v=6*5;
    20. printf("Hier ist der Wert von v %i\n\n", v);
    22. }
    24. void dort()
    25. {
    26. int k;
    27. int v;
    29. v+=5;
    30. k=0;
    31. printf("Dort ist der Wert von v %i\n\n", v);
    33. }
    Alles anzeigen

    (das k=0 hab ich nur rein, weil er mir ansonsten die Variable k komplett wegoptimiert hat)


    Und wenn du die Funktionen nicht nacheinander, sondern verschachtelt aufrufst, wird auch ein anderes Ergebnis rauskommen:

    Quellcode

    1. #include <stdio.h>
    3. void hier(void);
    4. void dort(void);
    6. int main()
    7. {
    8. hier();
    10. system("PAUSE");
    11. return 0;
    12. }
    14. void hier()
    15. {
    16. int v;
    18. v=6*5;
    19. printf("Hier ist der Wert von v %i\n\n", v);
    20. dort();
    21. }
    23. void dort()
    24. {
    25. int v;
    27. v+=5;
    28. printf("Dort ist der Wert von v %i\n\n", v);
    30. }
    Alles anzeigen