struct-frage

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

  • struct-frage

    hi leute,

    Meine struct:
    Struktur ArrayInt beinhaltet einmal die Größe eines dynamischen Arrays und den Zeiger auf das dynamische Array. Mit den Funktionen soll die Struktur bearbeitet werden.
    Mein Problem:
    Wenn ich den Speicher mit CreateArray() alloziiere wird die Variable size der Struktur ArrayInt richtig belegt. (Ausgabe: "Größe: 5")
    Wenn ich den alloziierten Speicher mit SetValue() belege, wird die Variable size leider überschrieben und enthält dann den Wert des dritten Elements.
    Kann sich jemand denken warum:

    Mein code:

    Quellcode

    1. /* Includefiles */
    2. #include <stdio.h> /*printf, getchar*/
    3. #include <stdlib.h> /*malloc, realloc*/
    5. /* Declarations of Structures */
    6. struct ArrayInt
    7. {
    8. int size;
    9. int *element;
    10. };
    12. /* Declarations of Functions */
    13. struct ArrayInt *CreateArray(int numberElements);
    14. void DeleteArray(struct ArrayInt *ptr_Array_Int);
    15. int GetValue(struct ArrayInt *ptr_Array_Int, int aElement);
    16. int GetSize(struct ArrayInt *ptr_Array_Int);
    17. void SetValue(struct ArrayInt *ptr_Array_Int, int aElement, int aValue);
    18. void errorOutOfMemory();
    19. void errorWrongNumberOfElements();
    21. /* Main-Function */
    22. int main(int argc, char *argv[])
    23. {
    24. struct ArrayInt *testArray;
    26. testArray = CreateArray(5);
    27. printf("Größe: %d\n", GetSize(testArray));
    28. SetValue(testArray, 0, 22);
    29. SetValue(testArray, 1, 33);
    30. SetValue(testArray, 2, 44);
    31. SetValue(testArray, 3, 55);
    32. SetValue(testArray, 4, 66);
    33. printf("Ausgabe: %d\n", GetValue(testArray, 0));
    34. printf("Ausgabe: %d\n", GetValue(testArray, 1));
    35. printf("Ausgabe: %d\n", GetValue(testArray, 2));
    36. printf("Ausgabe: %d\n", GetValue(testArray, 3));
    37. printf("Ausgabe: %d\n", GetValue(testArray, 4));
    38. printf("Größe: %d\n", GetSize(testArray));
    39. }
    42. /********************************************
    43. CreateArray
    44. ********************************************/
    45. struct ArrayInt *CreateArray(int numberElements)
    46. {
    47. struct ArrayInt *ptr_Array_Int;
    48. if(numberElements <= 0) errorWrongNumberOfElements();
    49. ptr_Array_Int = malloc(sizeof(struct ArrayInt));
    50. if(!ptr_Array_Int) errorOutOfMemory();
    51. ptr_Array_Int->element = malloc(numberElements * sizeof(int));
    52. ptr_Array_Int->size = numberElements;
    53. return(ptr_Array_Int);
    54. }
    56. /********************************************
    57. GetSize
    58. ********************************************/
    59. int GetSize(struct ArrayInt *ptr_Array_Int)
    60. {
    61. return( ptr_Array_Int->size );
    62. }
    65. /********************************************
    66. SetValue
    67. ********************************************/
    68. void SetValue(struct ArrayInt *ptr_Array_Int, int aElement, int aValue)
    69. {
    70. int *ptrTMP;
    71. if(aElement >= ptr_Array_Int->size) return;
    72. //ptrTMP = ptr_Array_Int->element + (aElement * sizeof(int));
    73. //+*ptrTMP = aValue;
    74. *(ptr_Array_Int->element + (aElement * sizeof(int))) = aValue;
    75. //+*ptr_Array_Int->element = aValue;
    76. }
    78. /********************************************
    79. GetValue
    80. ********************************************/
    81. int GetValue(struct ArrayInt *ptr_Array_Int, int aElement)
    82. {
    83. return( *(ptr_Array_Int->element + (aElement * sizeof(int))) );
    84. }
    86. /********************************************
    87. DeleteArray
    88. ********************************************/
    89. void DeleteArray(struct ArrayInt *ptr_Array_Int)
    90. {
    91. if(!ptr_Array_Int) return;
    92. if(ptr_Array_Int->element) free(ptr_Array_Int->element);
    93. }
    95. void errorOutOfMemory()
    96. {
    97. printf("Fatal Error! Out Of Memory.\n");
    98. exit(-1);
    99. }
    101. void errorWrongNumberOfElements()
    102. {
    103. printf("Error! Wrong Parameter: Number Of Elements.\n");
    104. exit(-1);
    105. }
    Alles anzeigen


    Es wäre supertoll, wenn mir jemand einen Hinweis geben könnte.
    Viele Grüße
    Chris

  • Quellcode

    1. void SetValue(struct ArrayInt *ptr_Array_Int, int aElement, int aValue)
    2. {
    3. int *ptrTMP;
    4. if(aElement >= ptr_Array_Int->size) return;
    5. ptr_Array_Int->element[aElement] = aValue;
    6. }
    8. /********************************************
    9. GetValue
    10. ********************************************/
    11. int GetValue(struct ArrayInt *ptr_Array_Int, int aElement)
    12. {
    13. return ptr_Array_Int->element[aElement];
    14. }
    Alles anzeigen


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

  • hi phax & void,

    danke für euren hinweis. hatte fälschlicherweise gedacht, das ich zum zeiger int (für 32-bitter eben 4-byte) addieren muß, um auf das nächste element zu zeigen. und um das hardwareunabhängig zu machen, habe ich eben sizeof(int) addiert.
    o.k. denkfehler.
    is machmal simpler, als man denkt...

    so gehts auch (um zeigersyntax weiter zu nutzen):

    Quellcode

    1. void SetValue(struct ArrayInt *ptr_Array_Int, int aElement, int aValue)
    2. {
    3. ptr_Array_Int->element + aElement = aValue;
    4. }


    gruss
    chris