Partage
  • Partager sur Facebook
  • Partager sur Twitter

Allocation qui ne marche pas ?

Alloc dynamique

    17 janvier 2022 à 16:28:58

    Bonjour,

    J'ai juste un ptit souci, je pense pas avoir bien compris les alloc dynamique, car j'ai fait un programme ou on saisit deux phrases, on les allocs, et puis si je demande en fin de programme la taille du tableau, il m'indique son maximum : 50... Un peu emmerdant vu que je l'ai alloc...

    int phrases(char phrase1[], char phrase2[])
    {
        *phrase1 = (char*)malloc(sizeof(char));
        *phrase2 = (char*)malloc(sizeof(char));
    
        printf("Saisir la phrase 1 :\n");
        gets(phrase1);
        printf("Saisir la phrase 2 :\n");
        gets(phrase2);
    
    
    
    }
    
    int main()
    {
        char phrase1[50];
        char phrase2[50];
    
        phrases(phrase1, phrase2);
        printf("%s\n", phrase1);
        printf("%s\n", phrase2);
        printf("La taille de la phrase 1 est : %d\n", sizeof(phrase1));
    
    }
    

    Comment montrer qu'il y a bien eu une alloc ?

    PS : J'ai bien free et NULL mes valeurs, mais ou est ce qu'on les free ?

    -
    Edité par Clément 2910 17 janvier 2022 à 16:36:10

    • Partager sur Facebook
    • Partager sur Twitter
      17 janvier 2022 à 16:44:08

      Dans ta fonction phrases, phrase1 et phrase2 sont des pointeurs sur char, donc *phrase1 et *phrase2 sont des char, ils ne sont donc pas adaptés pour recevoir l'adresse de l'allocation !

      A savoir qu'en C en ne transtype (cast) pas le retour de malloc.

      Si on regarde ton code dans son ensemble, phrase1 et phrase2 de la fonction main sont des tableaux de 50 char. Ils sont déjà alloué sur la pile. On se demande donc ce que viennent faire ces malloc dans la fonction phrases !

      Il faudrait peut-être revoir ton cours à ce sujet ! 

      PS : si c'est la taille d'une chaîne de caractère que tu veux, il faut utiliser la fonction strlen, sizeof donne la taille d'un type (ou la taille que prend une variable en mémoire). Un tableau de 50 char donne 50 même si tu n'utilises qu'une seule case. 

      -
      Edité par rouIoude 17 janvier 2022 à 16:49:56

      • Partager sur Facebook
      • Partager sur Twitter
        17 janvier 2022 à 16:53:29

        Ok j'ai compris... Donc on initialise nos phrases à NULL dans le main quoi ?

        Par contre je ne comprends pas pourquoi ya une erreur à la ligne 7 et 8 maintenant...

        #include <stdio.h>
        #include <stdlib.h>
        #include <string.h>
        
        int phrases(int taille1, char phrase1, char phrase2)
        {
            *phrase1= (char*)malloc(sizeof(char));
            *phrase2 = (char*)malloc(sizeof(char));
            taille1 = sizeof(phrase1);
            printf("Saisir la phrase 1 :\n");
            gets(phrase1);
            printf("Saisir la phrase 2 :\n");
            gets(phrase2);
            taille1 = sizeof(phrase1);
        
        
        
        
        }
        
        int main()
        {
            char phrase1 = NULL;
            char phrase2 = NULL;
            int taille1;
            phrases(taille1, phrase1, phrase2);
            printf("%s\n", phrase1);
            printf("%s\n", phrase2);
            printf("La taille de la phrase 1 est : %d\n", taille1);
        
            free(phrase1);
            free(phrase2);
            *phrase1 = NULL;
            *phrase2 = NULL;
        
        }



        • Partager sur Facebook
        • Partager sur Twitter
          17 janvier 2022 à 16:57:22

          Parce que c'est encore plus faux qu'avant.

          Dans ton main tu déclare un char * et si tu veux vraiment l'allouer dans phrases tu dois prendre un pointeur sur char *.

          Donc pour résumer :

          int phrases(char **phrase1, char **phrase2)
          {
              *phrase1 = malloc();
              *phrase2 = malloc();
          }
          
          int main(void)
          {
              char *phrase1, *phrase2;
          
              phrases(&phrase1, &phrase2);
          }


          Autre notes :

          • La fonction gets n'existe plus.
          • Une taille d'objet se stocke dans un size_t, pas int.
          • Ce n'est pas systématique d'initialiser les pointeurs à NULL si ils vont être obligatoirement réaffectés juste après.

          -
          Edité par markand 17 janvier 2022 à 17:00:24

          • Partager sur Facebook
          • Partager sur Twitter

          l'azerty est aux dispositions ce que subversion est aux SCM

            17 janvier 2022 à 18:15:04

            Oui, c'est pire qu'avant.

            Maintenant dans ta fonction phrase1 et phrase2 sont des char, tu ne peux donc pas les déréférencer, seul les pointeurs peuvent être déréférencé !

            malloc est une fonction qui alloue de la mémoire et qui retourne l'adresse de l'allocation, comme tu as du le voir dans ton cours une adresse ne peut être affectée qu'a un pointeur. Et je le répète, il ne faut pas transtyper le retour de malloc.

            Maintenant dans ta fonction main phrase1 et phrase2 sont des char, ils ne peuvent donc pas être NULL. Un char est une variable ne pouvant contenir qu'un seul caractère. (NULL est une valeur que l'on peut donner à un pointeur pour signifier qu'il est invalide).

            Comme je t'ai dit, tu devrais réviser ton cours, car il y a beaucoup trop de chose qui ne vont pas dans ton code.  

            -
            Edité par rouIoude 17 janvier 2022 à 18:18:34

            • Partager sur Facebook
            • Partager sur Twitter
              17 janvier 2022 à 18:59:50

              À quoi sert vraiment la fonction? Pour allouer de la mémoire?
              Tu peux faire dans le main:
              char *phrase1 = espace(taille);   // taille que tu désires.
              dans la fonction, tu peux faire:
              char *espace(size_t taille) {
                  char *area = malloc(taille);
                  return area;
              }
              Ça c'est si le malloc fonctionne et si on  assez de mémoire.
              sinon:
              char *espace(size_t taille) {
                   char *area = malloc(taille);
                  if(area != NULL) return area;
                   printf("Erreur, memoire demandee: %d\n", taille);
                  exit(EXIT_FAILURE);   // requière stdlib.h
              }
              • Partager sur Facebook
              • Partager sur Twitter

              Le Tout est souvent plus grand que la somme de ses parties.

              Allocation qui ne marche pas ?

              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
              • Editeur
              • Markdown