✔ [C] 2 Char Arrays nur mit Zeigern zu einem Char Array zusammenfassen

[kyanthos]

Hallo,
ich möchte wie im Titel geschrieben 2 Char Arrays nur mit Hilfe von Zeigern zu einem Char Array zusammenfassen. So etwas wie "std" darf nicht verwendet werden. Ich habe schon folgenden Ansatz geschrieben aber leider funktioniert es nicht. Könnt Ihr mir ein Tipp geben, was ich falsch gemacht hab oder vieleicht ein Quellcode?
Ich glaube das

gesamt[index]=*(zeiger1+i);

nicht stimmt, oder der Typ der Funktion nicht richtig ist. Ich weiß aber nicht, wie ich es ändern soll.

Quelltext:

#include <stdio.h>
#include <stdlib.h>

int charLaenge(char* b)
{
	char* a = b;
	while(*a!='\0')
		a++;
	return a-b;
}

char anhaengen(char zkette1[], char zkette2[])[]
{
	char *zeiger1 ;
	zeiger1= &zkette1[0];
	
	char *zeiger2 ;
	zeiger2= &zkette2[0];
	
	int laenge = charLaenge(zeiger1) + charLaenge(zeiger2);
	zeiger1= &zkette1[0];
	zeiger2= &zkette2[0];
	
	char gesamt[laenge];
	int index=0; 
	int i=0;
	while(*zeiger1!='\0')
	{
		gesamt[index]=*(zeiger1+i);
		index++;
		i++;
	}
	i=0;
	while(*zeiger2!='\0')
	{
		gesamt[index]=*(zeiger2+i);
		index++;
		i++;
	}
	
	return gesamt;
}

int main( )
{	
	char test1[] = "Hallo";
	char test2[] = "Welt";
	
	printf("\n%c",anhaengen(test1,test2));
	printf("%d",(charLaenge(test1)));
	return 0;
}

 

[sheel]

Hi und Willkommen bei tutorials.de

Du willst also nicht 2 Arrays von Index a bis Index b zusammenfügen, sondern zwei mit '\0' beendete Zeichenketten? Ohne fertige Funktionen zu verwenden?

Das hängt b an a an:

void my_strcat(char *a, char *b)
{
    while(*a) a++;
    while(*b) *(a++) = *(b++);
}

Wenn du das zusammengehängte nicht in der ersten, sondern einer anderen Zeichenkette speichern willst:
Das speichert b und c in a:

void my_strcpcat(char *a, char *b, char *c)
{
    while(*b) *(a++) = *(b++);
    while(*c) *(a++) = *(c++);
}

Wenn du Fragen hast, immer her damit

Gruß

PS: "Sowas" wie std nennt man Namespace.

 

[sheel]

Hab mir deine Funktion noch etwas genauer angeschaut...
Folgende Punkte fallen auf:

zkette1 und zkette2 überigbst du so:
char zkette1[]
Was dir aber nicht ganz klar zu sein scheint, das ist das Gleiche wie
char *zkette1
Dadurch macht es keinen Sinn, es erst wieder in zeiger1 zu speichern (um ein char* zu haben), weil es das sowieso schon ist.

&zkette1[0] ist übrigens auch das Gleiche wie zkette1 ohne & und [0], die heben sich gegenseitig auf.
*zkette1 wäre übrigens auch das Gleiche wie zkette[0], genauer gesagt ist
zkette[n] gleich *(zkette + n), wobei zkette als Adresse im Speicher, also Nummer, genommen wird.
Und *(zkette + 0) ist nunmal das Gleiche wie *zkette.

Mit dem Wissen kannst du auch deinen (sehr seltsamen) Funktionskopf verbessern:
char anhaengen(...)[]
Das [] am Schluss passt da nicht hin.
Warum jetzt nicht so?
char *anhaengen(...)

Und noch ein schwerer, prinzipieller Fehler:
In der Funktion machst du ein char-Array gesamt, in dem du das Ergebnis speicherst.
Soweit kein Problem.
Am Schluss gibst du aber gesamt mit return zurück.
Das Problem: Variablen, die du in einer Funktion anlegst, werden am Ende der Funktion wieder entfernt.
Das gesamt, das im main ankommt, ist nur noch eine Nummer, wo das char-Array im Speicher früher einmal war.
Das Array selber ist weg, auch der Inhalt ist entsprechend weg.

Leg besser ein weiteres char-Array im main an, das du auch an die Funktion übergibst, und speichere das Ergebnis dort.
Dieses Array wird dann erst am main-Ende entfernt, und da braucht es sowieso keiner mehr.

Gruß

 

[kyanthos]

Vielen dank für die schnellen Antworten. Danke für den Code und die Erklärung sheel. Jetzt hab ich die Zeiger ein bisschen besser verstanden. Ich wusste auch gar nicht, dass Variablen einer Funktion am Ende gelöscht werden bevor man diese zurückgibt. Danke auch für diesen wichtigen Tip.

Ich hab grad schnell mal deinen Code bei mir eingefügt. Ist der Aufruf so in der main richtig? Wenn ich es ausführe, dann gibt er nur t aus.

#include <stdio.h>
#include <stdlib.h>

int charLaenge(char* b)
{
	char* a = b;
	while(*a!='\0')
		a++;
	return a-b;
}

void anhaengen(char *a, char *b, char *c)
{
    while(*b) *a = *(b++);
    while(*c) *a = *(c++);
}

