การเรียกใช้ฟังก์ชันที่มีตัวชี้ไปยังไม่ใช่ const และตัวชี้ไปยังอาร์กิวเมนต์ const ของที่อยู่เดียวกัน

ฉันต้องการเขียนฟังก์ชั่นที่ป้อนอาร์เรย์ของข้อมูลและส่งออกอาเรย์อีกหนึ่งข้อมูลโดยใช้พอยน์เตอร์

ฉันสงสัยว่าผลลัพธ์คืออะไรถ้าทั้งคู่srcและdstชี้ไปยังที่อยู่เดียวกันเพราะฉันรู้ว่าคอมไพเลอร์สามารถปรับให้เหมาะสมสำหรับ const มันเป็นพฤติกรรมที่ไม่ได้กำหนดหรือไม่? (ฉันติดแท็กทั้ง C และ C ++ เพราะฉันไม่แน่ใจว่าคำตอบอาจแตกต่างกันหรือไม่และฉันต้องการทราบเกี่ยวกับทั้งคู่)

void f(const char *src, char *dst) {
    dst[2] = src[0];
    dst[1] = src[1];
    dst[0] = src[2];
}

int main() {
    char s[] = "123";
    f(s,s);
    printf("%s\n", s);
    return 0;
}

นอกเหนือจากคำถามข้างต้นแล้วสิ่งนี้ได้กำหนดไว้อย่างชัดเจนหรือไม่หากฉันลบconstในรหัสต้นฉบับ?

ในขณะที่มันเป็นความจริงที่พฤติกรรมที่มีการกำหนดไว้อย่างดี - มันไม่เป็นความจริงที่คอมไพเลอร์สามารถ "เพิ่มประสิทธิภาพสำหรับ const" ในแง่ที่คุณหมายถึง

นั่นคือคอมไพเลอร์ไม่ได้รับอนุญาตสมมติว่าเพียงเพราะพารามิเตอร์เป็นconst T* ptrหน่วยความจำที่ชี้ไปตามptrจะไม่ถูกเปลี่ยนผ่านตัวชี้อื่น พอยน์เตอร์ไม่จำเป็นต้องเท่ากัน constเป็นภาระหน้าที่ไม่รับประกัน - ภาระผูกพันโดยคุณ (= ฟังก์ชั่น) จะไม่ทำการเปลี่ยนแปลงผ่านตัวชี้ว่า

เพื่อให้มีการรับประกันจริงนั้นคุณต้องทำเครื่องหมายตัวชี้ด้วยrestrictคำสำคัญ ดังนั้นถ้าคุณรวบรวมทั้งสองฟังก์ชั่น:

int foo(const int* x, int* y) {
    int result = *x;
    (*y)++;
    return result + *x;
}

int bar(const int* x, int* restrict y) {
    int result = *x;
    (*y)++;
    return result + *x;
}

foo()ฟังก์ชั่นจะต้องอ่านสองครั้งจากxในขณะที่bar()เพียงต้องการที่จะอ่านมันครั้งเดียว:

foo:
        mov     eax, DWORD PTR [rdi]
        add     DWORD PTR [rsi], 1
        add     eax, DWORD PTR [rdi]  # second read
        ret
bar:
        mov     eax, DWORD PTR [rdi]
        add     DWORD PTR [rsi], 1
        add     eax, eax              # no second read
        ret

ดูรายการสดGodBoltนี้

restrictเป็นเพียงคำหลักใน C (ตั้งแต่ C99) โชคไม่ดีที่มันยังไม่ได้ถูกนำมาใช้ใน C ++ จนถึงขณะนี้ (ด้วยเหตุผลที่ไม่ดีที่มีความซับซ้อนมากกว่าในการแนะนำใน C ++) คอมไพเลอร์หลายคนทำครับ-สนับสนุนมัน __restrictแต่เป็น

Bottom line: คอมไพเลอร์จะต้องรองรับกรณีการใช้ "ความลับ" ของคุณเมื่อรวบรวมf()และจะไม่มีปัญหาใด ๆ

_{ดูโพสต์นี้restrictเกี่ยวกับกรณีการใช้งานสำหรับ}

