Anhänger von Zeichenketten in Zeichenketten

JeromeC

Hallo,

ich versuche mittels strcat eine linear wachsenden Index einer Zeichenkette mit einem zufäligen char-Element einer anderen Zeichenkette zu füllen.
Dabei ist die Zeichenkette, aus der das Element genommen wird, bereits mit char-Werten gefüllt.

Mein Code dazu:

strcat(zk2[klaenge], char *zk1[rn2]);

klaenge wird - wie gesagt - von 0 bis k inkrementiert und jeder k-te Array-Platz soll beliebig oft mit char-Elementen von der 1. Zeichenkette gefüllt werden.

Beim compeliren bekomme ich folgende Fehlermeldung:

syntax error before "char"

Kann mir jemand sagen, was ich vergesse?

Grüße, Jerome!

Wenn du in einen String ein Zeichen aus einem anderen String schreiben willst, mach's einfach so:

zk2[klaenge] = zk1[rn2];

Wenn ich dich falsch verstanden hab, erklär's bitte genauer.

JeromeC

Du hast recht, klingt logisch.
Aber ich möchte immer ein char-Zeichen anhängen, daher wählte ich "strcat".. ich glaube so würde er immer nur ein Element im dieser Array-Pos. inne haben.

Entschuldige, dass ich mich so unpräzise formuliere.
Die Frage ist, wie ich mehrere char-Elemente in eine Array-Pos stecke (von einem Array in das andere).

Wenn du in beiden Strings weder am Anfang, noch am Ende bist, ist wohl memcpy oder eine kleine Schleife das einfachste. strcat() sucht das Nullbyte am Ende des Ziel-Strings und hängt dort den Quell-String an, bis zu dessen Nullbyte.

ZB so:

char ziel[] = "Ich habe genug platz, das ist das wichtigste.";
char quelle[] = "bin nicht sicher";

memcpy(ziel + 4, quelle, 16);
puts(ziel);

JeromeC

Hey, danke für den wertvollen Tipp mit memcpy!
Die Funktion ist sehr gut nachvollziehbar.

Habe dass jetzt auf meine Bedürfnisse modifiziert:

memcpy((char*)zk2[klaenge]+ii, (char*)zk1+rn2, 1);

"ii" ist dabei eine Konstante, die hochzählt, und rn2 eine Zufallszahl, beide vom Typ Int.

Das (char*) habe ich eingefügt, da ich die 2 Zeichenketten dynamisch mit

int * zk1 = NULL;

und

zk1 = malloc(sizeof(int) * n);

erzeuge (dass selbe nochmal für zk2) und der Compiler sonst meckert, dass ich keinen typecaste vor zk1&zk2 mache, wenn ich (char*) weglasse.

Jetzt läuft das Programm bis zu dem Punkt, an dem ich zk2[2] fülle. zk2[0] und zk2[1] nimmt er noch, dann kracht's.

Kann mir vielleicht jemand sagen, in welche Richtung ich den Fehler suchen sollte?
Ich habe gerade den Überblick leicht verloren.

Besten Dank auch an dich µngbd,

Jerome.

Was für ein Typ ist zk2?
Je nachdem, könnte es dann heißen:
memcpy( **&**zk2[klaenge]+ii, zk1+rn2, 1);

Andererseits frage ich mich, warum du als erstes Argument einen char* und als zweites einen int* nimmst und den int* nach char* castest? Das Wirrwarr lässt sich bestimmt auflösen.
Wenn rn2 eine Zufallszahl ist, mußt du auch sicherstellen, dass zk1+rn2 eine gültige Zeigeradresse ergibt (allokierter RAM bzw. eine Array Speicherstelle). Das gleiche gilt natürlich ach für zk2[klaenge]+ii, bzw.
&zk2[klaenge]+ii.

JeromeC

ich probiere es mal

JeromeC

Kann mir jemand eine Frage beanworten?

Wenn ich versuche mehrere Zeichenkette in Zeichekette versuche abzuspeichern, wie realisiere ich dass am besten?

Es sind beliebig viele verschiedene Zeichenkette(ich nenne Sie mal 'B') in einer Zeichenkette('A') abzuspeichern.
Wenn ich nun in A Zeiger auf jedes B erzeuge, muss ich B-viele Zeichenketten erstellen, dass scheint mir eine schlechte Lösung, oder?
Gibt es eine Möglichkeiten Zeichenketten direkt in einer Zeichenketten-Pos. abzuspeichern?

