Labor, 9. hét: dinamikus tömbök II.

Figyeld meg jól a feladatkiírás str = masolat("alma") kifejezését! Ebben a függvényhívás után egy értékadás történik: az str = ... kifejezésrészlet egy pointert tárol el. Ez az a pointer, amelyik a függvény által lefoglalt területre mutat. Fontos, hogy itt nem sztring értékadás történik, azaz nem tömbök közötti értékadás; egyszerűen csak egy pointert ráállítunk a létrejött tömbre.

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

/* Dinamikusan foglalt területre másolja a paraméterként kapott
 * sztringet. A másolat címével tér vissza. A kapott területet
 * a hívónak fel kell szabadítania a free() függvénnyel. */
char *masolat(char const *str) {
    /* milyen hosszú a sztring? */
    int hossz = strlen(str);
    
    /* dinamikus tömb foglalása, +1 a lezáró nullának */
    char *uj = (char*) malloc((hossz + 1) * sizeof(char));
    if (uj == NULL)
        return NULL;    /* :( */
    
    /* sztring másolása, biztosan elfér a tömbbe */
    strcpy(uj, str);
    return uj;
}


int main(void) {
    char *x = masolat("hello, dinamikus vilag!");
    if (x != NULL) {
        printf("%s\n", x);
        free(x);
    }
    return 0;
}

Vajon miért kell a függvénynek visszatérnie a dinamikusan foglalt terület címével? Azért, mert az átméretezés során megváltozhat a memóriaterület helye a memóriában. Lehet, hogy az eredeti helyen nem fér el a nagyobb tömb, és új jön létre, nagyobb mérettel. Az eredeti tömb pedig eltűnik, felszabadítja azt a függvény! Az előadáson már találkoztál ezzel a realloc() függvény kapcsán.

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

/* az előző feladatból */
char *masolat(char const *str) {
    char *uj = (char*) malloc((strlen(str) + 1) * sizeof(char));
    strcpy(uj, str);
    return uj;
}


/*
 * Hozzáfűzi a 'mihez' pointer által mutatott
 * dinamikusan foglalt sztringhez a 'mit' sztringet.
 * Visszatér a dinamikusan foglalt terület címével,
 * ami megváltozhatott, ezért a hívó be kell másolja
 * azt az eredeti változóba: x = hozzafuz(x, ...).
 * A hívó feladata a free()-t hívni a kapott tömbre.
 */
char *hozzafuz(char *mihez, char const *mit) {
    int ujhossz = strlen(mihez) + strlen(mit);
    
    char *uj = (char*) malloc((ujhossz + 1) * sizeof(char));
    if (uj == NULL) return NULL;
    
    strcpy(uj, mihez);
    strcat(uj, mit);
    
    free(mihez);
    return uj;
}

int main(void) {
    char *x;
    x = masolat("korte");
    x = hozzafuz(x, "fa");
    if (x != NULL) {
        printf("%s\n", x);    // kortefa
        free(x);
    }
    return 0;
}

Az alábbi megoldás a memcpy() függvényt használja az egyszerűség kedvéért. Ez tetszőleges adatot másol, memcpy(hova, honnan, hány bájtot). Azért volt rá szükség, mert a kivágandó sztringrészlet végén nincs lezáró nulla, tehát a strcpy nem lett volna alkalmas erre a feladatra. Ezért kell a lezáró nullát is az új sztringbe külön betenni.

Ciklussal elvégezve a másolást, ugyanolyan jó megoldáshoz lehet jutni.

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

/*
 * Előállít egy új sztringet, amely az 'eredeti' nevű sztring
 * közepéből van kivágva, [mettol, meddig) balról zárt, jobbról
 * nyílt intervallumban. A hívó a free() függvénnyel fel kell
 * szabadítsa a kapott tömböt.
 */
