free()

[fabarazzi]

DirkB schrieb:

Du kannst dafür memset nehmen.

Danke .. da hätte ich eigtl auch selber draufkommen können ^^

Prof. Geiler? Nein

Damit ich nicht noch ein neues Thema eröffnen muss: Ich hab ein Problem mit float Parametern in Funktionen. Alle float-Parameter die ich einer Funktion übergebe, werden falsch interpretiert. Bei double-Werten ist dies aber nicht der Fall. Dazu ein Beispiel:

void f_step(float f_value)
{
     printf("%f",f_value);  //Falls ich f_step(1.0f) aufrufe bekomme ich hier eine 0.00000000 Ausgabe. Wieso?
}

[SeppJ]

PrettyC schrieb:

DirkB schrieb:

Du räumst doch aber auch vorher deine persönlichen Sachen raus.

Schließlich wirst Du kaum beim neuen Eigentümer Gehör finden, wenn Du ankommst und sagst, Du möchtest gern den Innenraum seines Wagens durchsuchen.

Eine passendere Analogie wäre, dass man den Wagen in der Garage geparkt hat und ausgestiegen ist. Wenn der Wagen verkauft wird (Speicher wird vom OS zurück genommen und von diesem an andere Prozesse gegeben), wird bei jedem halbwegs normalen OS der Speicher vorher genullt (wäre sonst viel zu unsicher!). Das macht aber schon das OS für dich und das kann das auch extrem effizient, weil es ganze Speicherseiten verwaltet und die kann man in einem Rutsch komplett nullen.

Wenn du selber noch was im Wagen vorfindest, dann war das ein Familienmitglied (dein eigenes Programm), welches da vorher was reingeschrieben hat und der Speicher war zwischendurch nicht beim OS.

[SeppJ]

fabarazzi schrieb:

Damit ich nicht noch ein neues Thema eröffnen muss: Ich hab ein Problem mit float Parametern in Funktionen. Alle float-Parameter die ich einer Funktion übergebe, werden falsch interpretiert. Bei double-Werten ist dies aber nicht der Fall. Dazu ein Beispiel:

void f_step(float f_value)
{
     printf("%f",f_value);  //Falls ich f_step(1.0f) aufrufe bekomme ich hier eine 0.00000000 Ausgabe. Wieso?
}

Zeig mal ein vollständiges Beispiel, welches den Fehler produziert. Denn:
http://ideone.com/Em4JL

[fabarazzi]

Das ist in der einen c-Datei:

err = f_steps(p_step,1,get_time);

Und folgendes in einer anderen

int f_steps(STEP *p_step, int quantity, float time)                //!! ? void?
{
    [..]
     printf("Kein Fehler %f",time);
    [..]
}

Deklariert ist die Funktion auch richtig, in der entsprechenden .h-Datei

[SeppJ]

SeppJ schrieb:

Zeig mal ein vollständiges Beispiel, welches den Fehler produziert.

[fabarazzi]

work.c

//Status 
             err = f_steps(p_step,1,1.0f);
             if(!err)
             {
                   /*Neuer Status = alter STATUS + Zeit*/
                   p_order->status += p_step->time; // ODER new_state

                   time_verbrauch += p_step->time;
             }

f_steps.c

int f_steps(STEP *p_step, int quantity, float time)                
{
    /*ABHAENGIG VON ZEIT*/

    int i = 0;
    int err = 0;
    /*Suche in Arbeitsschritt, welche Ressource verarbeitet wird*/
    if(!p_step->p_ressources && strcmp(p_step->ressource,"")) /*Falls kein Pointer vorhanden, aber Wert existiert*/
    {
        p_ressource = search_ressource(p_step->ressource);
    }
    else
    {
        p_ressource = p_step->p_ressources;
    }

    /*Ressource in p_ressource abgelegt (sofern es eine gibt)*/

    /*Geld fuer AS vorhanden?*/
    if(kapital<(quantity*time*p_step->price))
    {
        err = 1;
    }

    /*Genuegend Ressourcen im Lager vorhanden?*/
    if(p_ressource && p_ressource->stock < (quantity*time))
    {
        err = 2;
    }

    /*Ressourcen vom Lagerbestand abziehen, Kapital abzueglich der AS-Kosten*/
    if(!err)
    {

        printf("Kein Fehler %f %f",time,p_step->price);

        kapital = kapital - time*p_step->price;
        if(p_ressource) p_ressource->stock = p_ressource->stock - (quantity*time);              //!Es sollten eigtl keine 0.x Mengen abgeubcht werden koennen
    }

    return err;
}

