Die Mathe-Redaktion - 23.05.2018 22:19 - Registrieren/Login
Auswahl
ListenpunktHome
ListenpunktAktuell und Interessant ai
ListenpunktArtikelübersicht/-suche
ListenpunktAlle Links / Mathe-Links
ListenpunktFach- & Sachbücher
ListenpunktMitglieder / Karte
ListenpunktRegistrieren/Login
ListenpunktArbeitsgruppen
Listenpunkt1 im Schwätz / Top 15
ListenpunktWerde Mathe-Millionär!
ListenpunktAnmeldung MPCT Juli
ListenpunktFormeleditor fedgeo
Aktion im Forum
Suche
Stichwortsuche in Artikeln und Links von Matheplanet
Suchen im Forum
Suchtipps

Bücher
Englische Bücher
Software
Suchbegriffe:
Mathematik bei amazon
Naturwissenschaft & Technik
In Partnerschaft mit Amazon.de
Kontakt
Mail an Matroid
[Keine Übungsaufgaben!]
Impressum

Bitte beachten Sie unsere Nutzungsbedingungen, die Distanzierung, unsere Datenschutzerklärung und
die Forumregeln.

Sie können Mitglied werden. Mitglieder können den Matheplanet-Newsletter bestellen, der etwa alle 2 Monate erscheint.

Der Newsletter Okt. 2017

Für Mitglieder
Mathematisch für Anfänger
Wer ist Online
Aktuell sind 564 Gäste und 30 Mitglieder online.

Sie können Mitglied werden:
Klick hier.

Über Matheplanet
 
Zum letzten Themenfilter: Themenfilter:
Matroids Matheplanet Forum Index
Moderiert von matph
Informatik » Programmieren » C: Einfach verkettete Liste
Druckversion
Druckversion
Antworten
Antworten
Autor
Universität/Hochschule C: Einfach verkettete Liste
Specialagent
Aktiv Letzter Besuch: im letzten Monat
Dabei seit: 17.11.2012
Mitteilungen: 64
Aus:
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Themenstart: 2018-01-18


Hallo zusammen,

ich möchte Eigenschaften der chemischen Elemente in Form einer einfach verketteten Liste verwalten. Hierbei soll die Funktion einfuegen() mithilfe der Funktion zeigerAufNeuenKnoten() ein neues Element gemäß seiner Ordnungszahl in aufsteigender Reihenfolge in die Liste einfügen.

Also für den Anfang muss ich glaube ich 4 Fälle unterscheiden, damit das Element korrekt in die Liste eingefügt wird:

1) Es gibt noch kein Element in der Liste -> eingegebenes Element wird dann das erste in der Liste.
2) Eingegebenes Element ist das größte und wird hinten angehängt
3) Eingegebenes Element ist das kleinste und wird an den Anfang eingefügt
4) Eingegebenes Element muss irgendwo in der Mitte bzgl. seiner Ordnungszahl (kleiner oder größer) eingefügt werden.

Ich glaube ich habe bereits die Fallunterscheidung in einfuegen() nicht richtig umgesetzt und habe noch Probleme die ganze Geschichte mit Zeigern umzusetzen.

Könnte mir bitte jemand sagen was genau falsch ist bzw. wo meine Fehler liegen und mir einen Rat geben wie ich vorgehen muss?

