Différence entre malloc et calloc?

Quelle est la différence entre faire:

ptr = (char **) malloc (MAXELEMS * sizeof(char *));

ou:

ptr = (char **) calloc (MAXELEMS, sizeof(char*));

Quand est-ce une bonne idée d'utiliser calloc sur malloc ou vice versa?

calloc()vous donne un tampon zéro initialisé, tout en malloc()laissant la mémoire non initialisée.

Pour les allocations importantes, la plupart des callocimplémentations sous les OS traditionnels obtiendront des pages à zéro connu de l'OS (par exemple via POSIX mmap(MAP_ANONYMOUS)ou Windows VirtualAlloc), il n'a donc pas besoin de les écrire dans l'espace utilisateur. C'est ainsi que la normale mallocobtient plus de pages du système d'exploitation; callocprofite simplement de la garantie de l'OS.

Cela signifie que la callocmémoire peut toujours être «propre» et allouée paresseusement, et la copie sur écriture mappée sur une page physique partagée de zéros à l'échelle du système. (En supposant un système avec mémoire virtuelle.)

Certains compilateurs peuvent même optimiser malloc + memset (0) en calloc pour vous, mais vous devez utiliser explicitement calloc si vous voulez que la mémoire soit lue 0.

Si vous ne lirez jamais la mémoire avant de l'écrire, utilisez-la mallocafin qu'elle puisse (potentiellement) vous donner de la mémoire sale à partir de sa liste libre interne au lieu d'obtenir de nouvelles pages du système d'exploitation. (Ou au lieu de mettre à zéro un bloc de mémoire sur la liste gratuite pour une petite allocation).

Les implémentations intégrées de callocpeuvent laisser à calloclui-même la mémoire zéro s'il n'y a pas de système d'exploitation, ou ce n'est pas un système d'exploitation multi-utilisateurs sophistiqué qui met à zéro les pages pour arrêter les fuites d'informations entre les processus.

Sur Linux embarqué, malloc pourrait mmap(MAP_UNINITIALIZED|MAP_ANONYMOUS), qui n'est activé que pour certains noyaux intégrés car il n'est pas sécurisé sur un système multi-utilisateur.

Une différence moins connue est que dans les systèmes d'exploitation avec une allocation de mémoire optimiste, comme Linux, le pointeur renvoyé par mallocn'est pas soutenu par de la mémoire réelle jusqu'à ce que le programme le touche réellement.

calloctouche en effet la mémoire (il y écrit des zéros) et donc vous serez sûr que le système d'exploitation sauvegarde l'allocation avec de la RAM réelle (ou swap). C'est aussi pourquoi il est plus lent que malloc (non seulement il doit le mettre à zéro, le système d'exploitation doit également trouver une zone de mémoire appropriée en échangeant éventuellement d'autres processus)

Voir par exemple cette question SO pour plus de détails sur le comportement de malloc

Un avantage souvent négligé callocest que (implémentations conformes de) il vous aidera à vous protéger contre les vulnérabilités de débordement d'entier. Comparer:

size_t count = get_int32(file);
struct foo *bar = malloc(count * sizeof *bar);

contre.

size_t count = get_int32(file);
struct foo *bar = calloc(count, sizeof *bar);

Le premier pourrait entraîner une petite allocation et des dépassements de tampon ultérieurs, s'il countest supérieur à SIZE_MAX/sizeof *bar. Ce dernier échouera automatiquement dans ce cas car un objet de cette taille ne peut pas être créé.

Bien sûr, vous devrez peut-être être à la recherche d'implémentations non conformes qui ignorent simplement la possibilité de débordement.

La documentation fait ressembler le calloc à malloc, qui initialise simplement la mémoire à zéro; ce n'est pas la principale différence! L'idée de calloc est d'abstraire la sémantique de copie sur écriture pour l'allocation de mémoire. Lorsque vous allouez de la mémoire avec calloc, tout est mappé sur la même page physique qui est initialisée à zéro. Lorsqu'une des pages de la mémoire allouée est écrite dans une page physique est allouée. Ceci est souvent utilisé pour créer des tables de hachage ÉNORMES, par exemple car les parties de hachage vides ne sont pas soutenues par une mémoire supplémentaire (pages); ils pointent joyeusement vers la page unique initialisée à zéro, qui peut même être partagée entre les processus.

