4. Stringcat selber Programmieren

Stringcat selber Programmieren

  • M
     

    #include <stdio.h>

int main(void)
{
	int zahl, *zeiger_zahl;
	zahl = 3;
	zeiger_zahl = &zahl;

	printf("Adresse von zeiger_zahl ist %u\n", &zeiger_zahl);
	printf("Inhalt von zeiger_zahl ist %u\n", zeiger_zahl);
	printf("Wert von *zeiger_zahl ist %u\n", *zeiger_zahl);

	return 0;
}

    So wenn wir schon bei Pointern sind, weshalb gibt der mir bei Adresse und Inhalt das gleiche aus? ist das richtig? ich mein dann wär der & Operator ja sinnlos wenns auch so geht oder?

    EDIT: Muss mich korrigieren, gibt nicht den selben wert aus aber einen sehr ähnlichen, demnach wird mit & die Adresse des Objekts auf den der Pointer zeigt ausgegeben und im zweiten printf die adresse des pointers selbst? oder?

    0
  • S

    mazeli schrieb:

    Muss mich korrigieren, gibt nicht den selben wert aus aber einen sehr ähnlichen, demnach wird mit & die Adresse des Objekts auf den der Pointer zeigt ausgegeben und im zweiten printf die adresse des pointers selbst? oder?

    umgekehrt.

    ein zeiger ist ein objekt. es hat einen bestimmten wert (naemlich die adresse auf den der zeiger zeigt).

    ein zeiger selber ist somit 4 bytes im speicher - diese 4 bytes beinhalten die adresse des pointee (das objekt auf das gezeigt wird).

    int i;
int* p=&i;

    wenn wir davon jetzt ausgehen:
    wir haben hier also 2 objekte.

    printf("%p", p);
//fuer adressen verwendet man %p als format specifier nicht %u

    das gibt das selbe aus wie

    printf("%p",&i);

    naemlich die adresse von dem objekt i.

    aber das 2. objekt das wir haben ist ja unser zeiger selber.
    die 4 bytes die mit der adresse von i belegt sind, muessen ja auch irgendwo im speicher stehen und haben somit selber eine adresse:

    printf("%p",&p);

    dies gibt etwas anderes aus als die 2 oberen codes...

    0
  • M

    na jetzt wird mir einiges klar 😃

    Ich danke dir,

    ps: das mit dem %u hab ich aus nem Beispiel welches ich durch google gefunden hab

    0
  • M
     

    #include <stdio.h>

int strlen(char *);
void strcat(char *, char *);

void strcat(char *str1, char *str2)
{
	int x;
	char *hStr;

	for(x = 0; x <= strlen(*str1); x++)
	{
		*hStr = *str1;
                *hStr++;
		*str1++;
	}
	for(x = 0; x <= strlen(*str2); x++)
	{
		*hStr = *str1;
                *hStr++;
		*str2++;

	}
	printf("\n *str1 = %p, *str2 = %p, *hStr = %p", *str1, *str2, *hStr);
}

int strlen(char *strptr)
{
	int z = 0;

	while(*strptr != '\0')
	{
		z++;
	}
	return z;
}