Danke Euch.
C
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. typedef struct Knoten{
  6. char name[20];
  7. char symbol[3];
  8. int ordnungszahl;
  9. struct Knoten* rest;
  10. }Knoten;
  11.  
  12. typedef Knoten* Liste;
  13.  
  14.  
  15. Knoten* zeigerAufNeuenKnoten (char name[20], char symbol[3], int ordnungszahl, Knoten* r) {
  16.  
  17. Knoten* neu = malloc(sizeof(Knoten));
  18.  
  19. if(neu == NULL)
  20. {
  21. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  22. exit(EXIT_FAILURE);
  23. }
  24. strcpy(neu->name, name);
  25. strcpy(neu->symbol, symbol);
  26. neu->ordnungszahl = ordnungszahl;
  27.  
  28. neu->rest = r;
  29.  
  30. return neu;
  31. }
  32.  
  33.  
  34. Liste einfuegen (Liste l, char name[20], char symbol[3], int ordnungszahl) {
  35.  
  36. struct Knoten *zeiger, *zeiger1;
  37.  
  38. /* 1. Element der Liste? */
  39. if(neu == NULL)
  40. zeigerAufNeuenKnoten(name, symbol, ordnungszahl, r);
  41. /* nicht das 1. Element */
  42. else {
  43. zeiger=neu;
  44. while((zeiger != NULL) && (zeiger->ordnungszahl) < 0)
  45. zeiger=zeiger->rest;
  46. /* Falls Zeiger auf NULL zeigt, Element hinten anhängen */
  47. if(zeiger==NULL)
  48. zeigerAufNeuenKnoten(name, symbol, ordnungszahl, r);
  49. /* Ist Element das kleinste, so an den Anfang setzen */
  50. else if(zeiger==neu) {
  51. neu=malloc(sizeof(struct Knoten));
  52. if(NULL == neu) {
  53. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  54. exit(EXIT_FAILURE);
  55. }
  56. strcpy(neu->name, name);
  57. strcpy(neu->symbol, symbol);
  58. neu->ordnungszahl = ordnungszahl;
  59.  
  60. neu->rest = zeiger;
  61.  
  62. }
  63.  
  64. else {
  65. zeiger1=neu;
  66. /* Wir suchen das Element, das vor dem
  67.   * Zeiger zeiger steht. */
  68. while(zeiger1->rest != zeiger)
  69. zeiger1=zeiger1->rest;
  70. zeiger=malloc(sizeof(struct Knoten));
  71. if(NULL == zeiger) {
  72. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  73. exit(EXIT_FAILURE);
  74. }
  75. strcpy(zeiger->name,name);
  76. strcpy(zeiger->symbol, symbol);
  77. zeiger->ordnungszahl = ordnungszahl;
  78. /* Wir fügen das neue Element ein. */
  79. zeiger->rest=zeiger1->rest;
  80. zeiger1->rest=zeiger;
  81. }
  82. }
  83. }
  84.  
  85. //Liste loeschen( Liste l, int ordnungszahl ){
  86.  
  87. //***
  88. //}
  89.  
  90.  
  91. //void ausgeben( Liste l ){
  92.  
  93. //***
  94. //}
  95.  
  96. int main(void){
  97.  
  98. Liste l=NULL;
  99.  
  100. l = einfuegen( l, "Aluminium", "Al" , 13 );
  101. l = einfuegen( l, "Calium", "Ca" , 20 );
  102. l = einfuegen( l, "Chlor", "Cl" , 17 );
  103. l = einfuegen( l, "Fluor", "F" , 9 );
  104. l = einfuegen( l, "Magnesium", "Mg" , 12 );
  105.  
  106. return 0;
  107. }
 
Später möchte ich noch in der Funktion loeschen() das Element mit der Ordnungszahl 'ordnungszahl' aus der Liste löschen und mit ausgeben() mir die in der Liste gespeicherten Daten ausgeben lassen, aber das ist erstmal nicht so wichtig.



  Profil  Quote  Link auf diesen Beitrag Link
StrgAltEntf
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 19.01.2013
Mitteilungen: 4058
Aus: Milchstraße
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.1, eingetragen 2018-01-18


Hallo Specialagent,

kannst du das Programm denn ohne Fehlermeldung compilieren? Ich vermute, dass nicht. Ein erster Schritt wäre, dass Programm so zu modifizieren, dass es vom Compiler keine Fehlermeldung mehr gibt.



  Profil  Quote  Link auf diesen Beitrag Link
Specialagent
Aktiv Letzter Besuch: im letzten Monat
Dabei seit: 17.11.2012
Mitteilungen: 64
Aus:
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.2, vom Themenstarter, eingetragen 2018-01-19


Guten Morgen,

das Programm lässt sich nicht fehlerfrei compilieren, da hast du recht. Daher würde ich mich freuen, wenn mir diesbezüglich jemand helfen könnte.

Ich weiß im Moment leider nicht, wie ich das Programm zu modifizieren habe bzw. wo genau der Fehler liegt und wieso.




  Profil  Quote  Link auf diesen Beitrag Link
StrgAltEntf
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 19.01.2013
Mitteilungen: 4058
Aus: Milchstraße
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.3, eingetragen 2018-01-19


Geben die Fehlermeldungen denn keinen Hinweis, was falsch gelaufen sein könnte?

