Moin,

ich möchte eine swap-Funktion, die 2 Felder eines Arrays austauscht machen,

meine Funktion:

void swap(int *a, int *

{       int tmp;

        tmp  =*a;

        *a =*b;

        *b =tmp;

        return;

}

...


int Nummer[100];[/code]


mit dieser möchte ich nun die Felder Nummer[0] und Nummer[1] tauschen

[CODE]swap(Nummer[0],Nummer[1]);

bekomme allerdings den Fehler: "warning: passing arg 1 of `swap' makes pointer from integer without a cast", dasselbe für argument 2.

Kann mir jemand sagen wie ich dieses Problem in den Griff bekomme?

Danke und Gruß

Metalmind

Deine Funktion erwartet Zeiger, du musst also die Adressen deiner Arrayelemente übergeben.

Vielen Dank, funktioniert!

so einfach kanns manchmal sein

Bei mir hat sich gerade ein Problem ergeben, das zum Thema passt, und zwar möchte ich nach diesem Schema eine swap-Funktion für zweidimensionale char Arrays erstellen. Mein Beispiel:

ich habe ein Array "char Bezeichnung[100][20];

und möchte in diesem Array nun Position Bezeichnung[0] und Bezeichnung[1] tauschen, der Kopf dafür sieht so aus:

void swap(int *array1, int *array2)    //tausche Array 1 und 2

Könnte mir an dieser Stelle bitte jemand beim basteln helfen, ich habe es nach dem Schema:

int *tmp;

strcpy(tmp,Bezeichnung[j]);

strcpy(Bezeichnung[j],Bezeichnung[i]);

strcpy(Bezeichnung[i],tmp);

versucht, allerding erhalte ich dabei massenweise Fehlermeldungen, weiß jemand wie ich diese Funktion zum laufen kriege?

Gruß

Metalmind

Warum int*? Was hast du dir dabei gedacht?

Sorry, war mehr oder weniger "Reflex", natürlich heißt es überall char*

diese Funktion versuche ich dann für das Array:

char Name[100][20];

laenge=10;

...

swap2(Name[0],Name[1]);


for (i=0;i<laenge;i++) 

	{

	printf("%s\n",Name[i]);

	}

mit dieser Funktion:

void swap2(char *array1, char *array2)    //tauscht Variable a und b       

{   

	char *tmp;

    strcpy(tmp,array1);

    strcpy(array1,array2);

    strcpy(array2,tmp);

    return;

}

zu verwenden

Bearbeitet 15. Juni 201015 j von Metalmind

char *tmp;

Das ist ein sogenannter uninitialisierter Zeiger.

Der zeigt (weil du bei der Definition nichts anderes angegeben hast) auf irgendeine Speicheradresse. Dass du dabei zufällig eine Adresse erwischst, an die du deine Texte kopieren kannst, ist unwahrscheinlich.

Du willst Arrays tauschen, also sollte deine Zwischenspeicher-Variable auch ein Array sein, natürlich in ausreichender Größe.

du solltest für tmp auch Speicherplatz reservieren wenn du da was reinkopieren willst...

Danke, aber wie würde dieses Array denn dann aussehen?

Wenn ich sage "char *tmp[100][20]" oder einfach nur [100] funktioniert das Compilieren in den Zeilen mit tmp aufgrund von inkompatiblen Zeigertypen nicht

Bearbeitet 15. Juni 201015 j von Metalmind

Der zeigt (weil du bei der Definition nichts anderes angegeben hast) auf irgendeine Speicheradresse.

Müsste das nicht eigendlich egal sein? In der Zeile darunter wird tmp ja mit dem ersten Array beschrieben.

Ich habe das jetzt mit

tmp = (char*) malloc(laenge*20*sizeof(char));

gelöst, danke für die Hilfe

Ich habe das jetzt mit

tmp = (char*) malloc(laenge*20*sizeof(char));

gelöst, danke für die Hilfe

Ich hoffe, du gibst den Speicher hinterher auch wieder frei, sonst hast du da ein Speicherleck.

Ich lese grad deinen letzten Satz, wann genau muss man den Speicher denn wieder frei geben, sobald man den Zeiger das letzte mal beschrieben hat, das letzte mal ausgegeben hat oder ganz am Ende des Programms?

Gruß

Metalmind

wann genau muss man den Speicher denn wieder frei geben

Man sollte den Speicher freigeben, wenn man ihn nicht mehr braucht. In deinem Fall wäre das vor der return-Anweisung in deiner Tausch-Funktion.

tmp = (char*) malloc(laenge*20*sizeof(char));

Ich hatte dich in deinem "malloc-Anomalie"-Thread schon darauf hingewiesen, dass du den Rückgabewert von malloc nicht casten sollst.

Warum überhaupt dynamische Speicherallokation?

Ganz so nebenbei versteh ich auch nicht, warum laenge * 20...

Bei char Name[100][20] hab ich 20 Zeichenketten á 99 (100 - ZKEKZ) Zeichen, da reicht doch statische Allokation mit statischer Größe (100) bzw. bzw. dynamischer Größe.

20 * laenge (unter der Annahme, dass laenge=10) wäre doch 200 und ist dann doppelt so groß wie ein einzelner string.

Speicherfresser olé. :floet:

So, ich habe jetzt char tmp[100]; daraus gemacht und es läuft besser als jemals zuvor, Danke für den Rat!

Da habe ich wohl etwas falsch verstanden, ich dachte ich hätte 100 Zeichenketten mit 20 Zeichen...