Namespaces
Variants

std:: calloc

From cppreference.net
< cpp ‎ | memory ‎ | c
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
Défini dans l'en-tête <cstdlib>
void * calloc ( std:: size_t num, std:: size_t size ) ;

Alloue de la mémoire pour un tableau de num objets de taille size , l'initialise avec tous les bits à zéro ( créant implicitement des objets dans la zone de destination).

Si l'allocation réussit, retourne un pointeur vers l'octet le plus bas (premier) dans le bloc de mémoire alloué qui est correctement aligné pour tout type d'objet.

Si size est zéro, le comportement est défini par l'implémentation (un pointeur nul peut être retourné, ou un pointeur non nul pouvant ne pas être utilisé pour accéder au stockage peut être retourné).

Les fonctions suivantes doivent être thread-safe :

Les appels à ces fonctions qui allouent ou désallouent une unité de stockage particulière se produisent dans un ordre total unique, et chaque appel de désallocation se produit-avant la prochaine allocation (le cas échéant) dans cet ordre.

(depuis C++11)

Table des matières

Paramètres

num - nombre d'objets
size - taille de chaque objet

Valeur de retour

En cas de succès, retourne le pointeur vers le début de la mémoire nouvellement allouée. Pour éviter une fuite de mémoire, le pointeur retourné doit être désalloué avec std::free() ou std::realloc() .

En cas d'échec, retourne un pointeur nul.

Notes

En raison des exigences d'alignement, le nombre d'octets alloués n'est pas nécessairement égal à num * size .

L'initialisation de tous les bits à zéro ne garantit pas qu'un nombre à virgule flottante ou un pointeur serait initialisé respectivement à 0.0 et à la valeur du pointeur nul (bien que cela soit vrai sur toutes les plateformes courantes).

À l'origine (en C89), la prise en charge de la taille zéro a été ajoutée pour accommoder du code tel que 

OBJ *p = calloc(0, sizeof(OBJ)); // espace réservé de "longueur nulle"
...
while (1)
{ 
    p = realloc(p, c * sizeof(OBJ)); // réallocations jusqu'à stabilisation de la taille
    ... // code susceptible de modifier c ou de sortir de la boucle
}

Exemple

Exécuter ce code 
#include <cstdlib>
#include <iostream>
int main()
{
    int* p1 = (int*)std::calloc(4, sizeof(int)); // alloue et initialise à zéro un tableau de 4 int
    int* p2 = (int*)std::calloc(1, sizeof(int[4])); // identique, en nommant directement le type de tableau
    int* p3 = (int*)std::calloc(4, sizeof *p3); // identique, sans répéter le nom du type
    if (p2)
        for (int n = 0; n < 4; ++n) // affiche le tableau
            std::cout << "p2[" << n << "] == " << p2[n] << '\n';
    std::free(p1);
    std::free(p2);
    std::free(p3);
}

Sortie : 

p2[0] == 0
p2[1] == 0
p2[2] == 0
p2[3] == 0

Voir aussi

Documentation C pour calloc