Der Compiler sollte z. B. eine Meldung zu Zeile 39 ausgeben.



  Profil  Quote  Link auf diesen Beitrag Link
Specialagent
Aktiv Letzter Besuch: im letzten Monat
Dabei seit: 17.11.2012
Mitteilungen: 64
Aus:
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.4, vom Themenstarter, eingetragen 2018-01-19


Hallo,

ich habe mir die Fehlermeldungen mal angeschaut und probiert es hinzubekommen, aber so ganz will es noch nicht.

Meine Funktion einfuegen() muss ja noch etwas zurückgeben, aber ich weiß gerade nicht was ich überhaupt zurückgeben will. Eigentlich ist es doch die Liste l? Wenn ich das mache erhalte ich einen Speicherzugriffsfehler.

Ignoriere ich die Warnung vom Compiler und lasse das Programm laufen, dann fügt mir das Programm wohl Elemente in die Liste ein, ob es alle sind weiß ich gerade nicht. In der Ausgabe sehe ich jedenfalls nur das letzte Element mit der Ordnungszahl 12 (Ausgabe fkt. wurde hinzugefügt zum Überprüfen was überhaupt passiert).

Mein Code sieht jetzt folgendermaßen aus
C
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. typedef struct Knoten{
  6. char name[20];
  7. char symbol[3];
  8. int ordnungszahl;
  9. struct Knoten* rest;
  10. }Knoten;
  11.  
  12. typedef Knoten* Liste;
  13.  
  14.  
  15. Knoten* zeigerAufNeuenKnoten (char name[20], char symbol[3], int ordnungszahl, Knoten* r) {
  16.  
  17. Knoten* neu = malloc(sizeof(Knoten));
  18.  
  19. if(neu == NULL)
  20. {
  21. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  22. exit(EXIT_FAILURE);
  23. }
  24. strcpy(neu->name, name);
  25. strcpy(neu->symbol, symbol);
  26. neu->ordnungszahl = ordnungszahl;
  27.  
  28. neu->rest = r;
  29.  
  30. return neu;
  31. }
  32.  
  33.  
  34. Liste einfuegen (Liste l, char name[20], char symbol[3], int ordnungszahl) {
  35.  
  36. struct Knoten *neu = NULL;
  37. struct Knoten *zeiger, *zeiger1;
  38.  
  39. /* 1. Element der Liste? */
  40. if(neu == NULL)
  41. zeigerAufNeuenKnoten(name, symbol, ordnungszahl, NULL);
  42. /* nicht das 1. Element */
  43. else {
  44. zeiger=neu;
  45. while((zeiger != NULL) && (zeiger->ordnungszahl) < 0)
  46. zeiger=zeiger->rest;
  47. /* Falls Zeiger auf NULL zeigt, Element hinten anhängen */
  48. if(zeiger==NULL)
  49. zeigerAufNeuenKnoten(name, symbol, ordnungszahl, NULL);
  50. /* Ist Element das kleinste, so an den Anfang setzen */
  51. else if(zeiger==neu) {
  52. neu=malloc(sizeof(struct Knoten));
  53. if(NULL == neu) {
  54. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  55. exit(EXIT_FAILURE);
  56. }
  57. strcpy(neu->name, name);
  58. strcpy(neu->symbol, symbol);
  59. neu->ordnungszahl = ordnungszahl;
  60.  
  61. neu->rest = zeiger;
  62.  
  63. }
  64.  
  65. else {
  66. zeiger1=neu;
  67. /* Wir suchen das Element, das vor dem
  68.   * Zeiger zeiger steht. */
  69. while(zeiger1->rest != zeiger)
  70. zeiger1=zeiger1->rest;
  71. zeiger=malloc(sizeof(struct Knoten));
  72. if(NULL == zeiger) {
  73. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  74. exit(EXIT_FAILURE);
  75. }
  76. strcpy(zeiger->name,name);
  77. strcpy(zeiger->symbol, symbol);
  78. zeiger->ordnungszahl = ordnungszahl;
  79. /* Wir fügen das neue Element ein. */
  80. zeiger->rest=zeiger1->rest;
  81. zeiger1->rest=zeiger;
  82. }
  83. }
  84.  
  85.  
  86. }
  87.  
  88. //Liste loeschen( Liste l, int ordnungszahl ){
  89.  
  90. //***
  91. //}
  92.  
  93.  
  94. void ausgeben( Liste l ){
  95.  
  96. if (l->rest != NULL)
  97. ausgeben(l->rest);
  98.  
  99. printf("%d\n", l->ordnungszahl);
  100. }
  101.  
  102.  
  103.  
  104. int main(void){
  105.  
  106. Liste l=NULL;
  107.  
  108. printf("Einfügen der Elemente....\n");
  109.  
  110. l = einfuegen( l, "Aluminium", "Al" , 13 );
  111. l = einfuegen( l, "Calium", "Ca" , 20 );
  112. l = einfuegen( l, "Chlor", "Cl" , 17 );
  113. l = einfuegen( l, "Fluor", "F" , 9 );
  114. l = einfuegen( l, "Magnesium", "Mg" , 12 );
  115.  
  116. ausgeben( l );
  117.  
  118. return 0;
  119. }




  Profil  Quote  Link auf diesen Beitrag Link