Toute écriture sur une adresse virtuelle est mappée sur une page, si cette page est la page zéro, une autre page physique est allouée, la page zéro y est copiée et le flux de contrôle est renvoyé au processus client. Cela fonctionne de la même manière que les fichiers mappés en mémoire, la mémoire virtuelle, etc. fonctionnent .. il utilise la pagination.

Voici une histoire d'optimisation sur le sujet: http://blogs.fau.de/hager/2007/05/08/benchmarking-fun-with-calloc-and-zero-pages/

Il n'y a aucune différence dans la taille du bloc de mémoire alloué. callocremplit simplement le bloc de mémoire avec un motif physique de zéro. Dans la pratique, on suppose souvent que les objets situés dans le bloc de mémoire alloué avec callocont une valeur initiale comme s'ils avaient été initialisés avec un littéral 0, c'est-à-dire que les entiers devraient avoir la valeur de 0, les variables à virgule flottante - la valeur de0.0 , les pointeurs - la pointeur nul appropriée , etc.

Du point de vue pédant cependant, calloc(ainsi que memset(..., 0, ...)) n'est garanti que pour initialiser correctement (avec des zéros) les objets de type unsigned char. Tout le reste n'est pas garanti d'être correctement initialisé et peut contenir ce qu'on appelle une représentation d'interruption , ce qui provoque un comportement non défini. En d'autres termes, pour tout type autre que unsigned charle motif tout-à-zéro susmentionné, il pourrait représenter une valeur illégale, une représentation d'interruption.

Plus tard, dans l'un des rectificatifs techniques à la norme C99, le comportement a été défini pour tous les types d'entiers (ce qui est logique). Autrement dit, dans le langage C actuel, vous ne pouvez initialiser que les types entiers avec calloc(et memset(..., 0, ...)). L'utiliser pour initialiser autre chose dans le cas général conduit à un comportement indéfini, du point de vue du langage C.

En pratique, callocça marche, comme nous le savons tous :), mais c'est à vous de décider si vous souhaitez l'utiliser (compte tenu de ce qui précède). Personnellement, je préfère l'éviter complètement, utiliser à la mallocplace et effectuer ma propre initialisation.

Enfin, un autre détail important est celui qui callocest nécessaire pour calculer la taille finale du bloc en interne , en multipliant la taille des éléments par le nombre d'éléments. Ce faisant, vous callocdevez surveiller les éventuels débordements arithmétiques. Il en résultera une allocation infructueuse (pointeur nul) si la taille de bloc demandée ne peut pas être calculée correctement. Pendant ce temps, votre mallocversion n'essaie pas de surveiller les débordements. Il allouera une certaine quantité de mémoire "imprévisible" en cas de débordement.

extrait d'un article Benchmarking fun with calloc () and zero pages on Georg Hager's Blog

