编译器忽略运算符新分配

compiler ignores operator new allocation

本文关键字：分配 新分配 运算符 编译器      更新时间：2023-10-16

我正在用C++编程一个 512 位整数。对于整数，我使用 new 关键字从堆中分配内存，但编译器(MINGW 上的 g++ 版本 8.1(似乎错误地优化了它。即编译器命令是：

g++ -Wall -fexceptions -Og -g -fopenmp -std=c++14 -c main.cpp -o main.o

g++ -o binDebugcs.exe objDebugmain.o -O0 -lgomp

法典：

#include <iostream>
#include <cstdint>
#include <omp.h>
constexpr unsigned char arr_size = 16;
constexpr unsigned char arr_size_half = 8;
void exit(int);
struct uint512_t{
    uint32_t * bytes;
    uint512_t(uint32_t num){
        //The line below is either (wrongfully) ignored or (wrongfully) optimized out
        bytes = new(std::nothrow) uint32_t[arr_size];
        if(!bytes){
            std::cerr << "Error - not enough memory available.";
            exit(-1);
        }
        *bytes = num;
        for(uint32_t * ptr = bytes+1; ptr < ptr+16; ++ptr){
            //OS throws error 0xC0000005 (accessing unallocated memory) here
            *ptr = 0;
        }
    }
    uint512_t inline operator &(uint512_t &b){
        uint32_t* itera = bytes;
        uint32_t* iterb = b.bytes;
        uint512_t ret(0);
        uint32_t* iterret = ret.bytes;
        for(char i = 0; i < arr_size; ++i){
            *(iterret++) = *(itera++) & *(iterb++);
        }
        return ret;
    }
    uint512_t inline operator =(uint512_t &b){
        uint32_t * itera=bytes, *iterb=b.bytes;
        for(char i = 0; i < arr_size; ++i){
            *(itera++) = *(iterb++);
        }
        return *this;
    }
    uint512_t inline operator + (uint512_t &b){
        uint32_t * itera = bytes;
        uint32_t * iterb = b.bytes;
        uint64_t res = 0;
        uint512_t ret(0);
        uint32_t *p2ret = ret.bytes;
        uint32_t *p2res = 1+(uint32_t*)&res;
        //#pragma omp parallel for shared(p2ret, res, p2res, itera, iterb, ret) private(i, arr_size) schedule(auto)
        for(char i = 0; i < arr_size;++i){
            res = *p2res;
            res += *(itera++);
            res += *(iterb++);
            *(p2ret++) = (i<15) ? res+*(p2res) : res;
        }
        return ret;
    }
    uint512_t inline operator += (uint512_t &b){
        uint32_t * itera = bytes;
        uint32_t * iterb = b.bytes;
        uint64_t res = 0;
        uint512_t ret(0);
        uint32_t *p2ret = ret.bytes;
        uint32_t *p2res = 1+(uint32_t*)&res;
        //#pragma omp parallel for shared(p2ret, res, p2res, itera, iterb, ret) private(i, arr_size) schedule(auto)
        for(char i = 0; i < arr_size;++i){
            res = *p2res;
            res += *(itera++);
            res += *(iterb++);
            *(p2ret++) = (i<15) ? res+(*p2res) : res;
        }
        (*this) = ret;
        return *this;
    }
    //uint512_t inline operator * (uint512_t &b){
    //}
    ~uint512_t(){
        delete[] bytes;
    }
};
int main(void){
    uint512_t a(3);
}

ptr < ptr+16总是正确的。循环是无限的，最终会溢出它写入的缓冲区。

简单的解决方案：值初始化数组，这样你就不需要循环了：

bytes = new(std::nothrow) uint32_t[arr_size]();
//                                          ^^

附言。如果复制实例，则行为将是未定义的，因为复制将指向相同的分配，并且两个实例将尝试在析构函数中删除它。

简单的解决方案：不要使用裸拥有指针。如果需要动态分配数组，请使用 RAII 容器(如 std::vector(。

.PPS。首先要仔细考虑是否需要动态分配(以及相关的开销(。在许多情况下，512 位是一个相当安全的大小。

错误位于

此行，与new被优化无关：

for(uint32_t * ptr = bytes+1; ptr < ptr+16; ++ptr){
    *ptr = 0;
}

for的条件是错误的。 ptr < ptr+16永远不会是假的。循环将永远持续下去，最终您将取消引用无效的内存位置，因为ptr无限增加。

顺便说一下，允许编译器执行优化，但不允许更改程序的明显行为。如果你的代码执行new，编译器可以优化它，如果它可以确保new的副作用在你需要它们的时候(在本例中是你访问数组的那一刻(。

您正在越界访问数组。最小的可重现示例是：

#include <cstdint>
int main() {
        uint32_t bytes[16];
        for(uint32_t * ptr = bytes + 1; ptr < ptr + 16; ++ptr){
            //OS throws error 0xC0000005 (accessing unallocated memory) here
            *ptr = 0;
        }
}

ptr < ptr + 16始终为真(可能除了溢出(。

p.s 我尝试了您的解决方案，它工作正常 - 

bytes = new(std::nothrow) uint32_t[arr_size];
    if(!bytes){
        std::cerr << "Error - not enough memory available.";
        exit(-1);
    }
    *bytes = num;
    auto ptrp16 = bytes+16;
    for(uint32_t * ptr = bytes+1;ptr < ptrp16 ; ++ptr){
        *ptr = 0;
    }
相关文章：