Announcement

Collapse
No announcement yet.

Ist C++ Builder schlampig im Umgang mit Variablen?

Collapse
X
  • Filter
  • Time
  • Show
Clear All
new posts

  • Ist C++ Builder schlampig im Umgang mit Variablen?

    Hi!

    Mein Informatiklehrer hat mal (so ungefähr) gesagt, der C++ Builder würde im Speicher schlampig mit Variablen umgehen.
    In wie fern trifft das zu? Kann mir jemand detailliertere Informationen darüber geben?

    Kristian

  • #2
    Könnte dein Informatiklehrer mal Informationen geben was er meint???´

    Meine Variablen machen das was sie solle
    Christian

    Comment


    • #3
      Hi!

      Ich meine, er meinte die Verwaltung der Variablen im Speicher, aber ich kann ihn bei Gelegenheit ja nochmal fragen.

      Schönes Wochenende,
      Kristia

      Comment


      • #4
        Ist mir klar, dass er die Verwaltung meint, aber woher hat er seine Infos??

        Schönes Wochenend
        Christian

        Comment


        • #5
          Hi!

          Es geht darum, dass ich einer Funktion "void Test(int i, char ch)" auch Parameter anderer Typen übergeben kann. Also kann ich Test, z.B. so aufrufen: "Test('a', 33.5);" Der C++Builder gibt nichtmal eine Warnung aus. Nach einiger Laufzeit des Programms und "versehentlichem" falschen Aufruf kann es dann zu einem Stack-Overflow kommen.

          Hat jemand hierzu vielleicht einen Lösungsvorschlag? Gibt es eine Lösung dieses Problems?

          Schönes Wochenende,

          Kristia

          Comment


          • #6
            Was hat das mit schlampig zu tun???

            Hier wird ganz normales Typecasting vorgenommen.

            Das hat nichts mit dem C++Builder zu tun.

            Was ist ein "versehentlichem" falschen Aufruf????

            "kann es dann zu einem Stack-Overflow kommen." Kannst du oder dein "Informatiklehrer" das mal erläutern??

            Hat dein Informatiklehrer eine Ausbildung erhalten???

            Wenn ich alle Warnungen einschalte, bekomme ich 3 Stück angezeigt??
            Christian

            Comment


            • #7
              Hi!

              Es geht hier einfach darum, dass ein Programmierer (vorallem auch unerfahrenere) Fehler machen und einer Funktion z.B. einen Parameter eines anderen Typs übergeben, aber nicht absichtlich. In Dev-C++ und MSVC6 wird auf dieses Mißgeschick zumindest bei höherer Warnstufe hingewiesen. In C++Builder 6 verwende ich die Standardeinstellungen, jedoch mit Warnungen "Alle". Trotzdem zeigt er (im Gegenteil zu den anderen beiden Compilern) keine Warnung an.

              <PRE>
              #include "iostream.h"

              void test(int *i, int j);

              int main()
              {
              int i;

              test(&i, 9.76);
              cout << i << endl;

              system("pause");
              return 0;
              }

              void test(int *i, int j)
              {
              *i = j;
              }
              </PRE>

              Wenn ich "test" für "int j" z.B. einen Float-Wert übergebe, dann konvertiert BCB das einfach. Ich möchte aber eine Warnung haben, denn wenn ich einen Float übergebe wird der ja einfach gerundet und das möchte ich nicht.

              Kristia

              Comment


              • #8
                Achso, ..., der Stack-Overflow.

                Übergebe ich für "char c", z.B. "44.4", dann (so sagt mein Informatiklehrer in etwa) werden 4 Byte(Float) auf den Stack geschoben, aber nur 1 Byte(Char) wieder freigegeben.

                Das Beispiel hier stammt von mir. Falls die Formulierung nicht ganz korrekt ist, liegt das eher an mir, als an meinem Informatiklehrer.

                Kristia

                Comment


                • #9
                  Dann schau dir mal folgende Themen an:

                  Speicheruung von Fließkommazahlen

                  Speicherung von INT Datenty
                  Christian

                  Comment


                  • #10
                    Es scheint mir so als wenn dein Informatiklehrer entwas :-) sehr weit hinter der Zeit ist.

                    Bei C++ kann eine Funktion erst dann benutzt werden, wenn sie deklariert wurde.

                    Also "weiss" der Compiler bei Aufruf der Funktion welche Parameter
                    die Funktion benoetigt. Es wird also eine entsprechende Typenumwandlung vollzogen. Der Stach wird auf jedenfall richtig bereinigt.

                    Desweiteren sind wir im Zeitalter der 32 Bit Rechner. Es wird niemals nur 1 Byte auf den Stack "gepushed".

                    Am besten laesst sich dies Nachweisen, wenn du deine 44.4 uebergibst und vor Aufruf der Funktion auf Assemblerebene umschaltest.
                    Ansicht/Debugfenster/CPU.
                    Hier siehst du genau was gepushed und wieder "freigegeben" wird

                    Comment

                    Working...
                    X