Jak radzić sobie z brakiem pracy Malloc i zwracając NULL?

Jestem trochę zdezorientowany, jak sprawdzić, czy alokacja pamięci nie powiodła się, aby zapobiec niezdefiniowanym zachowaniom spowodowanym przez dewelowaną {X0}} wskaźnik. Wiem, że malloc (i podobne funkcje) może zawieść i zwrócić NULL, a z tego powodu adres zwrócony powinien być zawsze sprawdzany przed kontynuowaniem z resztą programu. To, czego nie dostaję, to najlepszy sposób na radzenie sobie z tymi przypadkami. Innymi słowy: Jaki jest program, który ma robić, gdy malloc Powraca NULL?

Pracowałem nad tym wdrożeniem podwójnie połączonej listy, gdy ta wątpliwość podniesiona.

struct ListNode {

    struct ListNode* previous;
    struct ListNode* next;
    void* object;
};

struct ListNode* newListNode(void* object) {

    struct ListNode* self = malloc(sizeof(*self));

    if(self != NULL) {

        self->next = NULL;
        self->previous = NULL;
        self->object = object;
    }

    return self;
}

Inicjalizacja węzła występuje tylko wtedy, gdy jego wskaźnik został prawidłowo przydzielony. Jeśli tak się nie stało, ta funkcja konstruktora zwraca NULL.

Napisałem również funkcję, która tworzy nowy węzeł (wywołanie funkcji newListNode) począwszy od już istniejącego węzła, a następnie powraca.

struct ListNode* createNextNode(struct ListNode* self, void* object) {

    struct ListNode* newNext = newListNode(object);

    if(newNext != NULL) {

        newNext->previous = self;

        struct ListNode* oldNext = self->next;

        self->next = newNext;

        if(oldNext != NULL) {

            newNext->next = oldNext;
            oldNext->previous = self->next;
        }
    }

    return newNext;
}

Jeśli newListNode zwraca NULL, createNextNode, createNextNode, a także zwroty NULL i węzeł przekazywany do funkcji nie są dotknięte.

Następnie struktura Listnode jest używana do wdrożenia rzeczywistej listy połączonej.

struct LinkedList {

    struct ListNode* first;
    struct ListNode* last;
    unsigned int length;
};

_Bool addToLinkedList(struct LinkedList* self, void* object) {

    struct ListNode* newNode;

    if(self->length == 0) {

        newNode = newListNode(object);
        self->first = newNode;
    }
    else {

        newNode = createNextNode(self->last, object);
    }

    if(newNode != NULL) {

        self->last = newNode;
        self->length++;
    }

    return newNode != NULL;
}

Jeśli utworzenie nowego węzła nie powiedzie się, funkcja addToLinkedList zwraca 0, a sama lista połączona jest nietknięta.

Wreszcie, rozważmy tę ostatnią funkcję, która dodaje wszystkie elementy połączonej listy na inną linkę.

void addAllToLinkedList(struct LinkedList* self, const struct LinkedList* other) {

    struct ListNode* node = other->first;

    while(node != NULL) {

        addToLinkedList(self, node->object);
        node = node->next;
    }
}

Jak powinienem poradzić sobie z możliwością zwrotu addToLinkedList? Za to, co zebrałem, malloc nie powiedzie się, gdy nie jest już możliwe przydzielenie pamięci, więc zakładam, że kolejne połączenia po awarii alokacji również nie mam racji? Więc jeśli zostanie zwrócone 0, jeśli pętla natychmiast się zatrzyma, ponieważ w każdym razie nie będzie można dodać żadnych nowych elementów do listy? Również jest poprawny, aby stosować wszystkie te sprawdzanie jednego nad innym sposobem, w jaki to zrobiłem? Czy nie jest zbędny? Czy błędnie byłoby natychmiast zakończyć program, gdy tylko Malloc się nie powiedzie? Czytałem, że byłoby problematyczne dla programów wielokrotnych, a także, że w niektórych istnieje program może być w stanie kontynuować uruchomienie bez dalszej alokacji pamięci, więc błędnie byłoby traktować to jako błąd fatalny w jakimkolwiek możliwym przypadku . Czy to jest poprawne?

Przepraszamy za naprawdę długiego postu i dziękuję za pomoc!