malloc ---> new : Wieso funktioniert die Umstellung nicht?



  • Hallo Programmierfreunde,

    so langsam komm ich mit C++ klar; war es doch für mich noch vor ein paar Wochen ein großes Mysterium.

    Doch diese Problematik kann ich mir nicht erklären:

    double RK4 (const int dimension,  double interval, double *x,double *xdot, double *x_in)
    {
    	int i;
    	double *xa;
    	xa = new double;                                                  //<---funzt nicht, aber warum?
    //	xa = (double *)malloc (dimension * sizeof (double));   //<---funzt
    	double *f0;
    	f0 = new double;                                                  //<---funzt nicht, aber warum?
    //	f0 = (double *)malloc (dimension * sizeof (double));   //<---funzt
    //......
    //......
    //	free (f0);                                               //   <---funzt 
    //	free (xa);                                              //    <---funzt 
    	delete xa;                                              //    <---funzt nicht, aber warum?
    	delete f0;                                               //   <---funzt nicht, aber warum?
    
    	return x_out[i];
    }
    

    Aus Gründen der vollständigkeit wollte ich den "alten" C-Code in c++ umwandeln. Ich weiß, malloc und free gehen auch in C++, aber ich dachte mir wenn schon c++ dann richtig.

    Der compiler hat nichts gegen die "neue" Variante mit new und delete, aber sobald ich das Prog starte schmiert es ab....

    Jemand Ideen?

    Schöne grüße und besten Dank,
    der Flo

    P.S.: liegt aber nicht daran das ich das Prog unter windows testen will obwohl es eigentlich für Linux gedacht ist, oder ?!
    Zur Erklärung: ich übe gerade auf meinem Home-Pc (winXP); Angewendet wird alles später auf dem "Dienstrechner" Linux.



  • Das funzt

    int main()
    {
        int i; 
        double *xa; 
        xa = new double;                                                  //<---funzt nicht, aber warum? 
    //    xa = (double *)malloc (dimension * sizeof (double));   //<---funzt 
        double *f0; 
        f0 = new double;                                                  //<---funzt nicht, aber warum? 
    //    f0 = (double *)malloc (dimension * sizeof (double));   //<---funzt 
    //...... 
    //...... 
    //    free (f0);                                               //   <---funzt 
    //    free (xa);                                              //    <---funzt 
        delete xa;                                              //    <---funzt nicht, aber warum? 
        delete f0;                                               //   <---funzt nicht, aber warum? 
    }
    

    Also liegt's an was Anderem.
    Was ist x_out[i]?



  • Was meinst du mit "funzt nicht"?

    Wird deine Konsole automatisch wieder geschlossen? Wenn ja, liegt das nicht am new , schau mal in den FAQ nach.

    Du solltest übrigens mit new erstellte Variablen initialisieren:

    // Initialisierung bei der Definition
    int *p = new int(4);
    
    // schrittweise, mit verspäteter Zuweisung
    int *q;
    q = new int;
    *q = 5;
    


  • WOW...seid ihr schnell

    @KAjetzt
    x_out[i] ist nur die Ausgabe der Funktion. Hätte ich bei meiner Fragestellung auch weglassen können. Ich hab den Code nur auszugsweise reingestellt...

    @Nexus:
    Funzt nicht heißt funktioniert nicht...also das Programm. Es hängt sich immer auf sobald ich es mit der "neuen" Variante starte. Compilieren ist kein Problem.
    Die von dir angegebene Initialisierung hat auch nichts gebracht. 😞



  • floh_x_anvs schrieb:

    Funzt nicht heißt funktioniert nicht...also das Programm. .

    Hätte ich jetzt nicht gedacht. :p

    floh_x_anvs schrieb:

    Es hängt sich immer auf sobald ich es mit der "neuen" Variante starte.

    Was heisst, es hängt sich auf? Passiert einfach nichts mehr? Kommt eine Debug-Fehlermeldung? Eine Heap Corruption? Eine Exception? Eine Assertion?
    Eine genaue Beschreibung wäre halt schon hilfreich. 😉



  • Die Konsole liefert mir die erste Iterationslösung:

    0.02 -0.00132800 0.00024267 -0.00097046 0.01974760

    und bricht dann ab; also schließt sich selbst.

    Die erzeugte STACKDUMP-Datei enthält folgendes:

    Stack trace:
    Frame Function Args
    0022C828 7C802542 (00000128, 0000EA60, 000000A4, 0022C870)
    0022C948 61097F54 (00000000, 7C802600, 7C802542, 000000A4)
    0022CA38 61095AEB (00000000, 003B0023, 00230000, 0022CE68)
    0022CA98 61095FCB (0022CAB0, 00000000, 00000094, 61020C1B)
    0022CB58 61096182 (0000161C, 00000006, 0022CB88, 61096383)
    0022CB68 610961AC (00000006, 0022CE88, B923A29C, C00387FC)
    0022CB88 61096383 (00000000, 00000000, 4BC6A7F0, 3FE38937)
    19821 [sig] flugsim 5660 _cygtls::handle_exceptions: Exception: STATUS_ACCESS_VIOLATION
    Exception: STATUS_ACCESS_VIOLATION at eip=61016583
    eax=610C3D58 ebx=61108148 ecx=00000000 edx=00000014 esi=00000007 edi=00000001
    ebp=006BC8B8 esp=006BC8B0 program=D:\Eigene Dateien\flugsim\Debug\flugsim.exe, pid 5660, thread sig
    cs=001B ds=0023 es=0023 fs=003B gs=0000 ss=0023
    Stack trace:
    Frame Function Args
    006BC8B8 61016583 (61108148, 6111C19B, 3FE38937, 00000000)
    006BC8D8 610166EC (00000001, 00000000, 00000000, 006BC960)
    006BC918 61017FD5 (00000040, 006BC960, 00000000, 00000000)
    006BCC58 61018638 (000000F0, 006BCC90, 000000A4, 006BCC8C)
    006BCD58 61099F57 (61106F00, 00000000, 00000000, 00000000)
    006BCD88 61002F32 (006BCE64, 61018970, 00001074, 00000000)
    61003650 61003769 (04A16430, 89000000, FFDA90B0, 24468BFF)
    49870 [sig] flugsim 5660 _cygtls::handle_exceptions: Exception: STATUS_ACCESS_VIOLATION
    50814 [sig] flugsim 5660 _cygtls::handle_exceptions: Error while dumping state (probably corrupted stack)



  • floh_x_anvs schrieb:

    xa = new double;                                                  //<---funzt nicht, aber warum?
    //	xa = (double *)malloc (dimension * sizeof (double));   //<---funzt
    	double *f0;
    	f0 = new double;                                                  //<---funzt nicht, aber warum?
    //	f0 = (double *)malloc (dimension * sizeof (double));   //<---funzt
    

    Fällt dir wirklich nicht auf, dass du bei malloc eine Variable dimension benutzt, bei new aber nicht? Du müsstest eigentlich wissen, dass du da ausrechnest, wieviel Bytes malloc holen soll. Glaubst du, new kann das erraten?

    double *xa = new double[dimension];
    ...
    delete[] xa;
    


  • Oh mein Gott....

    Danke!

    Manchmal sieht man den Wald vor lauter Bäumen nicht.

    Ich nehm das mal als Zeichen dafür das ich ins Bett sollte.

    Danke!
    Jetzt geht's.



  • das problem hätte man schneller lösen können, wenn wie gewußt hätten was hinter

    //......
    //......
    

    steckt;)



  • Na ja, ich glaube in dem Fall waren die gekürzten Stellen eher unwichtig, da er ja einfach den Multiplikator für seine Allokation "vergessen" hat. 🙂



  • ich glaube ehr das er an den stellen auf fremden speicher zugegriffen hat.

    Weil:

    double *p= new double;
    	p[2]=5; //ohne das hier , gibts kein fehler;)
    	delete p;
    


  • BorisDieKlinge schrieb:

    ich glaube ehr das er an den stellen auf fremden speicher zugegriffen hat.

    Hätten wir jetzt nicht gedacht 🙄

    Was passiert denn wohl, wenn man beim Allokieren einen Faktor vergisst? Richtig, der reservierte Speicher ist zu klein. Dass das aber keine Absturzursache ist, dürfte hier jedem klar sein.

    Manchmal hast Du das Talent, auf das Offensichtliche hinzuweisen 😃



  • Außer der Faktor ist kleiner 1. :p 😃



  • Fellhuhn schrieb:

    Außer der Faktor ist kleiner 1. :p 😃

    kleiner-gleich! 😃



  • Der Unterschied ist so verschwindend gering, den kann man nicht einmal mit einem Computer darstellen. Daher habe ich auf die Unterscheidung verzichtet. 😉 🤡


Anmelden zum Antworten