นี่ถูกกำหนดอย่างดี (ใน C ++, ไม่แน่ใจใน C อีกต่อไป), โดยมีและไม่มีตัวconstระบุ

สิ่งแรกที่จะมองหาเป็นกฎที่เข้มงวด aliasing 1 ถ้าsrcและdstชี้ไปที่วัตถุเดียวกัน:

• ใน C พวกเขาจะต้องเป็นประเภทที่เข้ากันได้ ; char*และchar const*เข้ากันไม่ได้
• ใน C ++ ที่พวกเขาจะต้องเป็นประเภทที่คล้ายกัน ; char*และchar const*มีความคล้ายคลึงกัน

เกี่ยวกับการconstคัดเลือกคุณอาจจะเถียงว่าตั้งแต่เมื่อdst == srcการทำงานของคุณได้อย่างมีประสิทธิภาพปรับเปลี่ยนสิ่งที่srcจุดไปไม่ควรจะมีคุณสมบัติเป็นsrc constนี่ไม่ใช่วิธีการconstทำงาน สองกรณีจำเป็นต้องได้รับการพิจารณา:

1. เมื่อวัตถุถูกกำหนดให้constเป็นในขณะที่char const data[42];การปรับเปลี่ยนมัน (โดยตรงหรือโดยอ้อม) นำไปสู่พฤติกรรมที่ไม่ได้กำหนด
2. เมื่อมีการconstกำหนดการอ้างอิงหรือตัวชี้ไปยังวัตถุเช่นเดียวกับchar const* pdata = data;หนึ่งสามารถปรับเปลี่ยนวัตถุพื้นฐานโดยที่มันไม่ได้ถูกกำหนดเป็นconst² (ดู 1) ดังนั้นต่อไปนี้เป็นคำนิยามที่ดี:

int main()
{
    int result = 42;
    int const* presult = &result;
    *const_cast<int*>(presult) = 0;
    return *presult; // 0
}

¹⁾ กฎนามแฝงที่เข้มงวดคืออะไร
²⁾ คือconst_castความปลอดภัยหรือไม่

สิ่งนี้ได้รับการกำหนดไว้อย่างดีใน C. กฎการใช้นามแฝงที่เข้มงวดไม่สามารถใช้ได้กับcharประเภทหรือกับตัวชี้สองประเภทเดียวกัน

ฉันไม่แน่ใจว่าคุณหมายถึงอะไรโดย "เพิ่มประสิทธิภาพสำหรับconst" คอมไพเลอร์ของฉัน (GCC 8.3.0 x86-64) สร้างรหัสเดียวกันแน่นอนสำหรับทั้งสองกรณี หากคุณเพิ่มตัวrestrictระบุไปยังพอยน์เตอร์แล้วรหัสที่สร้างขึ้นจะดีขึ้นเล็กน้อย แต่นั่นจะไม่ทำงานสำหรับกรณีของคุณพอยน์เตอร์จะเหมือนกัน

(C11 §6.5 7)

วัตถุต้องมีค่าที่เก็บไว้ที่เข้าถึงได้โดยนิพจน์ lvalue ที่มีประเภทใดประเภทหนึ่งต่อไปนี้:
- ชนิดที่เข้ากันได้กับชนิดของวัตถุที่มีประสิทธิภาพ
- รุ่นที่ผ่านการรับรองของชนิดที่เข้ากันได้กับชนิดประสิทธิผลของวัตถุ
- ประเภทที่เป็นประเภทที่ลงนามหรือไม่ได้ลงนามที่สอดคล้องกับประเภทของวัตถุที่มีประสิทธิภาพ
- ประเภทที่เป็นประเภทที่ลงนามหรือไม่ได้ลงนามที่สอดคล้องกับรุ่นที่มีประสิทธิภาพของประเภทของวัตถุ
- ประเภทรวมหรือสหภาพที่มี ประเภทดังกล่าวในหมู่สมาชิกของมัน (รวมถึง recursively, สมาชิกของ subaggregate หรือสหภาพที่มีอยู่) หรือ
- ประเภทตัวอักษร

ในกรณีนี้ (ไม่รวมrestrict) คุณจะได้รับ121ผลลัพธ์เสมอ