ligning
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 07.12.2014
Mitteilungen: 2032
Aus: Berlin
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.5, eingetragen 2018-01-19


2018-01-19 18:13 - Specialagent in Beitrag No. 4 schreibt:
Meine Funktion einfuegen() muss ja noch etwas zurückgeben, aber ich weiß gerade nicht was ich überhaupt zurückgeben will. Eigentlich ist es doch die Liste l? Wenn ich das mache erhalte ich einen Speicherzugriffsfehler.
Du musst natürlich die veränderte Liste zurückgeben. Das kann manchmal l sein, aber falls du einen Knoten vorne angefügt hast oder die Liste vorher leer war, dann ist es ein Zeiger auf den neuen Knoten.

Warnungen zu ignorieren ist meistens falsch, siehst du ja auch hier. Wahrscheinlich bekommst zum Beispiel du eine Warnung, dass du den Rückgabewert von zeigerAufNeuenKnoten ignorierst.

Ob der Rest der Logik richtig ist, hab ich nicht überprüft. Es empfiehlt sich, die einzelnen Fälle mit Papier und Bleistift durchzugehen. Male Kästchen für die Knoten und Pfeile für die Zeiger.



-----------------
⊗ ⊗ ⊗



  Profil  Quote  Link auf diesen Beitrag Link
matph
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 20.11.2006
Mitteilungen: 5344
Aus: A
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.6, eingetragen 2018-01-19


Hallo,

Du kannst auch die Adresse der List übergeben (call-by-reference), um dieses Problem zu vermeiden smile

Deine Funktionen sehen dann z.B. wie folgt aus:
C
typedef struct NODE {int val; struct NODE *next;} Node;
typedef Node *List; 
 
void push(List *xs, int y){
  List new = (List)malloc(sizeof(Node));
  new->val = y;
  new->next = *xs;
  *xs=new;}
 
int pop(List *xs){
  List ys = *xs;
  int r = ys->val;
  *xs = ys->next;
  free(ys);
  return r;}
und der Aufruf dieser:
C
List xs=NULL;
push(&xs, 1);
pop(&xs);

--
mfg
matph


-----------------
Wir müssen wissen, wir werden wissen. Hilbert
Das Buch der Natur ist in der Sprache der Mathematik geschrieben. Galilei



  Profil  Quote  Link auf diesen Beitrag Link
Specialagent
Aktiv Letzter Besuch: im letzten Monat
Dabei seit: 17.11.2012
Mitteilungen: 64
Aus:
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.7, vom Themenstarter, eingetragen 2018-01-20


Guten Morgen,

danke für Eure Beiträge. Ich kann im Moment fehlerfrei kompilieren und mir soweit alles ausgeben lassen, wenn ich mir aber in der main() einfach via copy&paste weitere Elemente einfügen will, bekomme ich einen Speicherzugriffsfehler beim Ausführen. Wo übersehe ich gerade was?