Vl sollte ich noch anmerken, dass die Ausgabe in Zeile 35 eigtl "Kein Fehler 1.000000" usw. ausgeben sollte. Heraus kommt aber "Kein Fehler 0.000000" usw.

[SeppJ]

Wenn du keine Hilfe möchtest, dann frag doch gar nicht erst.

[DirkB]

Ein vollständiges Beispiel ist ein minimales compilierbares Programm, bei dem der Fehler auftritt.
Dazu noch ein paar Infos zu Compiler und Betriebssystem.
Ansonsten: http://www.c-plusplus.net/forum/136013

[fabarazzi]

Ich denke da wurde gerade etwas falsch verstanden. Also ich komme bei diesem Problem gerade einfach nicht weiter und habe keine Idee, wieso genau dieses Problem besteht. Ich versuche es noch einmal detailiert zu erklären und schneide die wichtigen Codeteile heraus:

Im Grunde genommen möchte ich nur eine Funktion aufrufen, die über Parameter gesteuert wird. Diese Parameter sind ein Pointer, ein Integer und ein Float. Jetzt rufe ich diese Funktion auf und die Parameter werden auch erkannt und verarbeitet. Nur für den Float-Parameter bekomme ich eine falsche Zahl als Rückgabewert. Gebe ich beim Aufruf der Funktion 1.0f als Parameter an, bekomme ich 0.000000 beim Aufruf in der Funktion als Wert zurück. Rufe ich das Ganze mit beispielsweise 1.838 auf, erhalte ich eine riesengroße Zahl als Rückgabewert.

Baue ich die Funktion um, so dass ich statt des Float-Parameters einen Double-Parameter habe, funktioniert alles wunderbar. Allerdings würde ich gerne wissen, wieso das mit Float nicht funktioniert. Dieses Problem hatte ich an anderer Stelle nämlich auch schon.

Hier schildere ich es nochmal:

#include <stdio.h>
#include <stdlib.h>
int f_steps(int *p_step, int quantity, float time)
{
    printf("Wert fuer time: %f",time);
    int err = 0;

    //[..] err wird Integer Wert zugewiesen

   return err;
}

//Das Gleiche mit double
int f_steps2(int *p_step, int quantity, double time)
{
    printf("Wert fuer time: %lf",time);
    int err = 0;

    //[..] err wird Integer Wert zugewiesen

   return err;
}

void main()
{
   int err,err2;
   int *p_step = 0;

   err = f_steps(p_step,1,1.0f);  //Als Ausgabe erfolgt "Wert fuer time: 0.000000"

   err2 = f_steps2(p_step,1,1);  //Als Ausgabe erfolgt "Wert fuer time: 1.000000" 

   exit(0);
}

Compiled wird unter Windows mit GNU GCC Compiler
Editor: Code::Blocks 10.05

