ขายฉันเกี่ยวกับความถูกต้องของ const

เหตุใดจึงแนะนำให้ใช้ const ให้บ่อยที่สุด? สำหรับฉันแล้วดูเหมือนว่าการใช้ const อาจเป็นความเจ็บปวดมากกว่าความช่วยเหลือใน C ++ แต่แล้วอีกครั้งฉันมาที่นี่จากมุมมองของ python: ถ้าคุณไม่ต้องการให้บางสิ่งเปลี่ยนไปอย่าเปลี่ยน ด้วยเหตุนี้จึงเป็นคำถามสองสามข้อ:

1. ดูเหมือนว่าทุกครั้งที่ฉันทำเครื่องหมายบางอย่างเป็น const ฉันได้รับข้อผิดพลาดและต้องเปลี่ยนฟังก์ชันอื่นบางอย่างเพื่อให้เป็น const ด้วย แล้วนี้เป็นเหตุให้มีการเปลี่ยนแปลงอีกฟังก์ชั่นที่อื่น นี่เป็นสิ่งที่ง่ายขึ้นเมื่อมีประสบการณ์หรือไม่?

2. ประโยชน์ของการใช้ const จริงๆพอที่จะชดเชยปัญหาหรือไม่ หากคุณไม่ได้ตั้งใจจะเปลี่ยนวัตถุทำไมไม่เขียนโค้ดที่ไม่เปลี่ยนมัน

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

นี้เป็นบทความที่ชัดเจนเกี่ยวกับ "ความถูกต้อง const": https://isocpp.org/wiki/faq/const-correctness

สรุปการใช้ const เป็นแนวทางปฏิบัติที่ดีเพราะ ...

1. ช่วยปกป้องคุณจากการเปลี่ยนแปลงตัวแปรโดยไม่ได้ตั้งใจที่ไม่ได้ตั้งใจให้เปลี่ยนแปลง
2. ช่วยปกป้องคุณจากการกำหนดตัวแปรโดยไม่ได้ตั้งใจและ

3. คอมไพเลอร์สามารถปรับให้เหมาะสมได้ ตัวอย่างเช่นคุณได้รับการปกป้องจาก

   if( x = y ) // whoops, meant if( x == y )
   

ในขณะเดียวกันคอมไพลเลอร์สามารถสร้างโค้ดที่มีประสิทธิภาพมากขึ้นเนื่องจากรู้ว่าสถานะของตัวแปร / ฟังก์ชันจะเป็นอย่างไรตลอดเวลา หากคุณกำลังเขียนโค้ด C ++ แน่นนี่เป็นสิ่งที่ดี

คุณถูกต้องเนื่องจากอาจเป็นเรื่องยากที่จะใช้ความถูกต้องของ const อย่างสม่ำเสมอ แต่ end code จะกระชับและปลอดภัยกว่าในการเขียนโปรแกรมด้วย เมื่อคุณพัฒนา C ++ เป็นจำนวนมากประโยชน์ของสิ่งนี้จะปรากฏขึ้นอย่างรวดเร็ว

นี่คือโค้ดที่มีข้อผิดพลาดทั่วไปที่ความถูกต้องของ const สามารถป้องกันคุณจาก:

void foo(const int DEFCON)
{
   if (DEFCON = 1)     //< FLAGGED AS COMPILER ERROR! WORLD SAVED!
   {
       fire_missiles();
   }
}

ดูเหมือนว่าทุกครั้งที่ฉันทำเครื่องหมายบางอย่างเป็น const ฉันได้รับข้อผิดพลาดและต้องเปลี่ยนฟังก์ชันอื่นบางอย่างเพื่อให้เป็น const ด้วย แล้วนี่ทำให้ฉันต้องเปลี่ยนฟังก์ชั่นอื่นที่อื่น นี่เป็นสิ่งที่ง่ายขึ้นเมื่อมีประสบการณ์หรือไม่?

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

ไม่ใช่สำหรับคุณเมื่อคุณเขียนโค้ดในตอนแรก สำหรับคนอื่น (หรือคุณในอีกไม่กี่เดือนต่อมา) ที่กำลังดูการประกาศวิธีการภายในคลาสหรืออินเทอร์เฟซเพื่อดูว่ามันทำอะไร การไม่แก้ไขวัตถุเป็นข้อมูลสำคัญในการรวบรวมจากสิ่งนั้น