int main(void)
{
	char text1[50];
	char text2[50];
	//int x, y;

	printf("Bitte zwei Woerter eingeben: ");
	gets(text1);
	gets(text2);

	strcat(text1, text2);

	return 0;
}

    So habs nun nochmal neu versucht, natürlich funktioniert es nicht 😃 hoffe es ist wenigstens nicht totaler müll.

    Jetzt stellen sich mir einige Fragen,

    1. Kann ich mit gets() überhaupt ne Eingabe in das Array tätigen?
    2. Habe bei Strcat Fkt. als Übergabewerte ja char Pointer, die erwarten ja eine Adresse, wie kann ich das bei dem Array dann machen? Ein Array ist ja auch ein zeiger.
    3. Die strlen Funktion müsste eigentlich funktionieren.
    4. in der ersten for schleife zähle ich die beiden Zeiger hoch, bleibt die stelle dann bis zur zweiten schlefe gespeichert oder muss ich ihm erst sagen wo er dann weiter machen soll? also praktisch auf das ende des ersten strings ausrichten?

    Danke schonmal 😃

    0
  • H

    auweia...

    "char *str" ist ja ein zeiger (adresse) der auf eine ansammlung von chars zeigt.
    "*str" liefert dann den char der an dieser adresse im speicher steht.
    das gleiche waehre "str[0]".

    "strlen" erwartet einen zeiger. du uebergibst aber nur ein zeichen.
    selbst wenn das richtig waere, schiebst du diese adresse immer einen weiter (was du nicht tust, sondern nur ein zeichen) - der string wuerde damit ein zeichen kuerzer und ergibt keine sinnvolle abbruchbedingung fuer die schleife.
    innerhalb von "strlen" pruefst du mit *strptr immer nur das erste zeichen auf 0, hast also eine endlosschleife.

    du hast noch einiges zu tun 😉

    0
  • M

    hmm ich hab jetzt leider gar nix verstanden, sorry 😞 🙂

    0
  • H

    konkretes beispiel:

    so ist es:

    for(x = 0; x <= strlen(*str1); x++)
    {
        *hStr = *str1;
        *hStr++;
        *str1++;
    }

    so muss es:

    int l= strlen(str1);
    for(x = 0; x <= l; x++)
    {
        *hStr = *str1;
        hStr++;
        str1++;
    }
    0
  • M

    mhhh jo klingt logisch 😃

    0
  • F

    Wo genau meinst du denn, den neuen String hinzuschreiben? Bis jetzt schreibst du den irgendwo in Speicher, der dir nicht gehört, da du kein malloc benutzt.

    0
  • M

    Gute frage, ich raff des jetzt alles gar nimmer 😃

    0
  • ?
     

    Speicher am Anfang:

Stack:  Adr:0000| ffff | ffff |      |      |      |      |      |      |      |      |

Heap:   Adr:075f|      |      |      |      |      |      |      |      |      |      |

    1:

    char* txt;

    Speicher nach 1:

    txt
Stack:  Adr:0000| ffff | ffff |      |      |      |      |      |      |      |      |

Heap:   Adr:075f|      |      |      |      |      |      |      |      |      |      |

    2:

    txt = (char*)malloc(3);

    Speicher nach 2:

    txt
Stack:  Adr:0000| 075f | ffff |      |      |      |      |      |      |      |      |

Heap:   Adr:075f|      |      |      |      |      |      |      |      |      |      |

    3:

    txt[0] = 'a';
txt[1] = 'y';

    Speicher nach 3:

    txt
Stack:  Adr:0000| 075f | ffff |      |      |      |      |      |      |      |      |

Heap:   Adr:075f|  'a' |  'y' |      |      |      |      |      |      |      |      |
    0

  • Bildchen, ich weiß nicht, was du mit deinen "Ausführungen" bezwecken willst.

    Die ursprüngliche Aufgabenstellung bedeutete doch, strcat( ) aus <string.h> zu realisieren:

    #include <stdio.h>

size_t string_length( const char *src )
{
    size_t len = 0;

    while( *src ) {

        ++src;
        ++len;
    }

    return len;
}

char* string_copy( char *dest, const char *src )
{
    while( *src ) {

        *dest = *src;
        ++dest;
        ++src;
    }

    *dest = '\0';

    return dest;
}

char* string_cat( char *dest, const char *src )
{
    dest += string_length( dest );

    return string_copy( dest, src );
}

int main( )
{
    char test[ 80 ];

    string_copy( test, "Hello" );

    printf( "%s\n", test );
    printf( "len: %u\n\n", string_length( test ) );

    string_cat( test, ", World!");

    printf( "%s\n", test );
    printf( "length: %u\n\n", string_length( test ) );
}

    Greetz, Swordfish

    0
  • C
     

    size_t string_length(const char *src)
{
    char *p = src;
    while (*p) ++p;
    return (size_t)(p - src);
}

char *string_copy(char *dest, const char *src)
{
    char *p = dest;
    while (*p++ = *src++); // zu finden in K&R C, 1st/2nd edition; kopiert auch \0
    return dest;
}
    0
  • ?

    Swordfish schrieb:

    Bildchen, ich weiß nicht, was du mit deinen "Ausführungen" bezwecken willst.

    Zeigen, dass man nur durch das anlegen eines char pointers noch lange keinen Speicher hat in dem die Daten gespeichert werden können.

    0

  • Achso.

    Greetz, Swordfish

    0
  • M
     

    #include <stdio.h>

int string_laenge(char *);

char * string_cat(char *, char *);

