Euch beiden erstmal wirklich vielen Dank, so versteht man Dinge einiges schneller, als sich tausend Tutorials durch zu lesen.
Dein erster Teil ATH0, muss ich mir noch ein paar mal durchlesen, vllt ist es auch noch nicht an der Zeit den Teil zu verstehen^^
Das mit dem malloc buffer, ist mit jetzt klar geworden, ist logisch wenn man es verstanden hat.
Ich denke so:
PHP:
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
typedef struct product_data PRODUCT_DATA;
struct product_data {
int product_code;
char *product_value;
PRODUCT_DATA *next;
};
PRODUCT_DATA *products_head = NULL;
PRODUCT_DATA *products_tail = NULL;
PRODUCT_DATA *newproduct;
void new_value(int number, char*value)
{
newproduct = malloc(sizeof(PRODUCT_DATA));
newproduct->product_code = number;
newproduct->product_value = value;
newproduct->next = NULL;
if (!products_head) products_head = newproduct;
else products_tail->next = newproduct;
products_tail = newproduct;
}
char*read_value(int number)
{
PRODUCT_DATA *product;
product = products_head;
while (product)
{
if (product->product_code==number)
{
break;
}
else
{
product = product->next;
}
}
char*back=product->product_value;
return back;
}
int main()
{
FILE*pipe=popen("ls -la", "r");
int counter=1;
char *buffer = (char*) malloc(sizeof(char)*200);
while (fgets(buffer, 200, pipe))
{
new_value(counter, buffer);
buffer = (char*) malloc(sizeof(char)*200);
counter++;
}
int print_all;
for (print_all=1; print_all<products_tail->product_code+1; print_all++)
{
printf("%s", read_value(print_all));
}
while (products_head)
{
products_tail = products_head->next;
free(products_head);
products_head = products_tail;
}
return 0;
}
ich denke damit kann ich relativ zufrieden sein, das ist genau das was ich wollte. Das ist wie eine Revolution in C für mich
. Denn das ist ohne diese Dynamic immer sehr umständlich Pipes oder sonstiges auszulesen, wenn man nicht weiß wie lange die Ausgabe ist.
Das ist ne super sache mit den linkedlists, "wenn man es verstanden" hat...
Eine weitere Frage zu der buffer Geschichte hätte ich noch...
Was bei char buffer[200] passiert verstehe ich...
Aber wenn ich nun buffer = (char*) malloc(sizeof(char)*200); , was bedeutet genau die 200 jetzt, setzt er nun beim ersten mal 200 wie bei buffer[200] frei, und beim zweiten Aufrufen diesen Befehls nochmals 200 zu den 200 dazu? Das kann ja eig. nicht sein, da ja sonst der Inhalt von den vorherigen 200 noch darin enthalten wäre... So wie ich es verstanden habe, ist malloc dafür zuständig so viel Speicherplatz freizustellen, wie ich ich in dem Moment benötige, doch wofür ist dann die 200? Ich glaub in dem Punkt bin ich noch etwas zu verwirrt^^
edit: denn zum Beispiel hier:
newproduct = malloc(sizeof(PRODUCT_DATA));
wird ja keine bestimmte Zahl angegeben, sondern ein Datentyp, warum ist das bei der buffer sache anders?