static_cast <> และการหล่อสไตล์ C แตกต่างกันอย่างไร

มีเหตุผลใดที่จะชอบstatic_cast<>การคัดเลือกนักแสดงสไตล์ C มากกว่าหรือไม่? พวกเขาเท่ากันหรือไม่ การเรียงลำดับความเร็วแตกต่างกันหรือไม่?

การร่ายสไตล์ C ++ นั้นได้รับการตรวจสอบโดยคอมไพเลอร์ รูปแบบ C ใช้งานไม่ได้และอาจล้มเหลวขณะทำงาน

นอกจากนี้สไตล์ c ++ สามารถค้นหาได้ง่ายในขณะที่มันยากที่จะค้นหาสไตล์ c

ประโยชน์ที่ยิ่งใหญ่อีกประการหนึ่งคือสไตล์ C ++ ที่แตกต่างกัน 4 รูปแบบแสดงถึงเจตนาของโปรแกรมเมอร์ชัดเจนยิ่งขึ้น

เมื่อเขียน C ++ ฉันมักจะใช้ C ++ กับสไตล์ C เสมอ

ในระยะสั้น :

1. static_cast<>() ช่วยให้คุณมีความสามารถในการตรวจสอบเวลาคอมไพล์ C-Style cast ไม่ได้
2. static_cast<>() สามารถอ่านได้มากขึ้นและสามารถเห็นได้ง่ายทุกที่ในรหัสที่มา C ++, C_Style cast is'nt
3. ความตั้งใจจะถ่ายทอดได้ดีขึ้นโดยใช้ C + + casts

คำอธิบายเพิ่มเติม :

คงโยนแปลงดำเนินการระหว่างประเภทที่เข้ากันได้ มันคล้ายกับตัวละครสไตล์ C แต่มีข้อ จำกัด มากกว่า ยกตัวอย่างเช่นตัวละครสไตล์ C จะอนุญาตให้ตัวชี้จำนวนเต็มชี้ไปที่อักขระ

char c = 10;       // 1 byte
int *p = (int*)&c; // 4 bytes

เนื่องจากสิ่งนี้ส่งผลให้ตัวชี้แบบ 4 ไบต์ (ตัวชี้ไปยังประเภทข้อมูลแบบ 4 ไบต์) ชี้ไปที่ 1 ไบต์ของหน่วยความจำที่จัดสรรการเขียนไปยังตัวชี้นี้จะทำให้เกิดข้อผิดพลาดขณะทำงานหรือจะเขียนทับหน่วยความจำบางส่วน

*p = 5; // run-time error: stack corruption

ตรงกันข้ามกับตัว C-style คาสต์คงที่จะอนุญาตให้คอมไพเลอร์ตรวจสอบว่าตัวชี้และชนิดข้อมูลพอยต์เข้ากันได้ซึ่งช่วยให้โปรแกรมเมอร์จับการกำหนดตัวชี้ที่ไม่ถูกต้องนี้ในระหว่างการรวบรวม

int *q = static_cast<int*>(&c); // compile-time error

คุณสามารถตรวจสอบหน้านี้เพื่ออธิบายเพิ่มเติมเกี่ยวกับ C ++ casts: คลิกที่นี่

ดูการเปรียบเทียบของ C ++ ผู้ประกอบการหล่อ

อย่างไรก็ตามการใช้ไวยากรณ์เดียวกันสำหรับการดำเนินการร่ายที่แตกต่างกันสามารถทำให้เจตนาของโปรแกรมเมอร์ไม่ชัดเจน

ยิ่งไปกว่านั้นมันอาจเป็นเรื่องยากที่จะค้นหาประเภทของการหล่อในรหัสเบสขนาดใหญ่

ลักษณะทั่วไปของการขว้าง C-style สามารถ overkill สำหรับสถานการณ์ที่ทุกอย่างที่ต้องการคือการแปลงอย่างง่าย ความสามารถในการเลือกระหว่างผู้ดำเนินการหล่อที่แตกต่างกันหลายระดับพลังงานที่แตกต่างกันสามารถป้องกันโปรแกรมเมอร์จากการหล่อโดยไม่ตั้งใจไปยังประเภทที่ไม่ถูกต้อง

struct A {};
struct B : A {};
struct C {}; 

int main()
{
    A* a = new A;    

    int i = 10;

    a = (A*) (&i); // NO ERROR! FAIL!

    //a = static_cast<A*>(&i); ERROR! SMART!

    A* b = new B;

    B* b2 = static_cast<B*>(b); // NO ERROR! SMART!

    C* c = (C*)(b); // NO ERROR! FAIL!

    //C* c = static_cast<C*>(b); ERROR! SMART!
}

โพสต์ที่ยอดเยี่ยมที่อธิบายการปลดเปลื้องที่แตกต่างกันใน C / C ++ และสิ่งที่นักแสดงในรูปแบบ C ทำได้จริง: https://anteru.net/blog/2007/12/18/200/index.html

การคัดเลือกแบบ C-Style โดยใช้ไวยากรณ์ตัวแปร (ชนิด) ที่เลวร้ายที่สุดที่เคยประดิษฐ์ นี้พยายามที่จะทำมันได้ปลดเปลื้องต่อไปนี้ตามลำดับนี้: (ดูมาตรฐาน C ++, 5.4 expr.cast วรรค 5)

1. const_cast
2. static_cast
3. static_cast ตามด้วย const_cast
4. reinterpret_cast
5. reinterpret_castfollowed โดย const_cast

static_castตรวจสอบ ณ เวลารวบรวมว่าการแปลงนั้นไม่อยู่ระหว่างประเภทที่เข้ากันไม่ได้ ตรงกันข้ามdynamic_castไม่มีการตรวจสอบความเข้ากันได้ของชนิดในขณะใช้งาน นอกจากนี้static_castการแปลงไม่จำเป็นต้องปลอดภัย

static_cast ใช้ในการแปลงจากตัวชี้ไปยังคลาสพื้นฐานเป็นตัวชี้ไปยังคลาสที่ได้รับหรือระหว่างชนิดเนทีฟเช่น enum เป็น int หรือ float เป็น int

ผู้ใช้static_castต้องแน่ใจว่าการแปลงนั้นปลอดภัย

คาสต์ C-style ไม่ทำการตรวจสอบใด ๆ

static_cast <> ช่วยให้คุณพูดว่า "ฉันใช้การแปลงทางกฎหมายจากประเภทหนึ่งไปยังอีกประเภทหนึ่ง" มีหลายประเภทที่แตกต่างกันในแต่ละความหมาย การหล่อแบบ C ธรรมดาอาจมีความหมายหลายอย่าง คุณหล่อขึ้น / ลงหรือไม่ คุณกำลังตีความตัวชี้ซ้ำหรือไม่