Achja, die Funktionen loeschen() und ausgeben() wurden soweit jetzt auch hinzugefügt, falls da der Fehler liegen sollte.
C
  1. #include <stdio.h>
  2. #include <string.h>
  3. #include <stdlib.h>
  4.  
  5. typedef struct Knoten{
  6. char name[20];
  7. char symbol[3];
  8. int ordnungszahl;
  9. struct Knoten* next;
  10. }Knoten;
  11.  
  12. typedef struct Knoten *Liste;
  13. struct Knoten *next = NULL;
  14. struct Knoten *anfang = NULL;
  15.  
  16.  
  17. Knoten* zeigerAufNeuenKnoten (char *name, char *symbol, int ordnungszahl, Knoten* r) {
  18.  
  19. struct Knoten *zeiger;
  20.  
  21. if(anfang == NULL) {
  22. if((anfang = malloc(sizeof(struct Knoten))) == NULL){
  23.  
  24. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  25. exit(EXIT_FAILURE);
  26. }
  27. strcpy(anfang->name, name);
  28. strcpy(anfang->symbol, symbol);
  29. anfang->ordnungszahl = ordnungszahl;
  30.  
  31. anfang->next = NULL;
  32. }
  33. else{
  34. zeiger = anfang;
  35. while (zeiger->next != NULL)
  36. zeiger = zeiger->next;
  37. if((zeiger->next = malloc(sizeof(struct Knoten))) == NULL){
  38. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  39. exit(EXIT_FAILURE);
  40. }
  41. zeiger = zeiger->next;
  42. strcpy(zeiger->name, name);
  43. strcpy(zeiger->symbol, symbol);
  44. zeiger->ordnungszahl=ordnungszahl;
  45.  
  46. zeiger->next=NULL;
  47. }
  48. return zeiger;
  49. }
  50.  
  51.  
  52. Liste einfuegen (Liste l, char *name, char *symbol, int ordnungszahl) {
  53.  
  54.  
  55. struct Knoten *zeiger, *zeiger1;
  56.  
  57. /* 1. Element der Liste? */
  58. if(anfang == NULL)
  59. zeigerAufNeuenKnoten(name, symbol, ordnungszahl, NULL);
  60. /* nicht das 1. Element */
  61. else {
  62. zeiger=anfang;
  63. while((zeiger != NULL) && (strcmp(zeiger->name, name) < 0))
  64. zeiger=zeiger->next;
  65. /* Falls Zeiger auf NULL zeigt, Element hinten anhängen */
  66. if(zeiger==NULL)
  67. zeigerAufNeuenKnoten(name, symbol, ordnungszahl, NULL);
  68. /* Ist Element das kleinste, so an den Anfang setzen */
  69. else if(zeiger==anfang) {
  70. anfang=malloc(sizeof(struct Knoten));
  71. if(NULL == anfang) {
  72. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  73. exit(EXIT_FAILURE);
  74. }
  75. strcpy(anfang->name, strtok(name, "\n"));
  76. strcpy(anfang->symbol, strtok(symbol, "\n"));
  77. anfang->ordnungszahl = ordnungszahl;
  78. anfang->next = zeiger;
  79.  
  80. }
  81.  
  82. else {
  83. zeiger1=anfang;
  84. /* Wir suchen das Element, das vor dem
  85.   * Zeiger zeiger steht. */
  86. while(zeiger1->next != zeiger)
  87. zeiger1=zeiger1->next;
  88. zeiger=malloc(sizeof(struct Knoten));
  89. if(NULL == zeiger) {
  90. printf ("Programmabbruch, da Speicheranforderung fehlschlug!\n");
  91. exit(EXIT_FAILURE);
  92. }
  93. strcpy(zeiger->name,strtok(name, "\n"));
  94. strcpy(zeiger->symbol, strtok(symbol, "\n"));
  95. zeiger->ordnungszahl = ordnungszahl;
  96. /* Wir fügen das neue Element ein. */
  97. zeiger->next=zeiger1->next;
  98. zeiger1->next=zeiger;
  99. }
  100. }
  101. return l;
  102.  
  103. }
  104.  
  105. Liste loeschen( Liste l, int ordnungszahl ){
  106.  
  107. struct Knoten *zeiger, *zeiger1;
  108.  
  109. /* Ist überhaupt ein Element vorhanden? */
  110. if(anfang != NULL) {
  111. /* Ist unser 1. Element das von uns gesuchte ? */
  112. if(anfang->ordnungszahl == ordnungszahl) {
  113. zeiger=anfang->next;
  114. free(anfang);
  115. anfang=zeiger;
  116. }
  117. else {
  118. /* Es ist nicht das 1. Element zu löschen.
  119.   * Wir suchen in der weiteren Kette, ob das zu
  120.   * löschende Element vorhanden ist. */
  121. zeiger=anfang;
  122. while(zeiger->next != NULL) {
  123. zeiger1=zeiger->next;
  124. /* Ist die Adresse von zeiger1
  125.   * der gesuchte Name? */
  126. if(zeiger1->ordnungszahl == ordnungszahl) {
  127. /* Falls ja, dann ... */
  128. zeiger->next=zeiger1->next;
  129. free(zeiger1);
  130. break;
  131. }
  132. zeiger=zeiger1;
  133. } /* Ende while */
  134. } /* Ende else */
  135. } /* Ende if(anfang != NULL) */
  136. else
  137. printf("Es sind keine Daten zum Loeschen vorhanden!!!\n");
  138.  
  139. return l;
  140. }
  141.  
  142.  
  143. void ausgeben( Liste l ){
  144.  
  145. struct Knoten *zeiger = anfang;
  146.  
  147. while (zeiger != NULL){
  148. printf("%s, %s, %d\n", zeiger->name, zeiger->symbol, zeiger->ordnungszahl);
  149. zeiger = zeiger->next;
  150. }
  151. }
  152.  
  153. int main(void){
  154.  
  155. Liste l = NULL;
  156.  
  157. l = einfuegen( l, "Aluminium", "Al" , 13 );
  158. l = einfuegen( l, "Calium", "Ca" , 20 );
  159. l = einfuegen( l, "Chlor", "Cl" , 17 );
  160. l = einfuegen( l, "Fluor", "F" , 9 );
  161. l = einfuegen( l, "Magnesium", "Mg" , 12 );
  162.  
  163. ausgeben( l );
  164.  
  165. printf("\n");
  166.  
  167. l = loeschen( l, 17);
  168.  
  169. ausgeben( l );
  170.  
  171. return 0;
  172. }



  Profil  Quote  Link auf diesen Beitrag Link
