n-Zeichen Präfix eines Strings

[CCCstringcast]

Könnt ihr mir nochmal helfen?

char *prefix(char *s, int n); n-Zeichen Präfix eines Strings.

Habe keine Ahnung wie ich das machen soll! vll ein paar tips oder hinweise?

wäre echt nett.

danke im voraus

[SeppJ]

Lies dir deinen Beitrag nochmal durch und denk darüber nach, wie viel davon jemand, der nicht du bist, verstehen kann.

[CJosef]

Meine magische Kristallkugel offenbart mir gerade, dass er einen String der Funktion prefix übergeben möchte,
die ihn um n Zeichen vorderseitig erweitert, damit der String einen Präfix erhalten kann.

[CJosef]

Keine Widerrede?
Okay!
Das zugehörige basic data format wäre dann:

#define PREFIX_MAX 8
#define STRLEN_MAX 56
char str[PREFIX_MAX+STRLEN_MAX];

[Bashar]

Meine Kristallkugel sagt dagegen, dass ein String aus den ersten n Zeichen des übergebenen Strings (das "n-Präfix") zurückgegeben werden soll.

[CCCstringcast]

die aufgabenstellung ist auch nur so bezeichnet, verstehe da selbst nicht so viel.
hatte gedacht vll kennen erfahrenere Programmierer als ich, sich besser mit der dem problem aus und wissen um was es sich handelt.

ich denke selbst, dass ein string angenommen "efghijk" ein n-langes präfix erhalten soll. Also "nnnnnnefghijk" oder sehe ich das falsch?

danke.

[CJosef]

Das Problem ist, wir kennen die Aufgabenstellung nicht.
Ohne weitere Beschreibung kannst du dir dann wohl selbst etwas ausdenken.
Frag deinen Tutor/Lehrer/Dozenten.

[SeppJ]

Die Aufgabe lautet doch nicht wortwörtlich

char *prefix(char *s, int n); n-Zeichen Präfix eines Strings.

oder?

Falls doch: Solch dumme Aufgaben würde ich verweigern.

[volkard]

Je nach Kontext könnte schon

char *prefix(char *s, int n)
{
   s[n]='\0';
   return s;
}

ausreichen. Oder was Schlimmeres. Soll s unverändert bleiben und Speicher angefordert werden? Könnte n größer sein als die Länge von s?

[CCCstringcast]

Ich habe hier einen ersten Versuch vorgenommen.

Ich möchte als Ausgabe folgendes haben: prefix: nnnhallo

Es gibt aber nichts aus.

Kann mir jemand helfen?

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

int prefix(char *s1, int n)
{
    int i,j;
    n=3;
    int k=strlen(s1);
    char *a=(malloc(k+n+1));

    for(i=0;i<=n;i++)
    {
        a[i]="n";
    }

    for(j=0;s1[j]!='\0';j++)
    {
        a[n]=s1[j];
        n++;
    }
    a[n]='\0';

    return (char)a;
}

int main()
{
    char s1[]="hallo";
    int n=3;
    printf("prefix: %s", prefix(s1,n));
    getchar();
    return 0;
}

Vielen Dank.

Grüße

[volkard]

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

char *prefix(char *s1, int n)//Rückgabetyp war falsch
{
    int i,j;
    int k=strlen(s1);
    char *a=malloc(k+n+1);

    for(i=0;i<n;i++)
    {
        a[i]='n';//hier hattest Du "n"
    }

    for(j=0;s1[j]!='\0';j++)
    {
        a[n]=s1[j];
        n++;
    }
    a[n]='\0';

    return a;//hier hattest Du geschummelt mit dem cast
}

int main()
{
    char s1[]="hallo";
    printf("prefix: %s", prefix(s1,3));
    getchar();
    return 0;
}

Bei dem Speicherloch bekommen viele Leute Bauchweh. Das solltest Du Dir gleich abgewöhnen.

int main()
{
    char s1[]="hallo";
    char *prefixedS1=prefix(s1,3);
    printf("prefix: %s", prefixedS1);
    free(prefixedS1);//Und nach Verwendung wieder löschen. 
    getchar();
    return 0;
}

[cprimer]

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

char* putfront_prefix(char* prefix, char* str)
{
	char* new = malloc(strlen(prefix)+strlen(str)+1);
	if(!new)
		return 0;
	sprintf(new,"%s%s",prefix,str);
	return new;
}

int main(void)
{
	char* str = "Buch.";
	char* prefix="Kauf dir ein Grundlagen-";
	char* new = putfront_prefix(prefix, str);
	if(new)
		puts(new);
	free(new);
	return 0;
}

[SeppJ]

volkard schrieb:

Bei dem Speicherloch bekommen viele Leute Bauchweh. Das solltest Du Dir gleich abgewöhnen.

int main()
{
    char s1[]="hallo";
    char *prefixedS1=prefix(s1,3);
    printf("prefix: %s", prefixedS1);
    free(prefixedS1);//Und nach Verwendung wieder löschen. 
    getchar();
    return 0;
}

Bei der Version bekomme ich auch Bauchschmerzen. Ein Implementierungsdetail der Funktion prefix (das malloc) wird nach außen getragen. Ändert sich dieses Detail, dann wird sämtlicher Anwendungscode ungültig.

Aufgrund der Aufgabenstellung ist das aber nur mit extrem "kreativer" Auslegung der Aufgabenstellung besser machbar. Daher: Ganz schlechte Aufgabenstellung. Fördert die Angewöhnung schlechter Programmier- und Denkmuster.

Besser wäre eine Version folgender Art (bei der ich die Aufgabenstellung bewusst ignoriere):

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

char *prefix(char* dest, const char* str, size_t how_many, char prefix)
{
    memset(dest, prefix, how_many);
    strcpy(dest+how_many, str);
    return dest;
}

int main()
{
    char foo[] = "Hallo Welt!";
    char bar[100];  // Nun darf der Anwender selber wissen, was am besten für ihn ist
    prefix(bar, foo, 42, '?');
    puts(foo);
    puts(bar);
    return 0;
}

[CCCstringcast]

Ok vielen vielen Dank. Es funktioniert nun.

Grüße

[volkard]

SeppJ schrieb:

Aufgrund der Aufgabenstellung ist das aber nur mit extrem "kreativer" Auslegung der Aufgabenstellung besser machbar. Daher: Ganz schlechte Aufgabenstellung. Fördert die Angewöhnung schlechter Programmier- und Denkmuster.

Jo, absolut.
Der, der den Speicher besorgt, der gibt ihn auch wieder frei. Bis auf so wenige Ausnahmen, daß wir erstmal behaupen könnten, es gäbe keine Ausnahme.
In diesem Fall würde ich ein open/close-Paar anbieten. Dann können sich Details später ändern, wie sie lustig sind. Halt in C OO programmieren.

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

char *createPrefixedString(char *s1, int n)
{//bewusst keine string-funktionen benutzt!
//es sollte bestimmt eine Übung über Schleifen sein. 
    int i,j;
    int k=strlen(s1);
    char *a=malloc(k+n+1);

    for(i=0;i<n;i++)
    {
        a[i]='n';
    }

    for(j=0;s1[j]!='\0';j++)
    {
        a[n]=s1[j];
        n++;
    }
    a[n]='\0';

    return a;
}

void destroyPrefixedString(char* toDestroy)
{
    free(toDestroy);
}

int main()
{
    char s1[]="hallo";
    char *prefixedS1=createPrefixedString(s1,3);
    printf("prefix: %s", prefixedS1);
    destroyPrefixedString(prefixedS1);
    getchar();
    return 0;
}