Namespaces
Variants

std:: malloc

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 * malloc ( std:: size_t size ) ;

Alloue size octets de stockage non initialisés.

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 scalaire (au moins aussi strictement que std::max_align_t ) ( créant implicitement des objets dans la zone de destination).

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 peut être retourné qui ne peut pas être utilisé pour accéder au stockage, mais doit être passé à std::free ).

Les fonctions suivantes doivent être thread-safe :

Les appels à ces fonctions qui allouent ou désallouent une unité particulière de stockage 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

size - nombre d'octets à allouer

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

Cette fonction n'appelle pas les constructeurs ni n'initialise la mémoire de quelque manière que ce soit. Il n'existe pas de pointeurs intelligents prêts à l'emploi qui pourraient garantir que la fonction de désallocation correspondante soit appelée. La méthode préférée d'allocation de mémoire en C++ consiste à utiliser des fonctions compatibles RAII std::make_unique , std::make_shared , les constructeurs de conteneurs, etc., et, dans le code de bibliothèque de bas niveau, les new-expression .

Pour charger un fichier volumineux, le mappage de fichiers via des fonctions spécifiques au système d'exploitation, par exemple mmap sur POSIX ou CreateFileMapping ( A / W ) avec MapViewOfFile sur Windows, est préférable à l'allocation d'un tampon pour la lecture de fichiers.

Exemple

Exécuter ce code 
#include <cstdlib> 
#include <iostream>   
#include <memory>
#include <string>
int main() 
{
    constexpr std::size_t size = 4;
    if (auto ptr = reinterpret_cast<std::string*>(std::malloc(size * sizeof(std::string))))
    {
        try
        {
            for (std::size_t i = 0; i < size; ++i)
                std::construct_at(ptr + i, 5, 'a' + i);
            for (std::size_t i = 0; i < size; ++i)
                std::cout << "ptr[" << i << "] == " << ptr[i] << '\n';
            std::destroy_n(ptr, size);
        }
        catch (...) {}
        std::free(ptr);
    }
}

Sortie : 

p[0] == aaaaa
p[1] == bbbbb
p[2] == ccccc
p[3] == ddddd

Voir aussi

fonctions d'allocation
(fonction)
(obsolète en C++17) (supprimé en C++20)
obtient un stockage non initialisé
(modèle de fonction)
documentation C pour malloc