/Zc:alignedNew (C++17 over uitgelijnde toewijzing)

Schakel ondersteuning in voor C++17 boven uitgelijndenew, dynamische geheugentoewijzing die is uitgelijnd op grenzen die groter zijn dan de standaardwaarde voor het standaard uitgelijnde type. max_align_t

Syntaxis

/Zc:alignedNew[-]

Opmerkingen

De MSVC-compiler en -bibliotheek ondersteunen C++17 standaard over uitgelijnde dynamische geheugentoewijzing. Wanneer de /Zc:alignedNew optie is opgegeven, respecteert een dynamische toewijzing, zoals new Example; de uitlijning van Example zelfs wanneer deze groter is dan max_align_t, de grootste uitlijning die vereist is voor elk fundamenteel type. Wanneer de uitlijning van het toegewezen type niet meer is dan de uitlijning die wordt gegarandeerd door de oorspronkelijke operator new, beschikbaar als de waarde van de vooraf gedefinieerde macro __STDCPP_DEFAULT_NEW_ALIGNMENT__, resulteert de instructie new Example; in een aanroep zoals ::operator new(size_t) in C++14. Wanneer de uitlijning groter is dan __STDCPP_DEFAULT_NEW_ALIGNMENT__, verkrijgt de implementatie in plaats daarvan het geheugen met behulp van ::operator new(size_t, align_val_t). Op dezelfde manier wordt het verwijderen van overgelijnde typen aangeroepen ::operator delete(void*, align_val_t) of de handtekening voor ::operator delete(void*, size_t, align_val_t)het verwijderen van de grootte.

De /Zc:alignedNew optie is alleen beschikbaar wanneer /std:c++17 of later is ingeschakeld. Onder /std:c++17 of hoger /Zc:alignedNew is standaard ingeschakeld om te voldoen aan de C++-standaard. Als de enige reden waarom u een operator new implementeert en delete over-uitgelijnde toewijzingen ondersteunt, hebt u deze code mogelijk niet meer nodig in C++17 of hoger. Als u deze optie wilt uitschakelen en wilt terugkeren naar het C++14-gedrag van new en delete wanneer u deze gebruikt /std:c++17 of hoger, geeft u op /Zc:alignedNew-. Als u een operator new implementeert en delete u niet klaar bent om de overgelijnde operator new en delete overbelastingen met de align_val_t parameter te implementeren, gebruikt u de /Zc:alignedNew- optie om te voorkomen dat de compiler en de standaardbibliotheek aanroepen genereert naar de overgelijnde overbelastingen. Met /permissive- de optie wordt de standaardinstelling van /Zc:alignedNew.

Ondersteuning voor /Zc:alignedNew is beschikbaar vanaf Visual Studio 2017 versie 15.5.

Voorbeeld

In dit voorbeeld ziet u hoe operator new en operator delete zich gedragen wanneer de /Zc:alignedNew optie is ingesteld.

// 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;
}

Deze uitvoer is typisch voor 32-bits builds. De aanwijzerwaarden variëren op basis van waar uw toepassing wordt uitgevoerd in het geheugen.

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

Zie Niet-standaardgedrag voor informatie over nalevingsproblemen in Visual C++.

Deze compileroptie instellen in de Ontwikkelomgeving van Visual Studio

1. Open het dialoogvenster eigenschappenpagina's van het project. Zie C++ compiler en buildeigenschappen instellen in Visual Studio voor meer informatie.

2. Selecteer de eigenschappenpagina configuratie-eigenschappen>C/C++>opdrachtregel.

3. Wijzig de eigenschap Aanvullende opties om op te nemen /Zc:alignedNew of /Zc:alignedNew- kies vervolgens OK.

Zie ook

/Zc (conformiteit)