Allocation dynamique en C - complément

void* calloc(size_t num_elements, size_t size);

char *maChaine = malloc(15 * sizeof(char)); /* Ici, on ne connaît pas la valeur des cases mémoires. La valeur de chacune des cases mémoires est totalement aléatoire. */
int i;

if (maChaine == NULL) { /* On vérifie que le système n'a pas renvoyé un pointeur nul. */
    puts("ERREUR : probleme de memoire.");
    exit(EXIT_FAILURE);
}

for(i = 0; i < 15; i++)
    maChaine[i] = 0; /* On met chacune des cases à 0. */
/* suite du programme */

char *maChaine = calloc(15, sizeof(char)); /* Ici, on sait que les 15 cases mémoires contiennent 0. */

if (maChaine == NULL) {
    puts("ERREUR : probleme de memoire !");
    exit(EXIT_FAILURE);
}

/* suite du programme */

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

int main()
{
    float *ptr1 = NULL, *ptr2 = NULL;
    int i, n = 5, termination = 1;
    
    ptr1 = calloc(n, sizeof(float)); /* On alloue de la mémoire avec calloc() pour ptr1. */
    if (ptr1 == NULL) 
        printf("Echec de calloc().\n");
    else {
        ptr2 = malloc(n * sizeof(float));/* On alloue de la mémoire avec malloc() pour ptr2. */
        if (ptr2 == NULL)
            printf("Echec de malloc().\n");
        else {
            printf("Allocation de memoire avec\n");
            printf("calloc() pour ptr1\n");
            printf("malloc() pour ptr2.\n\n");
            for (i=0; i<n; i++)
                printf("ptr1[%d]=%f, ptr2[%d]=%f\n", i, ptr1[i], i, ptr2[i]);
            /* On affiche la valeur de chacune des cases des pointeurs. */
            printf("\n");
            free(ptr2);
            termination = 0;
        }
        free(ptr1);
    }
    
    return termination;
}

void* realloc(void *ptr, size_t size);

char *maChaine = calloc(15, sizeof(char));
if (maChaine == NULL)
    pb_memoire(); /* Cette fonction affiche un message d'erreur et termine le programme.
quelques instructions */

maChaine = realloc(maChaine, 20 * sizeof(char))
if (maChaine == NULL)
    pb_memoire();
/* quelques instructions */

free(maChaine);

void pb_memoire(void)
{
    printf("ERREUR : probleme de memoire !\n");
    exit(EXIT_FAILURE);
}

char *maChaine = malloc(15 * sizeof(char)), *copieDeMaChaine = NULL;
/* 15 ou plus probablement la valeur d'une variable. */
int i;

if (maChaine == NULL)
    pb_memoire();
for (i=0; i<15; ++i)
    maChaine[i] = 0; /* On met tout à zéro, ce que fait calloc().
  quelques instructions */

copieDeMaChaine = malloc(15 * sizeof(char));
if (copieDeMaChaine == NULL)
    pb_memoire();

for (i = 0; i < 15; i++)
    copieDeMaChaine[i] = maChaine[i]; /* On enregistre les données pour ne pas les perdre. */
 
free(maChaine); /* On libére la zone mémoire avant d'en acquérir une nouvelle. */
maChaine = malloc(20 * sizeof(char)); /* On demande plus de place en mémoire. */

if (maChaine == NULL)
    pb_memoire();

for (i = 0; i < 15; i++)
    maChaine[i] = copieDeMaChaine[i]; /* On récupère les valeurs qu'on a sauvegardées. */
free(copieDeMaChaine); /* On peut maintenant supprimer les données sauvegardées.
 
quelques instructions */
free(maChaine); /* On n'oublie pas de libérer la mémoire à la fin du programme ou de la fonction. */

void* realloc_s (void **ptr, size_t taille)
{
 void *ptr_realloc = realloc(*ptr, taille);

 if (ptr_realloc != NULL)
     *ptr = ptr_realloc;
/* Même si ptr_realloc est nul, on ne vide pas la mémoire. On laisse l'initiative au programmeur. */
 
 return ptr_realloc;
}

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

#define OS /* définir ici WINDOWS, LINUX ou MAC-OSX */
#define PAUSE puts("Appuyez sur entree pour continuer..."); \
     viderBuffer(); /* En effet, viderBuffer permet également de faire une pause dans le programme ! */

char* deleteCharInString(char c, char *string);
void* realloc_s(void **ptr, size_t taille); /* déclaration de la fonction de réallocation sécurisée */
size_t rentrerChaine(char **tailleChaine); /* renvoie la taille de la chaine */
char rentrerCaractere(void);
void viderBuffer(void);

