Condividi tramite

/Zc:alignedNew (Allocazione sovraallineare C++17)

  • Articolo

Abilitare il supporto per C++17 over-aligned new, allocazione di memoria dinamica allineata ai limiti superiori al valore predefinito per il tipo allineato standard di dimensioni massime, max_align_t.

Sintassi

/Zc:alignedNew[-]

Osservazioni:

Il compilatore e la libreria MSVC supportano l'assegnazione della memoria dinamica sovrallineata standard di C++17. Quando si specifica l'opzione /Zc:alignedNew , un'allocazione dinamica, ad new Example; esempio rispetta l'allineamento di Example anche quando è maggiore di max_align_t, l'allineamento più grande necessario per qualsiasi tipo fondamentale. Quando l'allineamento del tipo allocato non è maggiore dell'allineamento garantito dall'operatore neworiginale , disponibile come valore della macro __STDCPP_DEFAULT_NEW_ALIGNMENT__predefinita , l'istruzione new Example; restituisce una chiamata a ::operator new(size_t) come in C++14. Quando l'allineamento è maggiore di __STDCPP_DEFAULT_NEW_ALIGNMENT__, l'implementazione ottiene invece la memoria usando ::operator new(size_t, align_val_t). In modo analogo l'eliminazione dei tipi sovrallineati chiama ::operator delete(void*, align_val_t) o la firma di eliminazione con dimensioni ::operator delete(void*, size_t, align_val_t).

L'opzione /Zc:alignedNew è disponibile solo quando /std:c++17 o versione successiva è abilitata. In /std:c++17 o versioni successive, /Zc:alignedNew è abilitato per impostazione predefinita per essere conforme allo standard C++. Se l'unico motivo per cui si implementa l'operatore new e delete consiste nel supportare le allocazioni eccessivamente allineate, potrebbe non essere più necessario questo codice nelle modalità C++17 o successive. Per disattivare questa opzione e ripristinare il comportamento C++14 di new e delete quando si usa /std::c++17 o versione successiva, specificare /Zc:alignedNew-. Se si implementa l'operatore new e delete , ma non si è pronti per implementare l'operatore new e delete gli overload sovraallineare il align_val_t parametro, usare l'opzione /Zc:alignedNew- per impedire al compilatore e alla libreria standard di generare chiamate agli overload sovraallineare. L'opzione /permissive- non modifica l'impostazione predefinita di /Zc:alignedNew.

Il supporto per /Zc:alignedNew è disponibile a partire da Visual Studio 2017 versione 15.5.

Esempio

In questo esempio viene illustrato il comportamento dell'operatore e dell'operatore new delete quando l'opzione /Zc:alignedNew è impostata.

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

Questo output è tipico per le compilazioni a 32 bit. I valori del puntatore variano a seconda del punto in cui l'applicazione viene eseguita in memoria.

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

Per informazioni sui problemi di conformità in Visual C++, vedere Comportamento non standard.

Per impostare l'opzione del compilatore nell'ambiente di sviluppo di Visual Studio

  1. Aprire la finestra di dialogo Pagine delle proprietà del progetto. Per informazioni dettagliate, vedere Impostare il compilatore e le proprietà di compilazione.

  2. Selezionare la pagina delle proprietà Proprietà di configurazione>C/C++>Riga di comando.

  3. Modificare la proprietà Opzioni aggiuntive per includere /Zc:alignedNew o /Zc:alignedNew- quindi scegliere OK.

Vedi anche

/Zc (conformità)