String before and after delimiter

Om du vet maxlängden på strängen kan du använda en stackallokerad buffer, men i grund och botten tror jag inte att det blir så mycket enklare än vad du gör.

Det är för övrigt missar som denna — null-terminerade strängar — i C som gör att Rust kan prestera bättre i flera situationer, om man inte typ skriver sin egen alternativa sträng-implementation och sånt bös.

Såg förresten en liten förbättring till din kod nu när jag kom hem till datorn. Du allokerar onödigt mycket minne för resultat-strängen i before_delimiter. Du kan söka upp delimitern först, räkna hur lång prefix-strängen är, och bara allokera och kopiera över så många tecken som behövs:

char* before_delimiter(const char* str, char del) {
    const char* p = strchr(str, del);
    const size_t i = (size_t)(p - str);
    char* new = malloc(i + 1);
    strncpy(new, str, i);
    new[i] = 0;
    return new;
}

Jag tycker Rust är ett väldigt trevligt språk. Det trevligaste jämfört med C tycker jag är det avancerade typsystemet med bl.a. generics/polymorfism. Speciellt polymorfism gör det så mycket enklare att återanvända datastrukturer för olika typer, istället för att ad-hoc behöva återuppfinna hjulet varje gång man vill, säg, lägga sin egna datatyp i ett hash-träd utan att behöva lägga allting bakom massa indirektion med void-pekare. C går nog alltid att göra snabbare än Rust om man är villig att lägga ned jobbet, men i min erfarenhet känns det som att man med Rust når 90% av prestandan av optimal C, med 30% av koden. Och detta är ju då jämfört med just optimal C, vilket man sällan orkar ta fram.

Tror tyvärr att det behövs mer kod än mindre kod. Felsituationer kan inträffa. Det kan t ex vara så att avgränsaren del inte finns i strängen str och då fås en NULL-pekare som man inte ska använda.

Ett gissel med dynamisk minnesallokering är att man kan få minnesläckage om man inte frigör det minne man allokerat. I mitt kodexempel med realloc() nedan blir det också ett minnesläckage eftersom det inte anropar free() men läckaget är begränsat till längden på den längsta strängen.

Båda funktionerna returnerar NULL om något gått fel.

/*****************************************************************/
char* after_delimiter(char *str, char del)
{
    char *after;

    if ((after = strchr(str, del)))
        ++after;
    return after;
}

//**********************************************************************
char* before_delimiter(char *str, char del)
{
    static char *before;
    char *tmp;

    if ((before = (char *) realloc(before, strlen(str)+1)))
    {
        strcpy(before, str);
        if ((tmp = strchr(before, del)))
            *tmp = '\0';
        else
            before = NULL;
    }
    return before;
}

realloc() förändrar storleken på det minne som redan allokerats. malloc() allokerar minne på nytt.

@Sweedland: Ja, om minnet inte allokerats innan så beter sig realloc() som malloc().