Petite question sur la mémoire en C

Bonjour,

Dans le code suivant, deux fonctions (fill et fill_2) sont proposées pour remplir la variable list[], déclarée ligne 30.
De ce que j’ai compris, la fonction fill est préférable parce que l’autre fonction induit une fuite de mémoire irrécupérable.

Ce que je ne comprends pas, c’est pourquoi la fonction fill fonctionne.
La valeur contenue dans temp n’est-elle pas automatiquement effacée au retour de la fonction ?

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

typedef struct AB
{
    int a, b;

} AB;

void fill(AB* list)
{
    AB temp;
    temp.a = 47;
    temp.b = 23;

    list[0] = temp;
}

void fill_2(AB* list)
{
    AB* temp = malloc(sizeof(AB));
    
    temp->a = 47;
    temp->b = 23;
    list[0] = *temp;
}

int main(void)
{
    AB list[1];
    fill_2(list); // à tester aussi avec : fill(list);

    printf("list.a : %d\nlist.b : %d\n", list[0].a, list[0].b);
    return EXIT_SUCCESS;
}

Petite question comme ça…

L’expression !variable est-elle strictement équivalente à l’expression variable == NULL ?

C’est un peu compliqué. Pourquoi NULL ? Mais oui, c’est vrai.

Bon comme la définition de NULL est un peu complexe, c’est pas évident de répondre, mais avec d’autres paragraphes de la norme on conclut que dans tous les cas où la sizeof T <= sizeof(void*) alors oui !E est équivalent à E==0 (ou E==NULL).

Bon, j’ai cherché un contre exemple rapidement. J’ai trouvé ça si ton compilateur supporte __int128 (c’était la première fois que j’utilisais ce type d’ailleurs).

#include <stdio.h>
#include <stdint.h>

int main(int argc, char* argv[]) {

    printf("%zu\n", sizeof(__int128));
    printf("%zu\n", sizeof(void*));

    unsigned __int128 a = 1;
    a <<= 64;

    printf("%p\n", (void*)a);


    if( a == NULL )
        puts("est NULL");
    if( !a )
        puts("est 0");

    return 0;
}

BTW:

void fill_h(AB* list) {
    *list = (AB){.a = 47, .b = 23};
}

Plus lisible, plus claire, plus simple.

Merci pour l’info

Mmm… Je ne vois pas le rapport entre ton exemple et la question « est-ce que !variable est équivalent à variable == NULL ». La macroconstante NULL correspond soit à 0 soit à (void *)0.

Autrement dit, au vu de la définition de l’opérateur ! (citée précédemment), on a un cas où c’est strictement équivalent (NULL est définie comme valant zéro) et un cas un peu différent où NULL vaut (void *)0. Toutefois, c’est sans compter les conversions implicites induites par l’opérateur ==.

En bref, si NULL vaut zéro, alors elle sera convertie vers le type du second opérande, si en revanche elle vaut (void *)0, c’est le second opérande qui sera converti vers le type void *.

char *p = 0;

/*
 * 0 == p => (char *)0 == p 
 *
 * OU
 *
 * (void *)0 == p => (void *)0 == (void *)p
 */

Toutefois, le résultat sera le même.

En bref, est-ce que !pointeur est strictement équivalent à pointeur == NULL ? Si NULL vaut zéro, oui, si NULL vaut (void *)0, non. Néanmoins, le résultat sera identique.

Voilà
Tu es arrivé à la même conclusion que moi mais en détaillant tout le raisonnement.

Le truc, c’est que l’OP a parlé d’expression !variable et variable == NULL sans pour autant préciser que variable serait un pointeur.

En supposant que NULL vaille (void*)0 et que variable ne soit pas un pointeur, alors il est possible que !variable ne soit pas équivalent à variable == NULL.

Dans tous les autres cas, variable == NULL équivaut à !variable.

Ah en fait du coup les deux derniers messages ont embrouillés un peu ma compréhension de ce que je pensais avoir compris.

Pour simplifier, peut-on affirmer que si variable est soit un pointeur (char*, void*, int*…) , soit une variable classique (int, char, short…), alors !variable est strictement équivalent à variable == NULL ? (Oui, d’après ce que j’ai compris.)

@ache si NULL est défini avec (void*) 0, ta comparaison est de toute façon un undefined behavior (comparaison entier qui n’est pas une constante 0 avec pointeur).

Merci