Bonjour,

J'ai peut-etre raté quelque chose dans la partie du cours concernant les tableaux dynamiques.

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


int main(void)
{
    int *p = malloc(sizeof(int[1]));

    if (p == NULL)
    {
        printf("Échec de l'allocation\n");
        return EXIT_FAILURE;
    }

    for (unsigned i = 0; i < 20; ++i)
    {
        p[i] = i * 10;
        printf("p[%u] = %d %p\n", i, p[i], &p[i]);
    }

    free(p);
    return 0;
}

Extrait du résultat :

p[0] = 0 0x7fffb9c4f260
p[1] = 10 0x7fffb9c4f264
p[2] = 20 0x7fffb9c4f268
p[3] = 30 0x7fffb9c4f26c
p[4] = 40 0x7fffb9c4f270
p[5] = 50 0x7fffb9c4f274
p[6] = 60 0x7fffb9c4f278
p[7] = 70 0x7fffb9c4f27c

L'allocation de mémoire est d'un pointeur "int"

Pourquoi, je peux affecter 20 ints dans le tableau  ? Peut-etre que c'est un fonctionnement normal ?

Merci de vos lumières..

Salut,

Prend un bout de papier, découpe le d'une seule case, et pose le quelque part sur la table : ça c'est le malloc.

Commence à écrire des nombres dedans : une case par nombre.

Comme ta feuille ne fait qu'une seule case, tu écris le premier nombre dessus, et puis les autres....

- tu les écris sur la table (A)

- ou bien sur une autre feuille qui était à coté (B)

- tu es au bord de la table et tu tombes. (C)

C'est ce que tu fais, on dit que tu débordes, et ton programme est instable. Selon l'endroit ou le malloc "posera ta feuille", tu auras donc : 

(A) : ça marche par "chance" -> c'est ton cas.

(B) : tu pines d'autres variables et la c'est la merde.... Quand tu as une variable qui n'a rien demandée et qui est modifiée... c'est que sa "feuille" était à coté de celle de laquelle tu as débordé.

(C) : tu plantes. (segment faut ; "ce programme va être arrêté....")

Quoiqu'il en soit, ton programme est instable. Aujourd'hui il marche, demain il ne marchera peut être plus.

-
Edité par Fvirtman 10 juin 2021 à 16:42:20

@Fvirtman:
Ça ne dit pas ce qu'il faut faire ...
Qu'est-ce qu'on veut réserver dans ce malloc?
De la place pour 20 entiers (int).
Ça devrait ressembler à ceci:
réserver 20 * place pour un int
    int *p = malloc(20 * sizeof(int));

Il me semblait que son problème n'était pas de "comment il faut faire", mais "pourquoi ça marche alors que je fais comme ça et je pensais que ça ne devrait pas !"

Mais bon, du coup il a mon explication, et également comment il faut faire avec ton message

-
Edité par Fvirtman 10 juin 2021 à 18:11:36

malloc ça alloue des octets.

Ton expression de sizeof alloue un entier. Si tu veux allouer de la place pour 10 entiers, tu dois faire une multiplication.

malloc(sizeof (int) * 20);