Danke, Jerome.

JeromeC

Vergesst alles, Problem gelöst, die Anwort Big Brother funktioniert einwandfrei!

Ich werde mich jetzt nochmal hinsetzen und ausklamüsern, was ein Pointer, ein Array, etc. ist.

Vielen dank!

Big - Brother schrieb:

&zk2[klaenge]+ii

Mit einer Mischung aus Geschmack und Verstand würde man vermutlich lieber lesen:

zk2 + klaenge + ii
// oder
&zk2[klaenge + ii]

Wirklich, sehr geschmackvoll. Bin echt beeindruckt, Bruder!

µngbd schrieb:

Wirklich, sehr geschmackvoll. Bin echt beeindruckt, Bruder!

Hätte ich freundlicher formuliert, wenn ich dich nicht wegen dem Bindestrich für irgendeinen anonymen Nachmacher gehalten hätte. Seit fricky gegangen ist, müssen wir zusammenhalten, sonst wird uns bald der Spass vergehen.

Ich schätze, früher oder später kommt er wieder, nach dem Motto "Der Kater lässt das Mausen nicht".
Und wenns dazu ein paar Monate braucht. Wäre ansonsten IMO schon irgendwie doof.

Big Brother schrieb:

Ich schätze, früher oder später kommt er wieder, nach dem Motto "Der Kater lässt das Mausen nicht".
Und wenns dazu ein paar Monate braucht. Wäre ansonsten IMO schon irgendwie doof.

Ich wäre gern so sicher wie du. Man weiss ja nie, vielleicht hat zu viel Zeit im Internet durchgebracht, und macht jetzt lieber nur mehr das, wovon er was lernt.

Falls er nicht wieder kommt, musst leider du noch besser auf meine Fehler achten.

µngbd schrieb:

Ich wäre gern so sicher wie du. Man weiss ja nie, vielleicht hat zu viel Zeit im Internet durchgebracht, und macht jetzt lieber nur mehr das, wovon er was lernt.

Werden wir sehen

µngbd schrieb:

Falls er nicht wieder kommt, musst leider du noch besser auf meine Fehler achten.

Achwas, das machst du schon.

JeromeC

ich weiß nicht genau worüber ihr redet, scheint aber Insider-Wissen zu benötigen

falls ihr nochmal eine kurze frage beanworten könntet:

zk2 = malloc(k * sizeof(int *));

erzeuge ich eine ZK der Länge k..
mit

zk2[b] = malloc(rn1 * sizeof(int));

die Spalten der Länge rn1.
Nun ist rn1 immer unterschiedlich, wenn ich mir mittels

printf("%d", sizeof(zk2[b]));

die Länge der Spalte ausgeben lasse, ist jede Spalte immer 4 Lang.
Wieso ist das so?
Die Länge von zk2 ist auch nicht 4, sonder k, wie es auch sein sollte.

Kann mir jemand den Fehler nennen?

Danke euch nochmals,

Jerome.

JeromeC schrieb:

falls ihr nochmal eine kurze frage beanworten könntet:
zk2 = malloc(k * sizeof(int *));
erzeuge ich eine ZK

Besser: ein Array. Und am besten: einen Speicherbereich mit bekannter Grösse, der über einen Zeiger ansprechbar ist. Ein Zeiger ist nämlich kein Array. Man nennt so ein Ding von malloc() nur manchmal, etwas ungenau, "dynamisches Array". Aus Sicht der Sprache ist er aber keines, obwohl man ihn ausserhalb von sizeof so verwenden kann. Das liegt daran, dass C unter der Haube Zeiger verwendet, um Arrays zu handhaben.

JeromeC schrieb:

der Länge k..

mit
zk2[b] = malloc(rn1 * sizeof(int));
die Spalten der Länge rn1.
Nun ist rn1 immer unterschiedlich, wenn ich mir mittels
printf("%d", sizeof(zk2[b]));
die Länge der Spalte ausgeben lasse, ist jede Spalte immer 4 Lang.
Wieso ist das so?

Das eine übliche Grösse für ein int* , und jedes Element von zk2 ist ein int* . Könnte also durchaus stimmen.

JeromeC schrieb:

Die Länge von zk2 ist auch nicht 4, sonder k, wie es auch sein sollte.

Aber sizeof(zk2) ist doch auch 4, oder? Das muss die Grösse eines int** sein. zk2 ist als int** deklariert, oder?