Variasi pada tema jenis hukuman: konstruksi sepele di tempat

Saya tahu ini adalah subjek yang cukup umum, tetapi sebanyak UB tipikal mudah ditemukan, saya tidak menemukan varian ini sejauh ini.

Jadi, saya mencoba memperkenalkan objek Pixel secara resmi sambil menghindari salinan data yang sebenarnya.

Apakah ini valid?

struct Pixel {
    uint8_t red;
    uint8_t green;
    uint8_t blue;
    uint8_t alpha;
};

static_assert(std::is_trivial_v<Pixel>);

Pixel* promote(std::byte* data, std::size_t count)
{
    Pixel * const result = reinterpret_cast<Pixel*>(data);
    while (count-- > 0) {
        new (data) Pixel{
            std::to_integer<uint8_t>(data[0]),
            std::to_integer<uint8_t>(data[1]),
            std::to_integer<uint8_t>(data[2]),
            std::to_integer<uint8_t>(data[3])
        };
        data += sizeof(Pixel);
    }
    return result; // throw in a std::launder? I believe it is not mandatory here.
}

Pola penggunaan yang diharapkan, sangat disederhanakan:

std::byte * buffer = getSomeImageData();
auto pixels = promote(buffer, 800*600);
// manipulate pixel data

Lebih spesifik:

• Apakah kode ini memiliki perilaku yang jelas?
• Jika ya, apakah aman menggunakan pointer yang dikembalikan?
• Jika ya, untuk Pixeltipe apa lagi dapat diperpanjang? (mengendurkan batasan is_trivial? pixel dengan hanya 3 komponen?).

Baik dentang dan gcc mengoptimalkan seluruh loop ke ketiadaan, itulah yang saya inginkan. Sekarang, saya ingin tahu apakah ini melanggar beberapa aturan C ++ atau tidak.

Link Godbolt jika Anda ingin bermain-main dengannya.

(catatan: Saya tidak memberi tag c ++ 17 std::byte, karena pertanyaannya tetap menggunakan char)

Ini adalah perilaku yang tidak ditentukan untuk menggunakan hasil promotesebagai array. Jika kita melihat [expr.add] /4.2 yang kita miliki

Jika tidak, jika Pmenunjuk ke elemen array idari objek arrayx dengan nelemen ([dcl.array]), ekspresi P + Jdan J + P(di mana Jmemiliki nilai j) menunjuk ke elemen array (mungkin-hipotetis) i+jdari xjika 0≤i+j≤ndan ekspresi P - Jmenunjuk ke ( mungkin-hipotetis) elemen array i−jdari xjika 0≤i−j≤n.

kita melihat bahwa itu membutuhkan pointer untuk benar-benar menunjuk ke objek array. Anda sebenarnya tidak memiliki objek array. Anda memiliki pointer ke satu Pixelyang kebetulan memiliki lainnya Pixelsmengikutinya dalam memori yang berdekatan. Itu berarti satu-satunya elemen yang dapat Anda akses adalah elemen pertama. Mencoba mengakses hal lain adalah perilaku yang tidak terdefinisi karena Anda melewati akhir domain yang valid untuk penunjuk.

Anda sudah memiliki jawaban mengenai penggunaan terbatas dari pointer yang dikembalikan, tetapi saya ingin menambahkan bahwa saya juga berpikir Anda perlu std::launderuntuk dapat mengakses yang pertama Pixel:

Ini reinterpret_castdilakukan sebelum Pixelobjek apa pun dibuat (dengan asumsi Anda tidak melakukannya getSomeImageData). Karena itu reinterpret_casttidak akan mengubah nilai pointer. Pointer yang dihasilkan masih akan menunjuk ke elemen pertama std::bytearray yang diteruskan ke fungsi.

Ketika Anda membuat Pixelobjek, mereka akan bersarang di dalam std::bytearray dan std::bytearray akan menyediakan penyimpanan untuk Pixelobjek.

Ada kasus di mana penggunaan kembali penyimpanan menyebabkan pointer ke objek lama secara otomatis menunjuk ke objek baru. Tapi ini bukan yang terjadi di sini, jadi resultmasih akan menunjuk ke std::byteobjek, bukan Pixelobjek. Saya kira menggunakannya seolah-olah itu menunjuk ke suatu Pixelobjek secara teknis akan menjadi perilaku yang tidak terdefinisi.

Saya pikir ini masih berlaku, bahkan jika Anda melakukan reinterpret_castsetelah membuat Pixelobjek, karena Pixelobjek dan std::bytepenyimpanan yang menyediakannya tidak pointer-interconvertible . Jadi meski begitu pointer akan tetap menunjuk ke std::byte, bukan Pixelobjek.

Jika Anda memperoleh pointer untuk kembali dari hasil salah satu penempatan-baru, maka semuanya akan baik-baik saja, sejauh menyangkut akses ke Pixelobjek tertentu tersebut.

Anda juga perlu memastikan bahwa std::bytepointer sesuai untuk Pixeldan bahwa array benar-benar cukup besar. Sejauh yang saya ingat standar tidak benar-benar mengharuskan yang Pixelmemiliki keselarasan yang sama std::byteatau tidak memiliki padding.

Juga tidak satu pun dari ini tergantung pada Pixelmenjadi sepele atau benar-benar milik lainnya. Semuanya akan berperilaku dengan cara yang sama selama std::bytearray berukuran cukup dan sesuai untuk Pixelobjek.