Partager via

/Zc:alignedNew (Allocation sur-alignée C++17)

  • Article

Activez la prise en charge de C++17 sur-aligné new, l’allocation de mémoire dynamique alignée sur les limites supérieures à la valeur par défaut pour le type aligné standard de taille maximale, max_align_t.

Syntaxe

/Zc:alignedNew[-]

Notes

La bibliothèque et le compilateur MSVC prennent en charge l’allocation de mémoire dynamique suralignée standard C++17. Lorsque l’option /Zc:alignedNew est spécifiée, une allocation dynamique telle que new Example; respecte l’alignement de Example même lorsqu’elle est supérieure max_align_tà , l’alignement le plus grand requis pour tout type fondamental. Lorsque l’alignement du type alloué n’est pas supérieur à l’alignement garanti par l’opérateur newd’origine, disponible comme valeur de la macro __STDCPP_DEFAULT_NEW_ALIGNMENT__prédéfinie, l’instruction new Example; génère un appel comme ::operator new(size_t) il l’a fait en C++14. Lorsque l’alignement est supérieur __STDCPP_DEFAULT_NEW_ALIGNMENT__à , l’implémentation obtient à la place la mémoire à l’aide ::operator new(size_t, align_val_t)de . De même, la suppression de types suralignés appelle ::operator delete(void*, align_val_t) ou la signature de suppression dimensionnée ::operator delete(void*, size_t, align_val_t).

L’option /Zc:alignedNew est disponible uniquement lorsque /std:c++17 ou une version ultérieure est activée. Sous /std:c++17 ou version ultérieure, /Zc:alignedNew est activé par défaut pour être conforme à la norme C++. Si la seule raison pour laquelle vous implémentez l’opérateur new et delete consiste à prendre en charge les allocations sur-alignées, vous n’avez peut-être plus besoin de ce code en C++17 ou en mode ultérieur. Pour désactiver cette option et revenir au comportement C++14 de new et delete lorsque vous utilisez /std::c++17 ou version ultérieure, spécifiez /Zc:alignedNew-. Si vous implémentez l’opérateur new et delete que vous n’êtes pas prêt à implémenter l’opérateur new sur-aligné et delete les surcharges qui ont le align_val_t paramètre, utilisez l’option /Zc:alignedNew- pour empêcher le compilateur et la bibliothèque standard de générer des appels vers les surcharges sur-alignées. L’option /permissive- ne modifie pas le paramètre par défaut de /Zc:alignedNew.

La prise en charge est /Zc:alignedNew disponible à partir de Visual Studio 2017 version 15.5.

Exemple

Cet exemple montre comment l’opérateur et l’opérateur new delete se comportent lorsque l’option /Zc:alignedNew est définie.

// alignedNew.cpp
// Compile by using: cl /EHsc /std:c++17 /W4 alignedNew.cpp
#include <iostream>
#include <malloc.h>
#include <new>

// "old" unaligned overloads
void* operator new(std::size_t size) {
    auto ptr = malloc(size);
    std::cout << "unaligned new(" << size << ") = " << ptr << '\n';
    return ptr ? ptr : throw std::bad_alloc{};
}

void operator delete(void* ptr, std::size_t size) {
    std::cout << "unaligned sized delete(" << ptr << ", " << size << ")\n";
    free(ptr);
}

void operator delete(void* ptr) {
    std::cout << "unaligned unsized delete(" << ptr << ")\n";
    free(ptr);
}

// "new" over-aligned overloads
void* operator new(std::size_t size, std::align_val_t align) {
    auto ptr = _aligned_malloc(size, static_cast<std::size_t>(align));
    std::cout << "aligned new(" << size << ", " <<
        static_cast<std::size_t>(align) << ") = " << ptr << '\n';
    return ptr ? ptr : throw std::bad_alloc{};
}

void operator delete(void* ptr, std::size_t size, std::align_val_t align) {
    std::cout << "aligned sized delete(" << ptr << ", " << size <<
        ", " << static_cast<std::size_t>(align) << ")\n";
    _aligned_free(ptr);
}

void operator delete(void* ptr, std::align_val_t align) {
    std::cout << "aligned unsized delete(" << ptr <<
        ", " << static_cast<std::size_t>(align) << ")\n";
    _aligned_free(ptr);
}

struct alignas(256) OverAligned {}; // warning C4324, structure is padded

int main() {
    delete new int;
    delete new OverAligned;
}

Cette sortie est généralement pour les builds 32 bits. Les valeurs de pointeur varient selon l’endroit où votre application s’exécute dans la mémoire.

unaligned new(4) = 009FD0D0
unaligned sized delete(009FD0D0, 4)
aligned new(256, 256) = 009FE800
aligned sized delete(009FE800, 256, 256)

Pour des informations sur les problèmes de conformité dans Visual C++, consultez Nonstandard Behavior.

Pour définir cette option du compilateur dans l'environnement de développement Visual Studio

  1. Ouvrez la boîte de dialogue Pages de propriété du projet. Pour plus d’informations, consultez Définir le compilateur C++ et les propriétés de build dans Visual Studio.

  2. Sélectionnez la page de propriétés Propriétés de configuration>C/C++>Ligne de commande.

  3. Modifiez la propriété Options supplémentaires pour inclure /Zc:alignedNew ou /Zc:alignedNew- choisir OK.

Voir aussi

/Zc (Conformité)