malloc()

nwp2

Eine typische Anwendung sind Buffer/listen.
Zum Beispiel sowas wie

struct buffer{
   struct buffer *next;
   void *value;
};

struct buffer *newbuffer(){
    struct buffer *b = malloc(sizeof(struct buffer));
    b->next = 0;
    b->value = 0;
}

void addvalue(struct buffer *b, const void *v){
    struct buffer *temp, *nb = newbuffer();
    for (temp = b; temp->next; temp = temp->next); //find end
    temp->next = nb;
    nsb->value = v;
}

void *getvalue(struct buffer *b){
    struct buffer *temp;
    char *value;
    if (!b) return 0; //ungültiger buffer
    if (!b->next) return 0; //leerer buffer
    if (!b->next->next){
        temp = b->next;
        b->next = 0;
        value = temp->value;
        free(temp);
        return value;
    }
    for (temp = b; temp->next->next; temp = temp->next); //find end
        value = temp->next->value;
        free(temp->next);
        temp->next = 0;
        return value;
    }
}

Wie du vielleicht siehst kannst du dir mit newbuffer einen buffer holen, mit addvalue alle möglichen Werte dort hineinstopfen und mit getvalue kriegst du die Wert wieder heraus. Man könnte es auch eine filo-Liste (first in last out) oder einen Stack nennen.

Sowas braucht man für alles mögliche, zum Zwischenspeichern von Werten die man später mal braucht. Die Alternative ist dass man alles in einen void *buffer[wirdschonreichen] packt, wobei wirdschonreichen eine Zahl ist der man je nach Stellung des Mondes irgendeinen Wert gibt. Ist er zu klein gibts nen Segfault, ist er zu groß kriegt man irgendwann Speicherprobleme. Ersteres ist problematischer, aber wenn man zu großzügig ist kriegt man zweiteres Problem.

Ein Beispiel wo es nicht ohne geht ist ein Betriebssystem. Jedes Programm dass unter gängigen Betriebssystemen läuft kann bis zu 3.5 bis 4GB Speicher nutzen. Wir wollen bis zu 100 Programme laufen lassen. Also brauchen wir 350GB Ram mindestens. Blöde Sache. Selbst wenn wir nur 10 Programme laufen lassen und bei einem halben GB Schluss machen braucht man einen Rechner mit 5GB RAM.

Ein einfaches Programmbeispiel wo man unbedingt malloc braucht gibt es nicht. Solange das Programm einfach ist kannst du auch wirdschonreichen-Arrays nehmen, denn selbst wenn dein Hello-World-Programm 10mb groß ist wird es nicht wesentlich langsamer als ein 1kb-Programm sein. Erst bei größeren Anwendungen spielt es eine Rolle ob du sauberen Code oder Schrott schreibst.

Die wirdschonreiche-Arrays haben auch noch das Problem der gezielten Überläufe, nachzulesen bei wiki: http://de.wikipedia.org/wiki/Puffer�berlauf

[cpp]
int main(void)
{
char *p;
p = malloc(sizeof(char));
}

int main(void)
{
char *p;
p = malloc(sizeof(char));
free(p);
return 0;
}

int main(void) 
{ 
    char *p; 
    p = malloc(1); // Speicherreservierung sizeof(char) ist immer 1.
    *p = 'X';   // Anwendung: Zuweisung eines Werts. 
    putchar(*p); // Anwendung: Dereferenzierung des Werts für die Funktion .putchar
    free(p); // Speicherfreigabe.
    return 0; 
}

nwp2 schrieb:

Die Alternative ist dass man alles in einen void *buffer[wirdschonreichen] packt, wobei wirdschonreichen eine Zahl ist der man je nach Stellung des Mondes irgendeinen Wert gibt. Ist er zu klein gibts nen Segfault...

du musst natürlich vorm schreiben darauf achten, dass noch genug platz da ist, dann gibts keinen segfault.

nwp2

;fricky schrieb:

nwp2 schrieb:

Die Alternative ist dass man alles in einen void *buffer[wirdschonreichen] packt, wobei wirdschonreichen eine Zahl ist der man je nach Stellung des Mondes irgendeinen Wert gibt. Ist er zu klein gibts nen Segfault...

du musst natürlich vorm schreiben darauf achten, dass noch genug platz da ist, dann gibts keinen segfault.

Richtig. Und wenn nicht mehr genug Platz da ist? malloc benutzen oder mit einer Fehlermeldung "Fehler: Programmierer zu blöd" das Programm beenden

nwp2 schrieb:

;fricky schrieb:

nwp2 schrieb:

Die Alternative ist dass man alles in einen void *buffer[wirdschonreichen] packt, wobei wirdschonreichen eine Zahl ist der man je nach Stellung des Mondes irgendeinen Wert gibt. Ist er zu klein gibts nen Segfault...

du musst natürlich vorm schreiben darauf achten, dass noch genug platz da ist, dann gibts keinen segfault.

Richtig. Und wenn nicht mehr genug Platz da ist? malloc benutzen oder mit einer Fehlermeldung "Fehler: Programmierer zu blöd" das Programm beenden

weder, noch. die daten sofort verarbeiten und den puffer wiederverwenden (eventuell in verbindung mit einem flusskontroll-mechanismus, der die datenquelle bremsen kann). ich bin der meinung, dass viele c-programmierer 'malloc' zu oft verwenden. damit meine ich noch nicht mal die, die int* p = malloc(sizeof(int)); oder sowas machen.

ch1ller

danke für die ganzen Beiträge
hat mir sehr geholfen und verstanden hab ich es jetzt auch nach mehrfachem verinnerlichen xd

gruß
steffen

darkfate

Wäre nicht schlecht wenn man bei malloc auch das Alignment einstellen könnte..

darkfate schrieb:

Wäre nicht schlecht wenn man bei malloc auch das Alignment einstellen könnte..

gibts auch schon. google mal nach aligned_malloc oder so.