char * string_cat(char *s1Ptr, char *s2Ptr)
{
	int lv, x, y;
	char hstring[20];

	x = string_laenge(s1Ptr);
	y = string_laenge(s2Ptr);

	for(lv = 0; lv <= x; lv++)
	{
		hstring[lv] = *s1Ptr;
		s1Ptr++;
	}
	for(lv = x; lv <= (y+x); lv++)
	{
		hstring[lv] = *s2Ptr;
		s2Ptr++;
	}

	//printf("\nDie beiden Strings zusammengefuegt ergeben: %s", hstring);

	return hstring;
}

int string_laenge(char *sPtr)
{
	int i = 0;

	while(*sPtr != '\0')
	{
		i++;
		sPtr++;
	}
	return i;
}

int main(void)
{
	int x, y;
	char str1[20+1];
	char str2[20+1];
	char *hPtr;

	printf("Bitte geben Sie den ersten String ein: ");
	gets(str1);
	printf("\nBitte geben Sie den zweiten String ein: ");
	gets(str2);

	printf("\nString1: %s, String2: %s", str1, str2);

	hPtr = string_cat(str1, str2);

	printf("\n Die beiden Strings nach zusammenfuegen: %s", *hPtr);

	return 0;
}

    So habs nun nochmal komplett neu versucht, hat alles funktioniert als ich den zusammen gefügten String in der String_cat Funktion ausgedruckt habe.

    In der Aufgabe hieß es jedoch das die Funktion einen Char Pointer zurückliefern soll. Jetzt hab ich ja gelernt 😃 das der Arrayname ein Pointer auf das erste Element des Arrays ist. Dann dachte ich mir halt machste am schluss "return hstring", aber dann geb ich ja den Inhalt des ersten Elements zurück? also den ersten buchstaben vom string oder? muss es dann "return &hstring" heißen?

    0

  • Ich glaub' du hasst nicht verstanden, was strcat() aus string.h des C-Standards macht.
    strcat( dest, src ) hängt src an dest an und gibt src zurück.

    Greetz, Swordfish

    PS: Siehe mein Post 6 Posts darüber.

    0
  • M

    ok hab sie nun umgeschrieben

    #include <stdio.h>

int string_laenge(char *);

char * string_cat(char *, char *);

char * string_cat(char *s1Ptr, char *s2Ptr)
{
	int lv, x, y;

	x = string_laenge(s1Ptr);
	y = string_laenge(s2Ptr);

	for(lv = 0; lv <= x; lv++)
	{
		s1Ptr++;
	}
	for(lv = x; lv <= (y+x); lv++)
	{
		*s1Ptr = *s2Ptr;
		s1Ptr++;
		s2Ptr++;
	}

	//printf("\nDie beiden Strings zusammengefuegt ergeben: %s", *s1Ptr);

	return s1Ptr;
}

int string_laenge(char *sPtr)
{
	int i = 0;

	while(*sPtr != '\0')
	{
		i++;
		sPtr++;
	}
	return i;
}

int main(void)
{
	int x, y;
	char str1[20+1];
	char str2[20+1];
	char *hPtr;

	printf("Bitte geben Sie den ersten String ein: ");
	gets(str1);
	printf("\nBitte geben Sie den zweiten String ein: ");
	gets(str2);

	printf("\nString1: %s, String2: %s", str1, str2);

	string_cat(str1, str2);

	printf("\nNeuer String1: %s", str1);

	return 0;
}

    Bringt mir jetzt zumindest keine fehlermeldungmehr, aber er kopiert den zweiten string nicht an den ersten sondern gibt mir nur den ersten aus ????

    0
  • S

    schau dir deine 2 vorschleifen mal an:

    for(lv = 0; lv <= x; lv++)

    wenn in s1 zH "Hi" steht, dann liefert strlen(s1) ja 2.

    aber wie oft wird diese schleife nun ausgefuehrt?

    weiters wuerde ich die arrays groesser machen - bedenke dass in str1 ja der komplette inhalt von str2 platz haben muss...

    0
  • M

    ja ok er führt die schleife einmal zuviel aus, aber müsste er nicht trotzdem was hinkopieren? oder eben nicht weil nach dem ersten string nichts mehr initialisiert ist?

    bei meinem Programm oben ist das char * string_cat doch total unnütz und auch der rückgabewert oder? ich mein ich arbeite da ja mit Pointern die den string im main verändern, für was ist dann der char * rückgabewert?

    0
Anmelden zum Antworten