Zweidimensionales char-Array an Funktion übergeben

skluge

Hallo zusammen,

ich bin seit langem wieder mal an einem C-Programm und scheitere gerade an einem zweidimensionalen Array. Und zwar hab ich in einer struktur folgendes Array definiert:

typedef struct ms
{
...
char MeineListe[4][256];
...
}MS;

MS  ms;         // Main-Struct

Dieses Array möchte ich in meinem Programm befüllen, jedoch wird es zuvor an eine Funktion übergeben, die diese Befüllung durchführen soll.

static int Function1()
{
memset(ms.MeineListe, 0x0, 4*256);

 //Funktionsaufruf, bei der das Array an die Funktion "Function2" übergeben werden sollte
 ret = Function2((char**)ms.MeineListe);

}

Die andere Funktion sieht wie folgt aus:

int Function2(char **ms_meineListe)
{
   int FieldIndex = 2*256;
   strcpy(*ms_meineListe+FieldIndex, "Test");
}

Sobald das Programm in die Funktion "Function2" springt und die Zuweisung mittels "strcpy" durchführen möchte, knallt es mit einer Speicherverletzung.

Generell bin ich mir nicht ganz im Klaren, wie man am Besten ein mehrdimentionales Array an eine Funktion übergeben sollte?! Falls mein Lösungsansatz nicht gänzlich verkehrt ist, wie sieht die Verbesserung dafür aus?

Andererseits wäre interessant zu wissen, ob es eine Lösung gibt, bei der man in der Funktion "Function2" mittels den []-Klammern das Array ansprechen kann?!

Also in der Art:

strcpy(ms_meineListe[0], "Test");

Könnt ihr mir bei diesem Problem weiterhelfen?

Vielen Dank an eure Tipps!
Gruß

Wutz

1. du kannst die gesamte struct-Variable bis an die untere Funktion übergeben

int Function2(MS *ms)
{
   ...
   strcpy(ms->meineListe[0], "Test1");
   strcpy(ms->meineListe[1], "Test2");
   strcpy(ms->meineListe[2], "Test3");
   strcpy(ms->meineListe[3], "Test4");
   ...
}

oder
2. du übergibst das char-Array Array direkt

int Function2(char ms[4][256])
{
   ...
   strcpy(ms[0], "Test1");
   strcpy(ms[1], "Test2");
   strcpy(ms[2], "Test3");
   strcpy(ms[3], "Test4");
   ...
}

Ein 2D-Array ergibt keinen Doppelzeiger.

Du kannst das Array komplett angeben

int Function2(char ms_meineListe[4][256])
{
   strcpy(ms_meineListe[2], "Test");
}

Den ersten Index kannst du auch leer lassen

int Function2(char ms_meineListe[][256])
{
   strcpy(ms_meineListe[2], "Test");
}

Oder möchtest du das flexibler haben?

int Function2(char *ms_meineListe, size_t breite, size_t zeile)
{
   strcpy(ms_meineListe + zeile * breite, "Test");
}

....
ret = Function2((char *)ms.MeineListe, 256, 2);

dachschaden

Die Problembeschreibung kannst du auf folgendes Programm beschränken, welches sich auch ohne Probleme kompilieren lässt:

#include <string.h>
#include <stdio.h>

int Function2(char **ms_meineListe)
{
   int FieldIndex = 2*256;
   strcpy(*ms_meineListe+FieldIndex, "Test");
}

int main(void)
{
    char MeineListe[4][256];
    Function2(MeineListe);
    printf("%s\n",MeineListe[2]);

    return 0;
}

Und da würde ich empfehlen, dass du auf ein eindimensionales Array umsteigst. Implementieren würde ich das so:

#include <string.h>
#include <stdio.h>

#define UNITS (4)
#define UNIT_SIZE (256)
#define UNIT_2_INDEX(x) ((x)*UNIT_SIZE)

void Function(char*ms_meineListe,size_t index)
{
    strcpy(&ms_meineListe[UNIT_2_INDEX(index)], "Test");
}

int main(void)
{
    char MeineListe[UNIT_2_INDEX(UNITS)];
    Function(MeineListe,2);
    printf("%s\n",&MeineListe[UNIT_2_INDEX(2)]);

    return 0;
}

Weil eindimensionale Arrays sich leichter verwalten lassen und du trotzdem mit dem Präprozessor eine ordentliche Indexberechnung machen kannst. Nur einmal mache ich * 256 , und das im Makro. Keine Typumwandlung, keine Größenangabe in der Parameterliste, und der Code ist auch einigermaßen leserlich.