Das Komische daran ist, mit dem online-Compiler (http://ideone.com/ZvI1C) funktioniert das auch wunderbar. Aber wieso funktioniert dann das Ganze bei mir nicht? Kann es sein, dass mein Compiler irgendwelche Probleme bzw Sonderheiten beim Umgang mit Float-Werten hat?

[DirkB]

Wenn ich in Zeile 16 das %lf in %f ändere, bekomme ich zweimal Wert fuer "time: 1.000000"
(auch Code:Blocks 10.05 mit dem dazu gelieferten GCC, Windows 7 Home)

Warum muss es float sein?
Warum das f hinter der 1.0?

Bei deinem Original bekomme ich bei f_steps2 die 0.000000. Kann an dem %lf liegen.

[SeppJ]

Ist das wirklich 1:1 das Programm, welches den Fehler zeigt? Komplett mal neues Projekt angelegt, diesen Code genommen, komplett neu compiliert und dann kommt diese Ausgabe?

(Der Formatspezifizierer %lf bei f_steps2 zeugt übrigens nicht von Verständnis von printf. Er ist zwar technisch nicht direkt falsch, aber es ist nicht das was du denkst)

[fabarazzi]

Ich habe diese Zeilen eben rauskopiert und als neues Projekt angelegt. Dabei tritt der Fehler nicht auf... Komisch.

Zu der Frage wieso 1.0f: Eigtl steht dort eine Variable die einen float-Wert beinhaltet. 1.0f habe ich nur testweise hingeschrieben, um den Fehler zu finden.

Statt dem %lf sollte ich wohl eher %e nehmen. Ist nur hängengeblieben von den anderen Versuchen.

Also den Code, den ich gerade gepostet habe, da spielt sich alles ab, was die Variablen und die Funktion betrifft:
In der Funktion f_steps habe ich testweise direkt als ersten Befehl die Ausgabe von time gefordert.
Und beim Funktionsaufruf (err = f_steps(p_step,1,1.0f)) kann ja an der Variablen auch nichts mehr geändert werden.

Aber logischerweise muss der Wert von time ja irgendwo verändert werden, aber wo sollte das geschehen? Und wieso funktioniert der Code, wenn ich anstelle des floats ein double, und den Parameter als double übergebe? Und printf natürlich anpasse..

[SeppJ]

fabarazzi schrieb:

Statt dem %lf sollte ich wohl eher %e nehmen. Ist nur hängengeblieben von den anderen Versuchen.

Erklär mal, was gegen %f spricht. Und ich nehme schonmal vorweg: Deine Erklärung ist falsch.

Aber logischerweise muss der Wert von time ja irgendwo verändert werden, aber wo sollte das geschehen? Und wieso funktioniert der Code, wenn ich anstelle des floats ein double, und den Parameter als double übergebe? Und printf natürlich anpasse..

Du wirst irgendwo in dem Teil den du uns verschwiegen hast undefiniertes Verhalten erzeugen. Das ist eben komisch. Und deswegen wurdest du auch schon zigmal aufgefordert:

SeppJ schrieb:

Zeig mal ein vollständiges Beispiel, welches den Fehler produziert.

Aber mir ist das langsam zu blöd. Wenn du nicht geholfen werden möchtest, dann musst du dir eben selber behilflich sein.

[fabarazzi]

Erklär mal, was gegen %f spricht. Und ich nehme schonmal vorweg: Deine Erklärung ist falsch.

Ich dachte nunmal, dass ich für einen double Wert als Formatierung entweder %lf oder %e verwende. Was daran so falsch ist, verstehe ich jetzt nicht, aber erklären kannst du es anscheinend ja auch nicht.

Wenn ich wüsste wo undefiniertes Verhalten zustande kommt, hätte ich es behoben und nicht dumm gefragt. Was eine direkt übergebene Variablen verändert, wenn der erste Befehl in der Funktion ein printf() ist, bleibt mir allerdings schleierhaft.
Ich biete dir gern meinen kompletten Code hier an, allerdings wird dort nirgends irgendetwas an der Funktion oder Variablen geändert:

In Zeile 66 wird die Funktion aufgerufen:

void work(int time)      
{
    float get_time;
    if(time){get_time = 1;}
    int i,z,err;
    err = 0;
    float time_verbrauch;
    float new_state;
    float act_state;
    int summe_steps = 0;
    /*Auftrag aus ORDER holen*/
    p_order = p_order_start;

    time_verbrauch = 0;
    while(p_order && !err)
    {
        printf("\nDEFINIERTE ANZAHL AN STEPS*QUANTITY %f\n\n",p_order->steps_quantity);
        /*Auftrag fuer Auftrag soll abgearbeitet werden*/
        /*get STATUS von ORDER*/
        act_state = p_order->status;

        /*Welcher Schrank soll gebaut werden*/
        p_schrank = p_order->id;

        /*naechsten STEP mittels STATUS und STEP finden*/
        i = 0;
        p_step = p_schrank->p_steps[i];

        new_state = 0;
        while(p_step && !err)
        {
            z = 0;
            while(z<p_schrank->steps_quantity[i] && !err)  //Solange noch nicht alle WIEDERHOLUNGEN von STEP erledigt wurden
            {
                /*Zeitverbrauch addieren*/
                new_state += p_step->time;

                /*Fange mit Arbeit erst an, wenn aktueller Status erreicht ist*/
                if(new_state>act_state && time_verbrauch<get_time)
                {
                    if(p_step->time > (get_time-time_verbrauch))   //falls zeitaufwand fuer step zu groß ist
                    {
                        printf("%f",p_step->time);
                        printf(" GEG %f GEG",get_time);
                        printf("Der AS braucht zu lange\n");

                        err = f_steps(p_step,1,get_time-time_verbrauch);
                        if(!err)
                        {
                            /*Neuer Status = alter STATUS + Zeit*/
                            p_order->status += p_step->time; // ODER new_state

                            time_verbrauch += p_step->time;

                            //Teil des Schrittes bearbeiten
                            p_order->status = act_state + get_time;
                            time_verbrauch = get_time;

                            printf("\nSTEP wird teilweise ausgefuehrt\n");
                            printf("Und zwar: %s \n",p_step->name);
                        }
                    }
                    else    //Zeitaufwand fuer STEP passt noch in TIME budget
                    {
                        //Status bekommen
                        err = f_steps(p_step,1,1.0f);
                        if(!err)
                        {
                            /*Neuer Status = alter STATUS + Zeit*/
                            p_order->status += p_step->time; // ODER new_state

                            time_verbrauch += p_step->time;
                        }

                        printf("\nES WIRD EIN STEP AUSGEFUEHRT, %f + %f\n",time_verbrauch, p_step->time);
                        printf("Und zwar: %s \n",p_step->name);
                    }

                }

                if(p_order->status == p_order->steps_quantity)    //ORDER fertig
                {
                    printf("Auftrag erfolgreich ausgefuehrt");
                    p_order_start = p_order->next_order;
                }

                //f_steps(p_step,1,p_step->time);
                z++;
            }
            i++;
            p_step = p_schrank->p_steps[i];
        }
        printf("\nVERBRAUCHTE ZEIT: %f\n",time_verbrauch);
        printf("\n\n\nNEUER STATUS: %f\n\n\n",p_order->status);

        p_order = p_order->next_order;
    }

    switch(err)
    {
        case 0:
            printf("\nKein Fehler\n");
            break;
        case 1:
            printf("\nKein Kapital\n");
            break;
        case 2:
            printf("\nKeine Ressourcen\n");
            break;
    }
}

int f_steps(STEP *p_step, int quantity, float time)
{
    printf("%f\n",time);
    /*ABHAENGIG VON ZEIT*/

    int i = 0;
    int err = 0;
    /*Suche in Arbeitsschritt, welche Ressource verarbeitet wird*/
    if(!p_step->p_ressources && strcmp(p_step->ressource,"")) /*Falls kein Pointer vorhanden, aber Wert existiert*/
    {
        p_ressource = search_ressource(p_step->ressource);
    }
    else
    {
        p_ressource = p_step->p_ressources;
    }

    /*Ressource in p_ressource abgelegt (sofern es eine gibt)*/

    /*Geld fuer AS vorhanden?*/
    if(kapital<(quantity*time*p_step->price))
    {
        err = 1;
    }

    /*Genuegend Ressourcen im Lager vorhanden?*/
    if(p_ressource && p_ressource->stock < (quantity*time))
    {
        err = 2;
    }

    /*Ressourcen vom Lagerbestand abziehen, Kapital abzueglich der AS-Kosten*/
    if(!err)
    {
        printf("Kein Fehler %lf %f",time,p_step->price);
        kapital = kapital - time*p_step->price;
        if(p_ressource) p_ressource->stock = p_ressource->stock - (quantity*time);              //!Es sollten eigtl keine 0.x Mengen abgeubcht werden koennen
    }

    return err;
}

[Belli]

fabarazzi schrieb:

Erklär mal, was gegen %f spricht. Und ich nehme schonmal vorweg: Deine Erklärung ist falsch.

Ich dachte nunmal, dass ich für einen double Wert als Formatierung entweder %lf oder %e verwende.

Warum dachtest Du das denn? Nimm nicht %lf, sondern %f - fertig, %e geht natürlich auch, erzeugt aber eine andere Darstellung.

[cooky451]

fabarazzi schrieb:

Erklär mal, was gegen %f spricht. Und ich nehme schonmal vorweg: Deine Erklärung ist falsch.

Ich dachte nunmal, dass ich für einen double Wert als Formatierung entweder %lf oder %e verwende. Was daran so falsch ist, verstehe ich jetzt nicht, aber erklären kannst du es anscheinend ja auch nicht.

Doch, kann er, nur wollte er dir die Möglichkeit lassen mal zu zeigen, dass du auch in der Lage bis so etwas selbst herauszufinden. Dürfte in so ziemlich jeder Doku zu printf stehen.

[fabarazzi]

Dann bedanke ich mich gerne für diesen Tip. Allerdings benötige ich jetzt keine Ausgabe von double-Werten.
Meine Problem war die Übergabe eines float-Parameters an eine Funktion ..

[DirkB]

fabarazzi schrieb:

Meine Problem war die Übergabe eines float-Parameters an eine Funktion ..

Ist dein Problem jetzt behoben?

fabarazzi schrieb:

Ich biete dir gern meinen kompletten Code hier an, ...

Auch diesen Code kann man nicht nachvollziehen, da dort kein main() vorhanden ist.

Warum muss es eigentlich float sein?
float nimmt man heutzutage nur noch wenn man sehr sehr viele Werte davon hat.
Schneller wird es mit float auch nicht, da die Berechnungen alle in double ausgeführt werden und somit jedesmal konvertiert werden muss.

[fabarazzi]

Dann wäre es an sich ja klüger einen double zu verwenden .. Danke.

Prinzipiell muss es kein double sein. Nur würde mich interessieren, wieso es hier zu einem Problem kommt, wenn ich einen float-Wert angebe ..

Wegen der Darstellung des Codes:
Ich wollte nur das Prinzip verdeutlichen, wie ich die Funktion aufrufe und was für Parameter verwendet werden. An und für sich ist das auch kein Hexenwerk. Nur komischerweise spinnt er bei mir bei einem bestimmten Datentyp.
Ich kann leider auch nicht die komplette Funktion mit der main hier posten, da dies viel zu unübersichtlich würde. Der relevante Teil, war der Teil, den ich hier veröffentlicht habe: http://ideone.com/ZvI1C

Und da funktioniert das Ganze ja auch. Die Frage, die ich mir stelle ist: Wo ein direkt übergebener Wert an eine Funktion verändert wird, wenn die erste Anweisung in der Funktion ein printf() ist. Eigtl ist dies doch nicht möglich.

Bei meiner Frage ging es nicht um Grundverständnisfragen, oder gar einen Streit, um Formatierungsausgabemöglichkeiten.

Aber um hier nicht noch weitere genervte Kommentare zu sammeln, belasse ich es dabei und suche die Lösung des Problems selbst.

Nebenbei sei nur angemerkt, dass ich niemanden gezwungen habe mir zur helfen. Und falls jemand meint sich des öfteren aufregen zu müssen, da ihm meine Problembeschreibung nicht passt, dann sollte er es sein lassen, noch weiter unnötige Anmerkungen zu schreiben, dass er keine Lust hat zu helfen. Was daran produktiv sein soll, versteh ich nicht ganz ..

Für die anderen Tips bin ich allerdings dankbar.

[Wutz]

fabarazzi schrieb:

Aber um hier nicht noch weitere genervte Kommentare zu sammeln, belasse ich es dabei und suche die Lösung des Problems selbst.

Richtig. Die Lösung des Problems liegt bei dir. Das Problem selbst auch.
Der Compiler hat immer recht.