/Zc:alignedNew (asignación con exceso de alineación de C++17)

Habilite la compatibilidad con new con exceso de alineación de C++17 y la asignación de memoria dinámica alineada en límites mayores que el predeterminado para el tipo alineado estándar de tamaño máximo, max_align_t.

Sintaxis

/Zc:alignedNew[-]

Comentarios

La biblioteca y el compilador de MSVC admiten la asignación de memoria dinámica alineada en exceso estándar de C++17. Cuando se especifica la opción /Zc:alignedNew, una asignación dinámica como new Example; respeta la alineación de Example, incluso cuando sea mayor que max_align_t, la máxima alineación necesaria para cualquier tipo fundamental. Cuando la alineación del tipo asignado no es exclusivamente la alineación garantizada por el operador original new, disponible como valor de la macro predefinida __STDCPP_DEFAULT_NEW_ALIGNMENT__, la instrucción new Example; da lugar a una llamada a ::operator new(size_t), como sucedía en C++14. Cuando la alineación es mayor que __STDCPP_DEFAULT_NEW_ALIGNMENT__, la implementación obtiene la memoria mediante ::operator new(size_t, align_val_t). Del mismo modo, la eliminación de tipos alineados en exceso invoca a ::operator delete(void*, align_val_t) o la firma de eliminación redimensionada ::operator delete(void*, size_t, align_val_t).

La opción /Zc:alignedNew solo está disponible cuando están habilitados /std:c++17, o cualquier versión posterior. Tanto en /std:c++17 como en cualquier versión posterior, /Zc:alignedNew está habilitado de forma predeterminada para cumplir la norma de C++. Si el único motivo para implementar los operadores new y delete es admitir asignaciones con exceso de alineación, es posible que no necesite este código ni en C++17 ni en los modos posteriores. Para desactivar esta opción y revertir al comportamiento de new y delete de C++14 al usar /std::c++17, o cualquier versión posterior, especifique /Zc:alignedNew-. Si implementa los operadores new y delete, pero no está listo para implementar las sobrecargas alineadas en exceso de los operadores new y delete que tienen el parámetro align_val_t, use la opción /Zc:alignedNew-para evitar que el compilador y la biblioteca estándar generen llamadas a las sobrecargas alineadas en exceso. La opción /permissive- no cambia la configuración predeterminada de /Zc:alignedNew.

La compatibilidad con /Zc:alignedNew está disponible a partir de la versión 15.5 de Visual Studio 2017.

Ejemplo

En este ejemplo se muestra cómo se comportan los operadores new y delete cuando se establece la opción /Zc:alignedNew.

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

Esta salida es típica de las compilaciones de 32 bits. Los valores de puntero varían en función de dónde se ejecuta la aplicación en la memoria.

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

Para obtener más información sobre los problemas de conformidad de Visual C++, vea Comportamiento no estándar.

Para establecer esta opción del compilador en el entorno de desarrollo de Visual Studio

1. Abra el cuadro de diálogo Páginas de propiedades del proyecto. Para más información, vea Establecimiento del compilador de C++ y de propiedades de compilación en Visual Studio.

2. Seleccione la página de propiedades Propiedades de configuración>C/C++>Línea de comandos.

3. Modifique la propiedad Opciones adicionales para que incluya /Zc:alignedNew o /Zc:alignedNew- y, después, seleccione Aceptar.

Consulte también

/Zc (Ajuste)