C Onlinetest: Listenoperationen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • C Onlinetest: Listenoperationen

    Hallo, ich möchte in diesem Thread Fragen bezüglich dem Onlinetest am Montag klären und Probleme mit dem 3. Übungsblatt diskutieren.

    Hier meine bisherige Lösung zur ersten Aufgabe. Bis auf copy und custom snd alle Funktionen implementiert und eine kleine main testet diese. Was mir noch nichtklar ist, ist die custom Funktion. Was macht diese und soll sie inkludiert werden oder muss man sie implementieren?
    Des Weiteren frage ich mich, wie man mit dem "void-Inhalt" umgehen soll, sobald er ausgegeben wird, da man ja gar nicht weiß, welche Inhalte in der Liste gespeichert sind.

    Hier erst mal der code, soweit ich ihn habe:

    Quellcode

    1. #include<stdlib.h>
    2. #include<stdio.h>
    4. typedef struct _node{
    5. int *content;
    6. struct _node *prev;
    7. struct _node *next;
    8. } node;
    10. const int nsize = sizeof(node);
    12. node* add( node *firstnode, void *cont ) {
    14. node *newnode = malloc( nsize );
    15. newnode->content = cont;
    17. if( firstnode == NULL ) { /*Wenn Liste leer*/
    18. newnode->prev = NULL;
    19. newnode->next = NULL;
    20. return newnode;
    21. }
    23. else{ /*fuege in bestehende Liste ein*/
    24. newnode->next = firstnode;
    25. newnode->prev = NULL;
    26. firstnode->prev= newnode;
    27. return newnode;
    28. }
    29. }
    31. node* add_ith( node *firstnode, void *cont, int pos ) {
    33. int i;
    35. node *newnode = malloc( nsize );
    36. newnode->content = cont;
    38. node *itnode = firstnode; /*suche i-1te Position*/
    39. for( i=1 ; i< pos-1 ; i++ ) {
    40. itnode = itnode->next;
    41. }
    43. if( itnode == NULL) /*Position ausserhalb, nicht einfuegen*/
    44. return firstnode;
    46. else{
    47. newnode->next = itnode->next; /*fuege neuen Knoten ein*/
    48. newnode->prev = itnode;
    49. newnode->next->prev = newnode;
    50. itnode->next = newnode;
    52. return firstnode;
    53. }
    54. }
    56. node* add_last( node *firstnode, void *cont ){
    58. node *newnode = malloc( nsize );
    59. newnode->content = cont;
    61. node *itnode = firstnode; /*suche letzten Knoten*/
    62. while( itnode->next != NULL ) {
    63. itnode = itnode->next;
    64. }
    65. itnode->next = newnode;
    66. newnode->prev = itnode;
    67. newnode->next = NULL;
    69. return firstnode;
    70. }
    72. node* del( node *firstnode){
    74. if( firstnode == NULL || firstnode->next == NULL) /*Wenn kein oder nur ein Konten vorhanden*/
    75. return NULL;
    77. else{
    78. node *newfirstnode = firstnode->next;
    79. newfirstnode->prev = NULL;
    80. free(firstnode);
    81. return newfirstnode;
    82. }
    83. }
    85. node* del_ith( node *firstnode, int pos ){
    87. int i;
    89. node *itnode = firstnode;
    91. for( i=1 ; i< pos-1 ; i++ ){ /*suche i-1te Position*/
    92. itnode = itnode->next;
    93. }
    95. if( itnode == NULL || itnode->next == NULL) /*wenn knoten nicht vorhanden*/
    96. return firstnode;
    98. else{
    99. node *delnode = itnode->next; /*merke zu loeschenden Knoten*/
    100. itnode->next = delnode->next;
    101. delnode->next->prev = itnode;
    102. free(delnode);
    103. return firstnode;
    104. }
    105. }
    107. node* del_last( node *firstnode){
    109. node *itnode = firstnode;
    111. while( itnode->next->next != NULL ) /*suche vorletzten Knoten*/
    112. itnode = itnode->next;
    114. free(itnode->next);
    115. itnode->next = NULL;
    116. return firstnode;
    117. }
    119. void del_all( node *firstnode ) {
    120. node *delnode = firstnode;
    122. while( firstnode->next != NULL ){
    123. firstnode = firstnode->next;
    124. free( delnode );
    125. delnode = firstnode;
    126. }
    128. free( delnode );
    129. }
    131. int main(void){
    132. int i1 = 0;
    133. int i2 = 1;
    134. int i3 = 2;
    135. void *eins = &i1;
    136. void *zwei = &i2;
    137. void *drei = &i3;
    139. node *dvlist = NULL;
    140. dvlist = add(dvlist,eins);
    141. dvlist = add(dvlist,zwei);
    142. dvlist = add_ith(dvlist,drei,2);
    144. printf("%d,%d,%d\n", *(dvlist->content), *(dvlist->next->content), *(dvlist->next->next->content));
    146. del_all(dvlist);
    148. return 1;
    149. }
    Alles anzeigen
    >: 4 8 15 16 23 42

  • Hi,
    grundsätzlich ist es schonmal schweinegefährlich in der Liste nur Zeiger auf den Inhalt zu halten.Da besteht immer die Gefahr dass der Zeiger im Laufe des Programms ungültig wird.
    Ansonsten sieht es so aus dass durch denn void* Typ die Listenverwaltungsfunktionen nen generischen Character bekommen sollen.
    Dann muss der C Programmierer natürlich schon einiges an Disziplin mitbringen und wirklich nur Daten in die Liste schieben die dem aktuellen Typ von _node->content entsprechen.Durch reines austauschen des Typs von node->content ist diese Listenimplementierung auch für andere Typen verwendbar(zumindest soweit ich dass auf die Schnelle überflogen habe).
    Was soll denn custom sein?

    Gruß void
    "Probleme kann man niemals mit derselben Denkweise lösen,
    durch die sie entstanden sind." (A. Einstein)

  • Es handelt sich hierbei um eine Aufgabe der Lehrveranstaltung Programmieren 3. Ziel ist eine dopelt verkettete Liste mit beliebigem Datensatz (Zeiger auf void). Da ist mir auch schon ein Fehler aufgeallen:

    In dem _node Struct müsste natürlich: "void *content" stehen.
    Habe nur zum ausprobieren int angegeben. Daher ergibt sich auch das Problem mit dem vaiablen Inhalt der Liste.
    Was die Custom-Funktion bewirken soll ist mir leider auch nicht klar, daher frage ich ja. Falls es dich interssiert, kannst du dir die Aufgabe hier ansehen:

    http://www.mi.fh-wiesbaden.de/~barth/prog3/prakt/Prog3PraktPB3.pdf
    >: 4 8 15 16 23 42

  • Naja,
    für del_all_custom ist custom nen Funktionszeiger auf ne beliebige Funktion die nen void Zeiger entgegen nimmt und void zurück gibt.
    Kennst du for_each und transform aus C++? Prinzipiell sollen die Funktionen del_all_custom und copy_custom ähnlich arbeiten.
    copy_all_custom soll ne neue Liste aufbauen deren Elemente aber aus den Rückgabewerten der Funktion bestehen,die du als custom übergeben hast.
    del_all_custom soll die Liste löschen aber vorher noch für jeden Wert der Liste die als custom übergebene Funktion(mit dem Wert als Parameter) ausführen.
    Ich küsse Bjarne Stroustrup den Arsch dass es C++ gibt.....

    Gruß void
    "Probleme kann man niemals mit derselben Denkweise lösen,
    durch die sie entstanden sind." (A. Einstein)

  • hi void, hi sebastian (zu dem Trupp an der FH Wiesbaden gehör ich übrigens auch...)

    ich bin auch froh, wenn wir ab Montag bei Python sind.

    Im Vergleich zur void del_all( node *firstnode ) würd ich in der _custom einfach diesen custom() aufruf mit content als Parameter ergänzen.. ist ja noch alles void.

    Quellcode

    1. void del_all_custom(node *firstnode , void (∗custom)(void ∗)) {
    2. node *delnode = firstnode;
    4. while( firstnode->next != NULL ){
    5. firstnode = firstnode->next;
    6. custom(firstnode->content);
    7. free( delnode );
    8. delnode = firstnode;
    9. }
    11. free( delnode );
    12. }
    Alles anzeigen


    Hast du mal mit valgrind gecheckt ob du das letzt free( delnode ) überhaupt noch aufrufen musst?
    Denn eigentlich ist ja alles gelöscht, oder?

    Aber diese custom() leuchtet mir nicht ein... was soll sie denn nun tun.. übergeben tu ich den content und zurückliefern tu ich einen pointer auf den content?

    Was soll denn das Ziel der Funktion sein?
    Wenn ich die liste mit copy_custom kopiere, könnte ich beide listen am ende unabhängig weiter befüllen/sortieren/...
    Wenn ich aber den content eines objekts aus liste A ändere, dann ändert sich auch der content des entsprechenden objekt in liste B.

    Steh da irgendwie auf dem schlauch...

  • Hi,
    ich hab heute abend zwar schon nen paar Bier auf aber ich hab mal ne Beispielimplementierung geschrieben.Zumindest so wie ich die Aufgabenstellung verstehe..... :) .
    Das Ganze baut auf DjRasts bisheriger Lösung auf(obwohl ich glaube dass da noch Fehler drin sind).

    Quellcode

    1. //Beispiel custom Funktion
    2. void print_as_int(void* arg)
    3. {
    4. printf("Der Wert des Knotens ist %d\n",*((int*)arg));
    5. }
    7. void del_all_custom( node *firstnode ,void(*custom)(void*))
    8. {
    9. node *delnode = firstnode;
    11. while( firstnode->next != NULL ){
    12. firstnode = firstnode->next;
    13. custom(delnode->content);
    14. free( delnode );
    15. delnode = firstnode;
    16. }
    17. free( delnode );
    18. }
    21. node* copy_custom(node* _original_list,void*(*custom)(void*))
    22. {
    23. node *head = NULL;
    24. void* temp_content;
    26. if(_original_list != NULL)
    27. {
    28. head = (node*)malloc(sizeof(node));
    29. head->content = custom(_original_list->content);
    30. head->next=NULL;
    31. head->prev=NULL;
    33. while(_original_list->next != NULL)
    34. {
    35. _original_list = _original_list->next;
    36. temp_content = custom(_original_list->content);
    37. add_last(head,temp_content);
    38. }
    39. }
    40. return head;
    41. }
    42. //manipulierende "custom" Funktion
    43. void* add2(void* _value)
    44. {
    45. int* new_value = (int*)malloc(sizeof(int));
    46. *new_value = *((int*)_value)+2;
    48. return new_value;
    49. }
    51. int main(void){
    52. int i1 = 0;
    53. int i2 = 1;
    54. int i3 = 2;
    55. void *eins = &i1;
    56. void *zwei = &i2;
    57. void *drei = &i3;
    59. node *dvlist = NULL;
    60. node *list = NULL;
    61. dvlist = add(dvlist,eins);
    62. dvlist = add(dvlist,zwei);
    63. dvlist = add_ith(dvlist,drei,2);
    65. list = copy_custom(dvlist,add2);
    67. del_all_custom(dvlist,print_as_int);
    68. del_all_custom(list,print_as_int);
    70. return 1;
    71. }
    Alles anzeigen


    Gruß void
    "Probleme kann man niemals mit derselben Denkweise lösen,
    durch die sie entstanden sind." (A. Einstein)