การเปลี่ยนแปลงเกี่ยวกับชุดรูปแบบการสะกดคำแบบพิมพ์: การสร้างสิ่งเล็กน้อยในสถานที่

ฉันรู้ว่านี่เป็นเรื่องที่ค่อนข้างทั่วไป แต่เท่าที่ UB ทั่วไปหาได้ง่ายฉันไม่พบตัวแปรนี้จนถึงตอนนี้

ดังนั้นฉันจึงพยายามแนะนำวัตถุพิกเซลอย่างเป็นทางการในขณะที่หลีกเลี่ยงการคัดลอกข้อมูลจริง

ถูกต้องหรือไม่

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.
}

รูปแบบการใช้ที่คาดไว้ง่ายขึ้นมาก:

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

โดยเฉพาะอย่างยิ่ง:

• รหัสนี้มีพฤติกรรมที่กำหนดไว้อย่างดีหรือไม่?
• ถ้าใช่มันปลอดภัยที่จะใช้ตัวชี้ที่ส่งคืนหรือไม่?
• ถ้าใช่Pixelมันสามารถขยายประเภทอื่นได้หรือไม่? (คลายข้อ จำกัด ของ is_trivial? pixel ด้วย 3 องค์ประกอบเท่านั้น)

เสียงดังกราวและจีซีซีทำให้ทั้งวงนั้นกลายเป็นความว่างเปล่าซึ่งเป็นสิ่งที่ฉันต้องการ ตอนนี้ฉันอยากรู้ว่านี่เป็นการละเมิดกฎ C ++ หรือไม่

ลิงค์ Godboltหากคุณต้องการเล่นกับมัน

(หมายเหตุ: ฉันไม่ได้ติดแท็ก c ++ 17 แม้ว่าจะstd::byteเป็นเพราะคำถามยังคงใช้อยู่char)

มันเป็นพฤติกรรมที่ไม่ได้กำหนดให้ใช้ผลลัพธ์ของpromoteการเป็นอาร์เรย์ ถ้าเราดู[expr.add] /4.2เรามี

มิฉะนั้นถ้าPชี้ไปที่องค์ประกอบอาเรย์iของวัตถุอาเรย์ที่xมีnองค์ประกอบ ([dcl.array]) นิพจน์P + JและJ + P(โดยที่Jมีค่าj) ชี้ไปที่องค์ประกอบอาเรย์ (อาจเป็นไปตามสมมุติฐาน) i+jของxif 0≤i+j≤nและนิพจน์P - Jชี้ไปที่ ( อาจ-สมมุติ) องค์ประกอบอาร์เรย์ i−jของถ้าx0≤i−j≤n

เราเห็นว่ามันต้องใช้ตัวชี้เพื่อชี้ไปที่วัตถุอาร์เรย์ คุณไม่มีวัตถุอาร์เรย์จริงๆ คุณมีตัวชี้ไปยังสิ่งPixelที่เพิ่งเกิดขึ้นที่จะมีสิ่งอื่นPixelsตามมาในหน่วยความจำต่อเนื่อง นั่นหมายถึงองค์ประกอบเดียวที่คุณสามารถเข้าถึงได้จริงคือองค์ประกอบแรก การพยายามเข้าถึงสิ่งอื่นจะเป็นพฤติกรรมที่ไม่ได้กำหนดเนื่องจากคุณผ่านจุดสิ้นสุดของโดเมนที่ถูกต้องสำหรับตัวชี้

คุณมีคำตอบเกี่ยวกับการใช้งานตัวชี้ที่ส่งคืนอย่าง จำกัด แต่ฉันต้องการเพิ่มว่าฉันคิดว่าคุณต้องstd::launderสามารถเข้าถึงตัวแรกได้Pixel:

reinterpret_castจะทำก่อนที่Pixelวัตถุถูกสร้างขึ้น (สมมติว่าคุณไม่ได้ทำดังนั้นในgetSomeImageData) ดังนั้นreinterpret_castจะไม่เปลี่ยนค่าตัวชี้ ตัวชี้ผลลัพธ์จะยังคงชี้ไปที่องค์ประกอบแรกของstd::byteอาร์เรย์ที่ส่งผ่านไปยังฟังก์ชัน

เมื่อคุณสร้างPixelวัตถุพวกมันจะถูกซ้อนกันภายในstd::byteอาเรย์และstd::byteอาเรย์จะจัดให้มีการจัดเก็บสำหรับPixelวัตถุ

มีหลายกรณีที่การใช้ที่เก็บข้อมูลซ้ำทำให้ตัวชี้ไปยังวัตถุเก่าชี้ไปที่วัตถุใหม่โดยอัตโนมัติ แต่นี่ไม่ใช่สิ่งที่เกิดขึ้นที่นี่ดังนั้นresultจะยังคงชี้ไปที่std::byteวัตถุไม่ใช่Pixelวัตถุ ฉันเดาว่าใช้มันราวกับว่ามันชี้ไปที่Pixelวัตถุนั้นในทางเทคนิคจะเป็นพฤติกรรมที่ไม่ได้กำหนด

ผมคิดว่านี้ยังคงถือแม้ว่าคุณจะทำreinterpret_castหลังจากการสร้างPixelวัตถุตั้งแต่Pixelวัตถุและstd::byteที่ให้การจัดเก็บข้อมูลสำหรับมันไม่ได้เป็นตัวชี้ interconvertible ดังนั้นแม้กระทั่งตัวชี้จะยังคงชี้ไปstd::byteที่Pixelวัตถุไม่ใช่

หากคุณได้รับตัวชี้ให้ส่งคืนจากผลลัพธ์ของการวางตำแหน่งใหม่อย่างใดอย่างหนึ่งทุกอย่างควรจะโอเคจนถึงการเข้าถึงPixelวัตถุเฉพาะนั้นที่เกี่ยวข้อง

นอกจากนี้คุณต้องตรวจสอบให้แน่ใจว่าstd::byteตัวชี้ถูกจัดตำแหน่งอย่างเหมาะสมPixelและอาร์เรย์มีขนาดใหญ่พอจริง เท่าที่ฉันจำได้ว่ามาตรฐานไม่จำเป็นต้องPixelมีการจัดตำแหน่งแบบเดียวกันstd::byteหรือว่ามันไม่มีช่องว่างภายใน

นอกจากนี้ยังไม่มีสิ่งนี้ขึ้นอยู่กับPixelความสำคัญหรือคุณสมบัติอื่น ๆ ของมัน ทุกอย่างจะทำงานในลักษณะเดียวกันตราบใดที่std::byteอาร์เรย์มีขนาดเพียงพอและจัดแนวให้เหมาะสมกับPixelวัตถุ