char *reszsztring(char const *eredeti, int mettol, int meddig) {
    int regihossz = strlen(eredeti);
    if (mettol < 0)
        mettol = 0;
    if (meddig > regihossz)
        meddig = regihossz;
    
    int ujhossz = meddig - mettol;
    char *ujsztring = (char*) malloc((ujhossz + 1) * sizeof(char));
    if (ujsztring == NULL)
        return NULL;
    
    memcpy(ujsztring, eredeti + mettol, ujhossz * sizeof(char));
    ujsztring[ujhossz] = '\0';
    return ujsztring;
}

int main(void) {
    char *uj = reszsztring("hello reszsztring", 3, 9);
    if (uj != NULL) {
        printf("[%s]\n", uj);
        free(uj);
    }
    return 0;
}

A memcpy() függvénnyel kapcsolatban lásd az előző feladat mintamegoldását.

Itt a működés a következő:

• Átmásoljuk az új helyre a sztring elejét a memcpy() függvénnyel. Ennek a végén egyelőre nincs lezáró nulla.
• Ezek után folytatólagosan (mettol karakterrel arrébb kezdődően) átmásoljuk az eredeti sztring végét. Az eredetinek a végén van lezáró nulla, és odáig kell menni, ezért ehhez a strcpy() is jó. Sőt ez lezáró nullát is tesz, úgyhogy készen is vagyunk.

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

/*
 * Előállít egy új sztringet, amely az 'eredeti' nevű sztring
 * eleje és vége kerül bele; a közepén lévő részt, a [mettol, meddig)
 * tartó karaktersorozatot elhagyva belőle. A hívó a kapott
 * dinamikus tömbre meg kell majd hívja a free() függvényt.
 */
char *kivag(char const *eredeti, int mettol, int meddig) {
    int regihossz = strlen(eredeti);
    if (mettol < 0)
        mettol = 0;
    if (meddig > regihossz)
        meddig = regihossz;
    
    int ujhossz = regihossz - (meddig - mettol);
    char *ujsztring = (char*) malloc((ujhossz + 1) * sizeof(char));
    if (ujsztring == NULL)
        return NULL;
    
    memcpy(ujsztring, eredeti, mettol * sizeof(char));
    strcpy(ujsztring + mettol, eredeti + meddig);
    return ujsztring;
}

int main(void) {
    char *uj = kivag("hello vilag kivagott sztring", 4, 8);
    if (uj != NULL) {
        printf("[%s]\n", uj);
        free(uj);
    }
    return 0;
}

Itt is lehetne a memcpy()-t használni; lásd az előző feladatokat.

Ez a mintamegoldás egy másik ötletet mutat. A strncat(mihez, mit, n) függvény a mihez sztringhez fűzi a mit sztring elején lévő, legfeljebb n darab karaktert. Utána pedig mindig tesz lezáró nullát. A lépések ezzel a következők:

• A karaktertömb elejére lezáró nullát teszünk, így az üres sztringgé válik.
• Az strncat() függvénnyel átmásoljuk az eredeti sztring elejét, abból hova darab karaktert. Utána lezáró nulla kerül, mert az strncat mindig tesz olyat.
• Az így kapott sztringhez fűzzük a mit sztringet; lezáró nulla itt is lesz.
• Az utolsó strcat() hívás az eredeti sztring végét fűzi az új sztringhez, megint lezárva azt a szükséges '\0'-val.

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

/*
 * Beszúrja az 'eredeti' sztring belsejébe, a 'hova'
 * pozícióba, a 'mit' sztringet. Az így kapott,
 * dinamikusan foglalt sztringgel tér vissza, amelyre
 * a hívónak a free() függvényt meg kell majd hívnia.
 */
char *beszur(char const *eredeti, int hova, char const *mit) {
    int ujhossz = strlen(eredeti) + strlen(mit);
    
    char *ujsztring = (char*) malloc((ujhossz + 1) * sizeof(char));
    if (ujsztring == NULL)
        return NULL;
    
    ujsztring[0] = '\0';
    strncat(ujsztring, eredeti, hova);
    strcat(ujsztring, mit);
    strcat(ujsztring, eredeti + hova);
    return ujsztring;
}

int main(void) {
    char *uj = beszur("hello!", 5, ", world");
    if (uj != NULL) {
        printf("[%s]\n", uj);
        free(uj);
    }
    return 0;
}