หากคุณใช้ const อย่างเข้มงวดคุณจะแปลกใจว่ามีตัวแปรจริงเพียงไม่กี่ตัวในฟังก์ชันส่วนใหญ่ มักไม่เกินตัวนับลูป หากรหัสของคุณไปถึงจุดนั้นคุณจะรู้สึกอบอุ่นภายใน ... การตรวจสอบความถูกต้องโดยการรวบรวม ... ขอบเขตของการเขียนโปรแกรมเชิงฟังก์ชันอยู่ใกล้ ๆ ... คุณเกือบจะสัมผัสได้แล้ว ...

const เป็นสัญญาที่คุณทำในฐานะนักพัฒนาและขอความช่วยเหลือจากคอมไพเลอร์ในการบังคับใช้

เหตุผลของฉันในการถูกต้อง const:

• เป็นการสื่อสารกับลูกค้าของฟังก์ชันของคุณว่าคุณจะไม่เปลี่ยนตัวแปรหรือวัตถุ
• การยอมรับข้อโต้แย้งโดยการอ้างอิง const ทำให้คุณมีประสิทธิภาพในการส่งผ่านข้อมูลอ้างอิงด้วยความปลอดภัยในการส่งผ่านค่า
• การเขียนอินเทอร์เฟซของคุณเป็น const ถูกต้องจะทำให้ไคลเอนต์สามารถใช้งานได้ หากคุณเขียนอินเทอร์เฟซของคุณเพื่อใช้ในการอ้างอิงที่ไม่ใช่ const ไคลเอนต์ที่ใช้ const จะต้องทิ้ง constness ออกไปเพื่อทำงานร่วมกับคุณ นี่เป็นสิ่งที่น่ารำคาญอย่างยิ่งหากอินเทอร์เฟซของคุณยอมรับ char * ที่ไม่ใช่ const และลูกค้าของคุณกำลังใช้ std :: strings เนื่องจากคุณจะได้รับ const char * จากพวกเขาเท่านั้น
• การใช้ const จะเกณฑ์คอมไพเลอร์เพื่อให้คุณซื่อสัตย์ดังนั้นคุณจะไม่เปลี่ยนแปลงสิ่งที่ไม่ควรเปลี่ยนแปลงโดยผิดพลาด

ปรัชญาของฉันคือถ้าคุณจะใช้ภาษาที่จู้จี้จุกจิกกับการตรวจสอบเวลาคอมไพล์มากกว่าที่จะใช้ให้เกิดประโยชน์สูงสุด constเป็นคอมไพเลอร์ที่บังคับใช้วิธีการสื่อสารในสิ่งที่คุณหมายถึง ... มันดีกว่าความคิดเห็นหรือ doxygen ที่เคยเป็นมา คุณจ่ายราคาทำไมไม่รับมูลค่า?

การเขียนโปรแกรม C ++ โดยไม่มี const ก็เหมือนกับการขับรถโดยไม่ได้เปิดเข็มขัดนิรภัย

การคาดเข็มขัดนิรภัยทุกครั้งที่ก้าวขึ้นรถเป็นความเจ็บปวดและ 364 จาก 365 วันคุณจะมาถึงอย่างปลอดภัย

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

สำหรับการเขียนโปรแกรมแบบฝังการใช้constอย่างรอบคอบเมื่อประกาศโครงสร้างข้อมูลส่วนกลางสามารถประหยัด RAM ได้มากโดยทำให้ข้อมูลคงที่อยู่ใน ROM หรือแฟลชโดยไม่ต้องคัดลอกไปยัง RAM ในเวลาบูต

ในการเขียนโปรแกรมในชีวิตประจำวันการใช้constอย่างระมัดระวังจะช่วยให้คุณหลีกเลี่ยงการเขียนโปรแกรมที่ขัดข้องหรือทำงานที่คาดเดาไม่ได้เนื่องจากพยายามแก้ไขตัวอักษรสตริงและข้อมูลส่วนกลางอื่น ๆ ที่คงที่

เมื่อทำงานร่วมกับโปรแกรมเมอร์คนอื่น ๆ ในโครงการขนาดใหญ่การใช้constอย่างถูกต้องจะช่วยป้องกันไม่ให้โปรแกรมเมอร์คนอื่นควบคุมคุณได้

constช่วยให้คุณแยกรหัสที่ "เปลี่ยนแปลงสิ่งต่างๆ" ด้านหลังของคุณ constดังนั้นในชั้นเรียนคุณต้องการทำเครื่องหมายวิธีการทั้งหมดที่ไม่ได้เปลี่ยนสถานะของวัตถุที่เป็น นั่นหมายความว่าconstอินสแตนซ์ของคลาสนั้นจะไม่สามารถเรียกใช้constวิธีการใด ๆ ที่ไม่ใช่เมธอดได้อีกต่อไป ด้วยวิธีนี้คุณจะถูกป้องกันไม่ให้เรียกใช้ฟังก์ชันที่สามารถเปลี่ยนแปลงวัตถุของคุณโดยไม่ได้ตั้งใจ

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