int main( )
{	
	char *eing1 = "Hallo";
	char *eing2 = "Welt";
	char *ausg;
	
	anhaengen(ausg,eing1,eing2);
	
	printf("\n%c",*ausg);
	
	return 0;
}

 

[sheel]

Noch zwei Hinweise zum Verständnis:

1) Eine Arrayvariable (wie char *xyz) speichert grundsätzlich nur die Adresse der Werte.
Also eine Nummer/ein int, wo im Speicher das erste Element (xyz[0]) ist.
Das nächste kommt dann ein Byte danach usw...alles in einer Reihe, ohne andere Sachen dazwischen.

Vielleicht macht für dich jetzt auch das *(xyz + n) von oben mehr Sinn.
Angenommen, ich will xyz[3] haben:
xyz hat die Adresse vom Element [0].
Mit *xyz, also *(xyz+0) könnte ich auf den Wert zugreifen
Da alle Elemente ohne Lücken hintereinander kommen, ist [3] eben 3 Byte weiter:
*(xyz+3)

Die Schrweibweise mit [..] ist letztendlich das Gleiche.

2)Beim "Löschen beim Zurückgeben" in der Funktion:
Es wird grundsätzlich immer eine Kopie des Wertes zurückgegeben.
Die existiert maximal solang, bis sie mit = in eine andere Variable gespeichert wurde.
Das Original ist derweil schon weg.

Bei Arrays wird aber nicht das ganze Array kopiert, sondern nur die Adresse.
Im main hast du dann also nur eine Info, wo das Array einmal angefangen hat.
Die Arrayelemente selber sind weg.

Deshalb besser im main anegen und übergeben.

Gruß

 

[kyanthos]

Man müsste also eine Schleife machen, um die die Werte, auf die der Zeiger zeigt auszugeben.

C - Code:

	while(*(ausg+i))
	{
		printf("\n%c",*(ausg+i));
		i++;
	}

 

[sheel]

Du kannst ruhig weiter ausg[i] schreiben, die andere Methode war nur zur Erklärung!
Was dir besser gefällt...

Und ja, so in einer Schleife wäre eine Möglichkeit.
Da es sowas aber schon fertig gibt:

puts(ausg);

oder

printf("%s",ausg);

oder auch

printf(ausg);

Erstes ist vorzuziehen.
Wenn %-Zeichen drin sind, macht printf nämlich Probleme, weil es dann ja sowas wie %c oder %s erwartet (und auch entsprechend weitere Variablen übergeben haben will)

Gruß

 

[kyanthos]

Ich hab es gerade mit puts() und meiner Schleife versucht aber ich bekomme immer nur t ausgegeben.

void anhaengen(char *a, char *b, char *c)
{
    while(*b) *a = *(b++);
    while(*c) *a = *(c++);
}

int main( )
{	
	char *eing1 = "Hallo";
	char *eing2 = "Welt";
	char *ausg;
	//int i=0;
	
	anhaengen(ausg,eing1,eing2);
	
	puts(ausg);
	
	return 0;
}

Oh. Ok hab mein Fehler gefunden. Da hab ich wohl nicht aufgepasst.

Hier der Code der Funktioniert

#include <stdio.h>
#include <stdlib.h>

void anhaengen(char *a, char *b, char *c)
{
    while(*b) {*a = *(b++);printf("%s",a);}
    while(*c) {*a = *(c++);printf("%s",a);}
}

int main( )
{	
	char *eing1 = "Hallo";
	char *eing2 = "Welt";
	char *ausg;
	int i=0;
	
	anhaengen(ausg,eing1,eing2);
	
	return 0;
}

Ich hab mich für die print variante entschieden, weil puts() jedes Zeichen in eine neue Zeile schreibt.

Nocheinmal vielen Dank für deine schnelle Hilfe.

 

[sheel]

Für ausg musst du eine Größe angeben.
char ausg[40];
zum Beispiel.
Der * ersetzt nur leere [].

Und zur Ausg-Funktion:
Da hab ich doch glatt was vergessen...
hab den Fehler oben (ganz oben in meinem ersten Beitrag hier) korrigiert.
Die ++ haben bei den *a gefehlt.

Gruß

 

[saftmeister]

Mit return aus der entsprechenden Funktion geht auch, wenn man die Ziel-Variable innerhalb der Funktion statisch deklariert:

#include <stdio.h>

#define MAX_CONCAT_LEN 100
 
/**
 * Concatenate two strings
 * @param str1 Pointer to the first string
 * @param str2 Pointer to the second string
 * @return The concatenated string
 */
const char *
concat_strings(const char *str1, const char *str2)
{
  // define a buffer
  static char result[MAX_CONCAT_LEN] = {0};
  // counter part
  int i = 0;
  
  // loop until end of string 1 has reached or destination buffer is full
  while(*str1 && i < MAX_CONCAT_LEN)
    result[i++] = *str1++;
  // loop until end of string 2 has reached or destination buffer is full
  while(*str2 && i < MAX_CONCAT_LEN)
    result[i++] = *str2++;

  // Null termination
  result[MAX_CONCAT_LEN-1] = 0;
 
  return result;
}
 
int main(int argc, char **argv)
{
  const char *a = "Hello ";
  const char *b = "World";
 
  const char *c = concat_strings(a, b);
 
  printf("%s\n", c);
 
  return 0;
}