Lors de l'allocation de mémoire à l'aide de calloc (), la quantité de mémoire demandée n'est pas allouée immédiatement. Au lieu de cela, toutes les pages qui appartiennent au bloc de mémoire sont connectées à une seule page contenant tous les zéros par une magie MMU (liens ci-dessous). Si de telles pages sont uniquement lues (ce qui était vrai pour les tableaux b, c et d dans la version originale du test de performances), les données sont fournies à partir de la page zéro unique, qui - bien sûr - tient dans le cache. Voilà pour les noyaux de boucles liés à la mémoire. Si une page est écrite (quelle que soit la manière), une erreur se produit, la page «réelle» est mappée et la page zéro est copiée en mémoire. C'est ce qu'on appelle la copie sur écriture, une approche d'optimisation bien connue (que j'ai même enseignée plusieurs fois dans mes conférences C ++). Après ça,

callocest généralement malloc+memsetà 0

Il est généralement légèrement préférable d'utiliser malloc+memsetexplicitement, surtout lorsque vous faites quelque chose comme:

ptr=malloc(sizeof(Item));
memset(ptr, 0, sizeof(Item));

C'est mieux car il sizeof(Item)est connu du compilateur au moment de la compilation et le compilateur le remplacera dans la plupart des cas par les meilleures instructions possibles pour mettre à zéro la mémoire. D'un autre côté, si cela memsetse produit calloc, la taille du paramètre de l'allocation n'est pas compilée dans le calloccode et réel memsetest souvent appelé, qui contiendrait généralement du code pour effectuer le remplissage octet par octet jusqu'à la limite longue, puis cycle pour remplir la mémoire en sizeof(long)morceaux et enfin le remplissage octet par octet de l'espace restant. Même si l'allocateur est suffisamment intelligent pour en appeler, aligned_memsetce sera toujours une boucle générique.

Une exception notable serait lorsque vous faites malloc / calloc d'une très grande partie de la mémoire (quelques power_of_two kilobytes), auquel cas l'allocation peut être effectuée directement à partir du noyau. Comme les noyaux de système d'exploitation mettent généralement à zéro toute la mémoire qu'ils donnent pour des raisons de sécurité, un calloc suffisamment intelligent peut simplement le renvoyer sans mise à zéro supplémentaire. Encore une fois - si vous allouez simplement quelque chose que vous savez petit, vous pourriez être mieux avec malloc + memset en termes de performances.

Différence 1:

malloc() alloue généralement le bloc de mémoire et il est un segment de mémoire initialisé.

calloc() alloue le bloc de mémoire et initialise tout le bloc de mémoire à 0.

Différence 2:

Si vous considérez la malloc()syntaxe, elle ne prendra qu'un seul argument. Considérez l'exemple suivant ci-dessous:

data_type ptr = (cast_type *)malloc( sizeof(data_type)*no_of_blocks );

Ex: si vous souhaitez allouer 10 blocs de mémoire pour le type int,

int *ptr = (int *) malloc(sizeof(int) * 10 );

Si vous considérez la calloc()syntaxe, cela prendra 2 arguments. Considérez l'exemple suivant ci-dessous:

data_type ptr = (cast_type *)calloc(no_of_blocks, (sizeof(data_type)));

Ex: si vous voulez allouer 10 blocs de mémoire pour le type int et initialiser tout cela à ZERO,

int *ptr = (int *) calloc(10, (sizeof(int)));

Similarité:

Les deux malloc()et calloc()renverront void * par défaut s'ils ne sont pas transtypés.!

Il y a deux différences.
Tout d'abord, c'est dans le nombre d'arguments. malloc()prend un seul argument (mémoire requise en octets), alors qu'il a calloc()besoin de deux arguments.
Deuxièmement, malloc()n'initialise pas la mémoire allouée, tout en calloc()initialisant la mémoire allouée à ZERO.

• calloc()alloue une zone mémoire, la longueur sera le produit de ses paramètres. callocremplit la mémoire de ZÉRO et renvoie un pointeur sur le premier octet. S'il ne parvient pas à localiser suffisamment d'espace, il renvoie un NULLpointeur.

Syntaxe: ptr_var=(cast_type *)calloc(no_of_blocks , size_of_each_block); ieptr_var=(type *)calloc(n,s);

• malloc()alloue un seul bloc de mémoire de REQUSTED SIZE et renvoie un pointeur sur le premier octet. S'il ne parvient pas à localiser la quantité de mémoire requise, il renvoie un pointeur nul.

Syntaxe: ptr_var=(cast_type *)malloc(Size_in_bytes); la malloc()fonction prend un argument, qui est le nombre d'octets à allouer, tandis que la calloc()fonction prend deux arguments, l'un étant le nombre d'éléments, et l'autre étant le nombre d'octets à allouer pour chacun de ces éléments. En outre, calloc()initialise l'espace alloué à des zéros, alors malloc()qu'il ne le fait pas.

La calloc()fonction qui est déclarée dans l'en- <stdlib.h>tête offre quelques avantages par rapport à la malloc()fonction.

1. Il alloue de la mémoire comme un certain nombre d'éléments d'une taille donnée, et
2. Il initialise la mémoire allouée afin que tous les bits soient nuls.

malloc()et calloc()sont des fonctions de la bibliothèque standard C qui permettent l'allocation dynamique de la mémoire, ce qui signifie qu'elles permettent toutes les deux l'allocation de la mémoire pendant l'exécution.

Leurs prototypes sont les suivants:

void *malloc( size_t n);
void *calloc( size_t n, size_t t)

Il y a principalement deux différences entre les deux:

• Comportement: malloc()alloue un bloc de mémoire, sans l'initialiser, et la lecture du contenu de ce bloc entraînera des valeurs inutiles. calloc(), d'autre part, alloue un bloc de mémoire et l'initialise à zéro, et évidemment la lecture du contenu de ce bloc se traduira par des zéros.

• Syntaxe: malloc()prend 1 argument (la taille à allouer) et calloc()prend deux arguments (nombre de blocs à allouer et taille de chaque bloc).

La valeur de retour des deux est un pointeur sur le bloc de mémoire alloué, en cas de succès. Sinon, NULL sera renvoyé, indiquant l'échec de l'allocation de mémoire.

Exemple:

int *arr;

// allocate memory for 10 integers with garbage values
arr = (int *)malloc(10 * sizeof(int)); 

// allocate memory for 10 integers and sets all of them to 0
arr = (int *)calloc(10, sizeof(int));

Les mêmes fonctionnalités que celles qui calloc()peuvent être obtenues en utilisant malloc()et memset():

// allocate memory for 10 integers with garbage values   
arr= (int *)malloc(10 * sizeof(int));
// set all of them to 0
memset(arr, 0, 10 * sizeof(int)); 

Notez qu'il malloc()est de préférence utilisé calloc()car il est plus rapide. Si vous souhaitez initialiser les valeurs à zéro, utilisez calloc()plutôt.

Une différence pas encore mentionnée: taille limite

void *malloc(size_t size)ne peut allouer que jusqu'à SIZE_MAX.

void *calloc(size_t nmemb, size_t size);peut allouer environ SIZE_MAX*SIZE_MAX.

Cette capacité n'est pas souvent utilisée dans de nombreuses plates-formes avec adressage linéaire. De tels systèmes se limitent calloc()à nmemb * size <= SIZE_MAX.

Considérons un type de 512 octets appelé disk_sectoret le code veut utiliser beaucoup de secteurs. Ici, le code ne peut utiliser que des SIZE_MAX/sizeof disk_sectorsecteurs.

size_t count = SIZE_MAX/sizeof disk_sector;
disk_sector *p = malloc(count * sizeof *p);

Considérez ce qui suit qui permet une allocation encore plus importante.

size_t count = something_in_the_range(SIZE_MAX/sizeof disk_sector + 1, SIZE_MAX)
disk_sector *p = calloc(count, sizeof *p);

Maintenant, si un tel système peut fournir une allocation aussi importante, c'est une autre affaire. La plupart aujourd'hui ne le feront pas. Pourtant, cela s'est produit pendant de nombreuses années quand il SIZE_MAXétait 65535. Compte tenu de la loi de Moore , soupçonnez que cela se produira vers 2030 avec certains modèles de SIZE_MAX == 4294967295mémoire et des pools de mémoire dans les 100 Go.

Nombre de blocs:
malloc () affecte un seul bloc de mémoire demandée,
calloc () affecte plusieurs blocs de la mémoire demandée

Initialisation:
malloc () - n'efface pas et n'initialise pas la mémoire allouée.
calloc () - initialise la mémoire allouée par zéro.

Vitesse:
malloc () est rapide.
calloc () est plus lent que malloc ().

Arguments et syntaxe:
malloc () prend 1 argument:

1. octets

   • Le nombre d'octets à allouer

calloc () prend 2 arguments:

1. longueur

   • le nombre de blocs de mémoire à allouer
2. octets
   • le nombre d'octets à allouer à chaque bloc de mémoire

void *malloc(size_t bytes);         
void *calloc(size_t length, size_t bytes);      

Manière d'allocation de mémoire:
La fonction malloc attribue de la mémoire de la «taille» souhaitée à partir du tas disponible.
La fonction calloc attribue à la mémoire la taille de ce qui est égal à 'num * size'.

Signification du nom:
Le nom malloc signifie "allocation de mémoire".
Le nom calloc signifie "allocation contiguë".