Kas malloci tulemuse valamine on C-s vajalik?

Malloci ja Castingi mõistmine C-s

C-programmeerimises hallatakse dünaamilist mälujaotust sageli funktsiooni "malloc" abil. Arendajad vaidlevad sageli selle üle, kas anda kursorile määramisel üle malloci tulemus. Kas näiteks on parem kasutada 'int *sõela = (int *)malloc(sizeof(*sieve) * pikkus);` asemel 'int *sõel = malloc(sizeof(*sieve) * pikkus);

Selles artiklis käsitletakse malloci tulemuste vältimise põhjuseid. Uurime mõlema lähenemisviisi mõju ja selgitame, miks ühte võiks eelistada teisele. Nende nüansside mõistmine võib aidata parandada teie C-programmeerimise tavasid.

Sukelduge malloci ja mäluhaldusse C-s

Esimeses skriptis näeme kasutamist malloc mälu dünaamiliseks eraldamiseks täisarvu massiivi jaoks. Avaldus int *sieve = malloc(sizeof(*sieve) * length); küsib mälu täisarvude 'pikkus' jaoks. Kasutades sizeof(*sieve), tagame, et olenemata kursori tüübist on eraldatud õige mälumaht. See meetod väldib tulemuste valamise vajadust malloc. Kui mälu eraldamine ebaõnnestub, kasutab programm seda fprintf(stderr, "Memory allocation failed\n"); tõrketeate printimiseks standardsesse veavoogu ja väljub seejärel nullist erineva olekuga. Eraldatud mälu kasutatakse täisarvude salvestamiseks vahemikus 1 kuni 'pikkuseni' ja see prinditakse hiljem välja enne selle vabastamist. free(sieve);.

Teises skriptis järgime sarnast struktuuri, kuid eraldame selle asemel mälu kahekordsete massiivi jaoks. Liin double *array = malloc(sizeof(*array) * length); eraldab mälu kahekordsete arvu 'pikkuse' jaoks. Kui jaotamine ebaõnnestub, perror funktsioon prindib kirjeldava veateate ja programm väljub koos EXIT_FAILURE. Eraldatud mälu kasutatakse topeltväärtuste salvestamiseks, mis initsialiseeritakse paarisarvudeks. Need väärtused prinditakse välja ja lõpuks vabastatakse mälu kasutades free(array);. Mõlemad skriptid näitavad edu kontrollimise tähtsust malloc ja õiget kasutamist free mälulekke vältimiseks.

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

int main() {
    int length = 10;
    int *sieve = malloc(sizeof(*sieve) * length);
    if (sieve == ) {
        fprintf(stderr, "Memory allocation failed\\n");
        return 1;
    }

    for (int i = 0; i < length; i++) {
        sieve[i] = i + 1;
    }

    for (int i = 0; i < length; i++) {
        printf("%d ", sieve[i]);
    }
    printf("\\n");

    free(sieve);
    return 0;
}

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

int main() {
    int length = 5;
    double *array = malloc(sizeof(*array) * length);
    if (array == ) {
        perror("Failed to allocate memory");
        return EXIT_FAILURE;
    }

    for (int i = 0; i < length; i++) {
        array[i] = i * 2.0;
    }

    for (int i = 0; i < length; i++) {
        printf("%f\\n", array[i]);
    }

    free(array);
    return 0;
}

Mälu eraldamise nüansid C-s

Teine C-s mälu jaotamise kriitiline aspekt on erinevuste mõistmine malloc ja muud mälu jaotamise funktsioonid nagu calloc ja realloc. Kuigi malloc eraldab mäluploki ilma seda initsialiseerimata, calloc mõlemad eraldavad ja lähtestavad mäluploki nulli. See võib ära hoida teatud tüüpi vigu, mis tekivad initsialiseerimata mälu kasutamisest. Näiteks, int *arr = calloc(length, sizeof(*arr)); tagab, et kõik elemendid on nullinitsialiseeritud, mis on kasulik, kui vajate puhast lehte.

Teiselt poolt, realloc kasutatakse olemasoleva mäluploki suuruse muutmiseks. Kui teil on vaja eraldatud mäluploki suurust muuta, realloc võib olla tõhusam valik kui uue ploki eraldamine ja sisu kopeerimine. Näiteks, arr = realloc(arr, new_length * sizeof(*arr)); reguleerib näidatud mäluploki suurust arr majutama new_length elemendid. Siiski on ülioluline hakkama saada realloc hoolikalt, et vältida mälulekkeid või algse mäluploki kaotamist realloc ebaõnnestub.