โครงสร้าง C / C ++ เทียบกับคลาส

หลังจากจบคลาส C ++ สำหรับฉันแล้วโครงสร้าง / คลาสแทบจะเหมือนกันยกเว้นมีความแตกต่างเล็กน้อยเล็กน้อย

ฉันไม่เคยตั้งโปรแกรมใน C มาก่อน แต่ฉันรู้ว่ามันมีโครงสร้าง ใน C เป็นไปได้ไหมที่จะสืบทอดโครงสร้างอื่น ๆ และตั้งค่าตัวปรับแต่งของสาธารณะ / ส่วนตัว?

ถ้าคุณทำได้ใน C ปกติทำไมเราถึงต้องการ C ++ ในโลกนี้? อะไรทำให้คลาสแตกต่างจากโครงสร้าง?

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

อย่างไรก็ตามใน Cโครงสร้างเป็นเพียงการรวบรวมข้อมูล (สาธารณะ) โดยรวมและไม่มีคุณสมบัติอื่น ๆ ที่เหมือนคลาส: ไม่มีเมธอดไม่มีตัวสร้างไม่มีคลาสฐาน ฯลฯ แม้ว่า C ++ จะสืบทอดคีย์เวิร์ด แต่ก็ขยายความหมาย (อย่างไรก็ตามนี่คือสาเหตุที่สิ่งต่าง ๆ เริ่มต้นเป็นสาธารณะในโครงสร้าง - โครงสร้างที่เขียนเหมือนโครงสร้าง C จะทำงานเหมือนกัน)

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

อื่น ๆ ที่ความแตกต่างในการเข้าถึงเริ่มต้น (สาธารณะ / ส่วนตัว) ไม่มีความแตกต่าง

อย่างไรก็ตามร้านค้าบางแห่งที่เขียนโค้ดใน C และ C ++ จะใช้ "class / struct" เพื่อระบุว่าสามารถใช้ได้ใน C และ C ++ (struct) และเป็น C ++ เท่านั้น (คลาส) กล่าวอีกนัยหนึ่งในรูปแบบนี้โครงสร้างทั้งหมดต้องทำงานร่วมกับ C และ C ++ นี่เป็นสาเหตุที่ทำให้เกิดความแตกต่างในครั้งแรกเมื่อนานมาแล้วย้อนกลับไปเมื่อ C ++ ยังรู้จักกันในชื่อ "C with Classes"

โปรดทราบว่าสหภาพ C ทำงานร่วมกับ C ++ แต่ไม่ใช่วิธีอื่น ตัวอย่างเช่น

union WorksWithCppOnly{
    WorksWithCppOnly():a(0){}
    friend class FloatAccessor;
    int a;
private:
    float b;
};

และเช่นเดียวกัน

typedef union friend{
    int a;
    float b;
} class;

ใช้ได้เฉพาะใน C

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

นี่คือส่วนที่เกี่ยวข้องจากหลักเกณฑ์:

C.2: ใช้คลาสถ้าคลาสมีค่าคงที่ ใช้โครงสร้างหากสมาชิกข้อมูลสามารถเปลี่ยนแปลงได้อย่างอิสระ

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

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

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

การบังคับใช้

มองหาโครงสร้างที่มีข้อมูลส่วนตัวและคลาสที่มีสมาชิกสาธารณะ

ตัวอย่างโค้ดที่ให้:

struct Pair {  // the members can vary independently
    string name;
    int volume;
};

// but

class Date {
public:
    // validate that {yy, mm, dd} is a valid date and initialize
    Date(int yy, Month mm, char dd);
    // ...
private:
    int y;
    Month m;
    char d;    // day
};

Classes ทำงานได้ดีสำหรับสมาชิกที่มาจากกันและกันหรือสัมพันธ์กัน นอกจากนี้ยังสามารถช่วยในการตรวจสอบสติสัมปชัญญะเมื่อมีการสร้างอินสแตนซ์ Structทำงานได้ดีกับการมี "ถุงข้อมูล" โดยที่ไม่มีอะไรพิเศษเกิดขึ้นจริง ๆ แต่สมาชิกก็มีเหตุผลที่จะรวมกลุ่มกัน

จากสิ่งนี้ทำให้รู้สึกว่าclassมีอยู่เพื่อรองรับการห่อหุ้มและแนวคิดการเข้ารหัสอื่น ๆ ที่เกี่ยวข้องซึ่งstructไม่มีประโยชน์มากนักสำหรับ

ไม่สามารถกำหนดฟังก์ชันสมาชิกหรือรับโครงสร้างจากกันและกันใน C

นอกจากนี้ C ++ ไม่ได้เป็นเพียง C + "derive structs" เท่านั้น เทมเพลตการอ้างอิงเนมสเปซที่ผู้ใช้กำหนดและตัวดำเนินการที่โอเวอร์โหลดทั้งหมดไม่มีอยู่ใน C

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

C ++ ใช้โครงสร้างเป็นหลักสำหรับ 1) ความเข้ากันได้ย้อนหลังกับ C และ 2) ประเภท POD โครงสร้าง C ไม่มีวิธีการสืบทอดหรือการมองเห็น