2-D array an eine Funkion übergeben...

lippoliv

hey mcr,
danke für deine Antwort,

aber eine frage, ist das dann call-by-value oder call-by-reference, denn ich will unbedingt, dass er die änderungen übernimmt, und nicht einfach kopiert, und die änderungen nur in der funktion hat...

mcr

lippoliv schrieb:

hey mcr,
danke für deine Antwort,

aber eine frage, ist das dann call-by-value oder call-by-reference, denn ich will unbedingt, dass er die änderungen übernimmt, und nicht einfach kopiert, und die änderungen nur in der funktion hat...

C kann in Wirklichkeit nur call-by-value. Hier ein Beispiel:

void func1(int b);
void func2(int *c);

Bei func1() wird ein Argument übergeben, welches vom Typ int ist.

void func1(int b) {
    b = 5;
}

Diese Zuweisung ist lediglich in der Funktion func1() gültig. Sobald
die Funktion verlassen wird, geht die Zuweisung verloren.

Bei func2() wird auch nur ein Argument übergeben. Diesmal ist
aber der Typ int*. Das bedeutet: Es wird ein Pointer auf ein Integer
übergeben. Auch hier wird das Argument nach c kopiert.

void func2(int *c) {
    *c = 5;
}

Was macht nun diese Zuweisung *c = 5?
Durch das Dereferenzieren von c wird nun 5 in die Speicherzelle geschrieben,
auf die c zeigt. Damit ist die 5 auch außerhalb von func2() verfügbar.

void func2(int *c) {
    c = malloc(4);
    *c = 5;
}

Nun wird innerhalb der Funktion func2() c ein neuer Speicherbereich und diesem
dann der Inhalt 5 zugewiesen. Da der Pointer c bei der Übergabe kopiert wird,
geht die Zuweisung *c = 5 nach Beenden der Funktion func2() verloren.

Ich hoffe, dies hilft dir.

Gruß mcr

lippoliv

ja dann ist dem wohl so,

ist aber schneller, als den gesamten berecih in einen neuen Speicher zu übertragen...

Was ist dein lösungsweg nun, bleiben die änderungen erhalten?

mcr

lippoliv schrieb:

ja dann ist dem wohl so,

ist aber schneller, als den gesamten berecih in einen neuen Speicher zu übertragen...

Was ist dein lösungsweg nun, bleiben die änderungen erhalten?

Bei der Lösung

void getNames( char theNames[][33] )

wird nicht der gesamte Bereich kopiert, sondern lediglich die Adresse.
Die Angaben [][33] sagen dem Kompiler, um was für ein Object es sich handelt.
Ohne diese wüßte er nicht, wo er das Zeichen theNames[2][5] finden kann.

Gruß mcr

lippoliv

Danke, das ist hilfreich...

könnte man argv[x][55] ansprechen? Wenn ja wie machen die das, denn ich trage ja lediglich "int main( int argc, char **argv )" ein... Da geht das dann auch nicht ne?

Das bedeutet, wenn ich einen temporären array hätte und den zeichen für zeichen befülle könnte ich dann "strcpy( names[i], tmpArr );" ausführen ?!

Ich hoffe ihr versteht was ich meine?!

mcr

lippoliv schrieb:

Danke, das ist hilfreich...

könnte man argv[x][55] ansprechen? Wenn ja wie machen die das, denn ich trage ja lediglich "int main( int argc, char **argv )" ein... Da geht das dann auch nicht ne?

Hier sieht es anders aus.

Am besten du stellst dir das wie folgt vor. Ein kleines Beispiel:

char ** array = malloc(10*sizeof(char*));
   int i;
   for (i=0; i<10; ++i) array[i] = malloc(23*sizeof(char));

array ist nun ein Pointer auf Pointern von Typ char*. Auch damit ist eine Art
zweidimensionales Array definiert mit hier 10 Zeilen und 23 Spalten.

Kleiner Hinweis: hier muss nicht jede Zeile 23 Zeichen lang sein. Man kann
                 auch unterschiedlich viel Speicher allozieren

Es gibt ein paar Unterschiede zu char array[10][23]:

- Die Zeilen müssen nicht hintereinander im Speicher liegen.
  - Es wird mehr Speicher benötigt und zwar zum Speichern der 10 Pointern.
  - Die Übergabe an Funktionen sieht ein wenig anderns aus: hier muss char **
    anstelle von char [][23] genommen werden.
  - ...

Das sind die wichtigsten Unterschiede.

Das bedeutet, wenn ich einen temporären array hätte und den zeichen für zeichen befülle könnte ich dann "strcpy( names[i], tmpArr );" ausführen ?!

Ich hoffe ihr versteht was ich meine?!

Nein, ich habe das nicht so ganz verstanden.

Gruß mcr

lippoliv

momentan (oder zum zeitpunkt des eröffnen dieses Threads) habe ich sowas gemacht

name[i][x] = msg[x];

das ging nicht. aber ich hätte sowas machen können oder?:

strcpy( name[i], msg );

mcr

Ich weiß immer noch nicht genau, was du willst.

Vielleicht mal hier etwas zur Klärung:

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

char names[255][33];

int main() {
    char msg[] = "Hallo Test";
    unsigned int i;

    printf("Mes: %d <%s>\n", strlen(msg), msg);

    strcpy(names[0], msg);
    strncpy(names[1], msg, 33);

    for (i=0; i<strlen(msg); ++i) names[2][i] = msg[i];

    for (i=0; i<3; ++i)
        printf("Names: %d:  len: %d   <%s>\n", i, strlen(names[i]), names[i]);

    return 0;
}

In diesem Beispiel hast du mal drei verschiedene Varianten, wie man mit
String in deinem Fall arbeiten kann.

Ich hoffe mal, deine Frage ist beantwortet.

Gruß mcr

PS: wenn das nicht weiterhilft, dann schreib bitte ein wenig ausführlicher,
was du für Variablendefinitionen hast.

lippoliv

Naja so habe ich es jetzt auch gemacht... global...

Das meinte ich aber gar nicht..

Ich habe einen LOKALEN(FUCK vergessen zu schreiben sry) array. Da war mein knackpunkt. Inzwischen ist er auch global, aber ich wollte wissen ob es auch mit einem lokalen geht. also

int main()
{
    char myArr[256][33];

    fillMyArr( myArr );

    return 0;
}

void fillMyArr( char **arr )
{
    arr[2][1] = 'a';
}

geht das so?

wohl eher so ne?

void fillMyArr( char arr[][33] )
{
    arr[2][1] = 'a';
}

mcr

Die zweite Variante ist korrekt.
Die erste ist falsch.

Gruß mcr

lippoliv

ok danke.