int main(int argc, char *argv[])
{
    char *chaine, toDelete;
    size_t tailleChaine;
         
    puts("Entrez une chaine de caractere :");
    tailleChaine = rentrerChaine(&chaine);

    if (tailleChaine > 0) {
        puts("Entrez le caractere de la chaine a supprimer :");
        toDelete = rentrerCaractere();

        printf("\nVous avez entre la chaine \"%s\" et le caractere '%c'.\n", chaine, toDelete);
    /* On affiche à l'écran ce que l'utilisateur a rentré (éventuellement tronqué si c'était trop grand pour contenir
dans le tableau). */

        deleteCharInString(toDelete, chaine);
        realloc_s(&chaine, (strlen(chaine)+1) * sizeof(char)); /* La taille de la chaine a sûrement changé :
on ajuste la taille mémoire bien que ça ne soit pas indispensable, mais cela permet ici de réduire l'occupation en mémoire
de la chaîne. */

        printf("\nLa chaine apres suppression de '%c' vaut maintenant :\n%s\n", toDelete, chaine);
    }   
    free(chaine);

#ifdef WINDOWS
    /*
     * Pause pour pouvoir lire avant que la console ne disparaisse.
     * Ceci est une version portable.
     */
     PAUSE
#endif

    return EXIT_SUCCESS;
}

char* deleteCharInString(char c, char *string)
{
    size_t cpt = 0, count = 0;

    if (c != '\0') { /* si on ne cherche pas à supprimer le caractère de fin de chaîne */
        while (string[cpt] != c && string[cpt] != '\0')
            ++cpt;
/* On se positionne sur la première occurence du caractère à supprimer ou à la fin si le caractère à supprimer n'est pas dans la chaîne. */
        if (string[cpt] == c) {
            do ++count;
            while (string[cpt+count] == c);
            string[cpt] = string[cpt+count];
            /* On remplace le caractère à supprimer par le suivant. */
            while (string[cpt+count] != '\0') {
            /* si on n'est pas à la fin de la chaîne, il faut recommencer.
            On fait la même opération pour le caractère suivant. */
                ++cpt;
                while (string[cpt+count] == c)
                    ++count;
                string[cpt] = string[cpt+count];
            /* On affecte le prochain caractère qui ne soit pas à détruire. */
            }
        }
    }
    return string;
}

void* realloc_s(void **ptr, size_t taille)
{
     void *ptr_realloc = realloc(*ptr, taille);

     if (ptr_realloc != NULL)
         *ptr = ptr_realloc;

     return ptr_realloc;
}

void viderBuffer(void)
{
    char poubelle;

    do poubelle = getchar();
    while (poubelle != '\n' && poubelle != EOF);
}

size_t rentrerChaine(char **chaine) /* alloue dynamiquement de la mémoire pour chaque caractère rentré : pas de gaspillage de mémoire. */
{
     size_t tailleChaine = 1;
	
     *chaine = malloc(sizeof(char));
	
     if (*chaine != NULL) {
         **chaine = getchar();
         while (*chaine != NULL && (*chaine)[tailleChaine-1] != '\n' && (*chaine)[tailleChaine-1] != EOF)
             if (realloc_s(chaine, ++tailleChaine * sizeof(char)))
                 (*chaine)[tailleChaine-1] = getchar();
             else {
                 free(*chaine); /* la mémoire est pleine : on la libère. */
                 *chaine = NULL;
                 viderBuffer();
                 tailleChaine = 1;
             }
         if (*chaine != NULL)
             (*chaine)[tailleChaine-1] = '\0';
     }

     return --tailleChaine;
}

char rentrerCaractere(void)
{
    char input = getchar();

    while (input == '\n') {
        puts("Vous n'avez pas entre un caractere valide. Veuillez recommencer.");
	input = getchar(); /* prend un nouveau caractere */
    }
    viderBuffer();

    return input;
}

#include <stdio.h>
#include <stdlib.h>
#include "dico.h"
#include "fonctions_pendu.h"

#define COUPS_RESTANTS 7

typedef unsigned short int entier;

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

 char lettre, motSecret[32], *lettresProposees, *recherche;

 entier coupsRestants, nombreLettresProposees, cpt, tailleMot,
   *lettresTrouvees; /* Un tableau de booléens. Chaque case correspond à une lettre du mot secret. 0 = lettre non trouvée, 1 = lettre trouvée */

 enum {EN_COURS, GAGNEE, PERDUE} partie;

 do {

/***************************INITIALISATION DES VARIABLES************************/
     putchar('\n');
     if (piocherMot(motSecret) == 0)
         pb_memoire();

     tailleMot = strlen(motSecret);

     lettresTrouvees = calloc(tailleMot, sizeof(entier)); /* Le tableau ne comporte que des zéros ! */
     if (lettresTrouvees == NULL) /* test de la validité du pointeur */
         pb_memoire();

     partie = EN_COURS;

     nombreLettresProposees = 0;

     coupsRestants = COUPS_RESTANTS;
/***************************INITIALISATION DES VARIABLES************************/

 /* corps du programme */

 } while(rejouer()); /* une boucle do while parce qu'on joue au moins une fois
et on demande à l'utilisateur s'il veut ou non rejouer. */

 return 0;
}

lettre = proposer(lettresProposees, nombreLettresProposees);

if (nombreLettresProposees == 0) {
    lettresProposees = malloc(sizeof(char));
    if (lettresProposees == NULL)
        pb_memoire();
}
else if(realloc_s(&lettresProposees, (nombreLettresProposees+1) * sizeof(char))) /* appel à la fonction sécurisée */
     lettresProposees[nombreLettresProposees++] = lettre;
else {
/* gestion erreur */
     free(lettresProposees);
     free(lettresTrouvees);
     puts("ERREUR : memoire saturee");
     exit(EXIT_FAILURE);
}