ตัวอย่าง:

#include <iostream>

class HelloWorld {
    bool hw_called;

public:
    HelloWorld() : hw_called(false) {}

    void hw() const {
        std::cout << "Hello, world! (const)\n";
        // hw_called = true;  <-- not allowed
    }

    void hw() {
        std::cout << "Hello, world! (non-const)\n";
        hw_called = true;
    }
};

int
main()
{
    HelloWorld hw;
    HelloWorld* phw1(&hw);
    HelloWorld const* phw2(&hw);

    hw.hw();    // calls non-const version
    phw1->hw(); // calls non-const version
    phw2->hw(); // calls const version
    return 0;
}

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

ในโค้ดจำนวนมากที่ฉันเขียนมันคุ้มค่ากับความพยายามเพราะเรามักจะใช้การจัดองค์ประกอบเป็นจำนวนมาก:

class A { ... }
class B { A m_a; const A& getA() const { return m_a; } };

หากเราไม่มีค่าความถูกต้องคุณจะต้องหันกลับไปใช้การส่งคืนวัตถุที่ซับซ้อนตามค่าเพื่อให้มั่นใจว่าไม่มีใครจัดการสถานะภายในของคลาส B ที่อยู่ด้านหลังของคุณ

ในระยะสั้นความถูกต้อง const เป็นกลไกการตั้งโปรแกรมป้องกันเพื่อช่วยตัวเองจากความเจ็บปวดบนท้องถนน

สมมติว่าคุณมีตัวแปรใน Python คุณรู้ว่าคุณไม่ควรแก้ไข ถ้าเผลอทำอะไรลงไป?

C ++ ช่วยให้คุณสามารถป้องกันตัวเองจากการทำอะไรบางอย่างโดยไม่ได้ตั้งใจตั้งแต่แรก ในทางเทคนิคคุณสามารถไปไหนมาไหนได้ แต่คุณต้องทำงานพิเศษเพื่อถ่ายทำเอง

มีบทความที่ดีเป็นที่นี่เกี่ยวกับ const ใน C ++ เป็นความคิดเห็นที่ตรงไปตรงมา แต่หวังว่าจะช่วยได้บ้าง

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

ใช่มันจะง่ายขึ้นเมื่อเวลาผ่านไป

ฉันชอบความถูกต้องของ const ... ในทางทฤษฎี ทุกครั้งที่ฉันพยายามใช้มันอย่างจริงจังในทางปฏิบัติมันก็พังทลายลงในที่สุดและ const_cast ก็เริ่มคืบคลานในการทำให้โค้ดน่าเกลียด

บางทีมันอาจจะเป็นแค่รูปแบบการออกแบบที่ฉันใช้ แต่ const มักจะกลายเป็นแปรงที่กว้างเกินไป

ตัวอย่างเช่นลองนึกภาพเอ็นจินฐานข้อมูลแบบธรรมดา ... มันมีวัตถุสคีมาตารางฟิลด์ ฯลฯ ผู้ใช้อาจมีตัวชี้ 'const Table' ซึ่งหมายความว่าพวกเขาไม่ได้รับอนุญาตให้แก้ไขสคีมาของตารางเอง ... แต่จะจัดการอย่างไร ข้อมูลที่เกี่ยวข้องกับตาราง? หากเมธอด Insert () ถูกทำเครื่องหมาย const จากนั้นภายในจะต้องทิ้ง const-ness ออกไปเพื่อจัดการกับฐานข้อมูลจริงๆ หากไม่ได้ทำเครื่องหมาย const แสดงว่าจะไม่ป้องกันการเรียกเมธอด AddField

บางทีคำตอบคือการแบ่งชั้นเรียนตามข้อกำหนดของ const-ness แต่มีแนวโน้มที่จะทำให้การออกแบบซับซ้อนมากกว่าที่ฉันต้องการเพื่อประโยชน์ที่จะได้รับ

คุณสามารถให้คำแนะนำคอมไพเลอร์ด้วย const ได้เช่นกัน .... ตามรหัสต่อไปนี้

#include <string>

void f(const std::string& s)
{

}
void x( std::string& x)
{
}
void main()
{
    f("blah");
    x("blah");   // won't compile...
}