DerEinfaeltige
Senior Letzter Besuch: in der letzten Woche
Dabei seit: 11.02.2015
Mitteilungen: 1485
Aus:
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.8, eingetragen 2018-01-20


Das Einfügen in die Mitte der Liste scheint buggy.
Da du aus irgendeinem Grund alphabetisch geordnet (nicht nach Ordnungszahl?!?) einfügst und auch so testest, wird dieser Fall von dir bisher nicht geprüft.
Das Löschen scheint korrekt zu funktionieren.

Da ich deine Implementierung etwas unübersichtlich finde, ist die Fehlersuche für mich leider nicht trivial.


-----------------
Why waste time learning when ignorance is instantaneous?
- Bill Watterson -



  Profil  Quote  Link auf diesen Beitrag Link
Specialagent
Aktiv Letzter Besuch: im letzten Monat
Dabei seit: 17.11.2012
Mitteilungen: 64
Aus:
Zum letzten BeitragZum nächsten BeitragZum vorigen BeitragZum erstem Beitrag  Beitrag No.9, vom Themenstarter, eingetragen 2018-01-20


Hallo,

das mit der Sortierung nach dem Alphabet hatte ich komplett übersehen, sorry. Sollte jetzt richtig sein.

Das Problem lag bei strtok(). Dies konnte ich jetzt einfach beheben und erhalte auch keinen Speicherzugriffsfehler. Danke dir für den Hinweis.

Soweit wäre meine Aufgabe gelöst. Danke Euch!



  Profil  Quote  Link auf diesen Beitrag Link
Specialagent hat die Antworten auf ihre/seine Frage gesehen.
Neues Thema [Neues Thema] Antworten [Antworten]    Druckversion [Druckversion]

 


Wechsel in ein anderes Forum:
 Suchen    
 
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters, all the rest © 2001-2018 by Matroids Matheplanet
This web site was made with PHP-Nuke, a web portal system written in PHP. PHP-Nuke is Free Software released under the GNU/GPL license.
Ich distanziere mich von rechtswidrigen oder anstößigen Inhalten, die sich trotz aufmerksamer Prüfung hinter hier verwendeten Links verbergen mögen.
Lesen Sie die Nutzungsbedingungen, die Distanzierung, die Datenschutzerklärung und das Impressum.
[Seitenanfang]