dynamisch speicher allokieren



  • hallo!

    ich will dynamisch speicher für matrizen allokieren.
    das klappt auch alles wunderbar bis ich ungefähr 2500 Byte allokiert habe.
    dann kriege ich eine access-violation-exception wenn ich speicher inne gewissen intervall allokieren möchte:

    fehler treten auf bei:

    inventory[0]=(float *)malloc(800);
    inventory[0]=(float *)malloc(900);

    klappen tun:

    inventory[0]=(float *)malloc(100);
    inventory[0]=(float *)malloc(1000);

    so nem phänomen bin ich noch nie begegnet. fällt da wem was ein?

    danke
    dirk



  • Vielleicht mal sizeof(float) benutzen? Und dann vielleicht auch mit calloc?

    float* floatarray = (float*)calloc(Elementzahl, sizeof(float));
    

    oder:

    float* floatarray = (float*)malloc(Elementzahl * sizeof(float));
    

    Dabei ist Elementzahl die Anzahl der Floatwerte die Du in floatarray ablegen willst.
    Einfach eine Anzahl vom Bytes zu allokieren und dann Floatwerte reinknüppeln ist nicht unbedingt das Sicherste.



  • auf das casten sollte man aber verzichten



  • Hmm, malloc bzw. calloc geben aber void Zeiger zurück. Bei hohem Warn-Level haut der Compiler Warnings raus. Und Warnings versuche ich eigentlich immer zu vermeiden.



  • warum sollte man casts vermeiden?
    solange man weiß was man tut, ist mir noch nie was schlimmes passiert. (was nicht heißen soll, dass ich immer weiß was ich tue...;-))



  • Ein compiler der hier warnt gehoert in die Muelltonne.

    Ein cast verhindert, dass erkannt wird, dass es fuer malloc keinen Prototypen gibt (weil man stdlib.h vergessen hat)

    auf architekturen wo sizeof(void*) != sizeof(int) fliegt dir das programm um die ohren.

    in c99 ist dieser cast nicht mehr gefaehrlich, aber immernoch sinnlos und irrefuehrend.



  • Auf welcher Architektur haben Zeiger unterschiedliche Längen?? Probleme gäbe es nämlich nur, wenn sizeof(void*) != sizeof(Andere Zeigertypen)...



  • Tachyon schrieb:

    Auf welcher Architektur haben Zeiger unterschiedliche Längen?? Probleme gäbe es nämlich nur, wenn sizeof(void*) != sizeof(Andere Zeigertypen)...

    auf garkeinen, warum fragst du?
    was hat das mit meinem beitrag zu tun?

    sizeof(void*) != sizeof(int)

    warum int, fragst du dich?
    welchen rueckgabewert wird bei einer funktion angenommen, zu der es keinen prototypen gibt?



  • Ich frage mich eher, was die Aussgage soll. Der generische void-Zeiger hat doch gerade den Sinn, daß man ihn auf beliebige Datenstrukturen zeigen lassen kann. Die Prototypen für malloc/calloc aller Compiler die ich kenne haben weiterhin ausschließlich einen void-Zeiger als Rückgabewert. Alles andere wäre auch Unsinn. Für zusammengesetzte Typen müßte man schließlich eh wieder auf void zurückgreifen. Und void-Zeiger werden nuneinmal in den jeweilig passenden Zeigertypen umgecastet (oben halt float*).



  • Tachyon schrieb:

    Die Prototypen für malloc/calloc aller Compiler die ich kenne haben weiterhin ausschließlich einen void-Zeiger als Rückgabewert. Alles andere wäre auch Unsinn.

    Stimmt. Aber man kann malloc auch aufrufen, wenn man stdlib.h vergessen hat einzubinden. In dem Fall glaubt der Compiler, der Rückgabewert wär int.
    Das ist an sich kein Problem, weil der Compiler hier hängenbleibt:

    int * foo = malloc(25*sizeof(int));
    

    int ist schließlich nicht ohne weiteres in int* konvertierbar. Schreibst du dort allerdings nen Cast nach int* hin, meckert der Compiler nicht, und schleust seelenruhig einen void* durch einen int in einen int*. Und wenn das zufällig nicht hinhaut (weil z.b. void* und int unterschiedliche Größen haben) gibts Ärger.



  • Ahso, das ist natürlich einzusehen.


Log in to reply