อะไรคือความแตกต่างระหว่าง struct และ class ใน C ++?

คำถามนี้ถูกถามอยู่แล้วในบริบทของ C

ตอนนี้ฉันต้องการเรียนรู้ความแตกต่างระหว่าง struct และคลาสใน C ++ โปรดอภิปรายเกี่ยวกับความแตกต่างทางเทคนิครวมถึงเหตุผลในการเลือกอย่างใดอย่างหนึ่งในการออกแบบ OO

ฉันจะเริ่มต้นด้วยความแตกต่างที่ชัดเจน:

• หากคุณไม่ระบุpublic:หรือprivate:สมาชิกของ struct เป็นแบบสาธารณะโดยค่าเริ่มต้น สมาชิกของคลาสเป็นส่วนตัวโดยค่าเริ่มต้น

ฉันแน่ใจว่ามีความแตกต่างอื่น ๆ ที่จะพบในมุมปิดบังของสเปค C ++

คุณลืมความแตกต่างที่สองหากินระหว่างคลาสและ structs

Quoth มาตรฐาน (§11.2.2ใน C ++ 98 ถึง C ++ 11):

ในกรณีที่ไม่มีการเข้าถึงระบุ สำหรับชั้นฐานประชาชนจะสันนิษฐานเมื่อเรียนมามีการประกาศ structและเอกชนจะสันนิษฐานเมื่อเรียนมีการประกาศคลาส

และเพื่อความสมบูรณ์เพียงเพื่อความแตกต่างที่รู้จักกันอย่างกว้างขวางมากขึ้นระหว่างชั้นเรียนและ struct กำหนดไว้ใน (11.2):

สมาชิกของคลาสที่กำหนดด้วยคลาสคำหลักเป็นส่วนตัวโดยค่าเริ่มต้น สมาชิกของคลาสที่กำหนดด้วยคีย์เวิร์ดstructหรือunion เป็นแบบสาธารณะโดยดีฟอลต์

ความแตกต่างเพิ่มเติม: classสามารถใช้คำหลักเพื่อประกาศพารามิเตอร์เทมเพลตในขณะที่structไม่สามารถใช้คำหลักนั้นได้

เธซเธฑc ++ คำถามที่พบบ่อย ,

[7.8] โครงสร้างคำหลักและคลาสแตกต่างกันอย่างไร

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

โครงสร้างและคลาสเป็นอย่างอื่นที่เทียบเท่ากับหน้าที่

ตกลงพอพูดคุยเทคโนสะอาดที่สะอาดสะอ้าน นักพัฒนาส่วนใหญ่สร้างความแตกต่างอย่างชัดเจนระหว่างคลาสและโครงสร้าง struct เพียงแค่รู้สึกเหมือนกองเปิดที่มีบิตน้อยมากในทางของการห่อหุ้มหรือการทำงาน ชั้นรู้สึกเป็นสมาชิกที่อยู่อาศัยและมีความรับผิดชอบของสังคมด้วยบริการที่ชาญฉลาดอุปสรรคการห่อหุ้มที่แข็งแกร่งและส่วนต่อประสานที่กำหนดไว้อย่างดี เนื่องจากเป็นความหมายแฝงที่คนส่วนใหญ่มีอยู่แล้วคุณควรใช้คำสำคัญ struct หากคุณมีคลาสที่มีวิธีการน้อยมากและมีข้อมูลสาธารณะ (สิ่งต่าง ๆ มีอยู่ในระบบที่ออกแบบมาอย่างดี!) แต่อย่างอื่น คำสำคัญ.

มันคุ้มค่าที่จะนึกถึงต้นกำเนิดของ C ++ และเข้ากันได้กับ C

C มีโครงสร้างมันไม่มีแนวคิดของการห่อหุ้มดังนั้นทุกอย่างจึงเป็นสาธารณะ

การเป็นสาธารณะโดยค่าเริ่มต้นโดยทั่วไปถือว่าเป็นความคิดที่ไม่ดีเมื่อใช้วิธีการเชิงวัตถุดังนั้นในการสร้างรูปแบบของ C ที่เอื้อต่อ OOP (คุณสามารถทำ OO ใน C แต่จะไม่ช่วยคุณ) ซึ่งเป็น แนวคิดใน C ++ (เดิมคือ "C With Classes") ทำให้เหมาะสมที่จะทำให้สมาชิกเป็นส่วนตัวโดยค่าเริ่มต้น

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

ดังนั้นคำหลักใหม่classได้รับการแนะนำให้เป็นเหมือน struct แต่ส่วนตัวโดยค่าเริ่มต้น

หาก C ++ มาจากศูนย์โดยไม่มีประวัตินั่นอาจเป็นเพียงคำหลักเดียวเท่านั้น มันอาจจะไม่ส่งผลกระทบกับมัน

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

สมาชิกของคลาสจะเป็นส่วนตัวโดยค่าเริ่มต้น สมาชิกของ Struct เป็นแบบสาธารณะโดยค่าเริ่มต้น นอกจากนั้นไม่มีความแตกต่างอื่น ๆ ดูคำถามนี้ด้วย

ตาม Stroustrup ในภาษา C ++ :

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

ในทางปฏิบัติไม่มีความแตกต่างจากสาธารณะ / ส่วนตัว

STRUCT เป็นชนิดของ Abstract Data Type ที่แบ่งหน่วยความจำที่กำหนดตามข้อกำหนดโครงสร้าง Structs มีประโยชน์อย่างยิ่งในการทำให้ไฟล์เป็นอนุกรม / ดีซีเรียลไลซ์เซชั่นเนื่องจากโครงสร้างสามารถเขียนลงในไฟล์คำต่อคำได้ (เช่นขอรับตัวชี้ไปที่ struct ใช้แมโคร SIZE เพื่อคำนวณจำนวนไบต์เพื่อคัดลอกจากนั้นย้ายข้อมูลเข้าหรือออกจาก struct)

คลาสเป็นชนิดข้อมูลนามธรรมที่แตกต่างกันซึ่งพยายามทำให้แน่ใจว่าซ่อนข้อมูล ภายในอาจมีความหลากหลายของการ machinations วิธีการตัวแปร temp ตัวแปรสถานะ ฯลฯ ที่ใช้เพื่อแสดง API ที่สอดคล้องกับรหัสใด ๆ ที่ต้องการใช้คลาส

เอฟเฟ็กต์ structs เป็นข้อมูลเกี่ยวกับคลาสที่เกี่ยวกับรหัส

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

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

1) สมาชิกของคลาสเป็นส่วนตัวโดยค่าเริ่มต้นและสมาชิกของ struct เป็นสาธารณะตามค่าเริ่มต้น

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

// Program 1
#include <stdio.h>

class Test {
    int x; // x is private
};
int main()
{
  Test t;
  t.x = 20; // compiler error because x is private
  getchar();
  return 0;
}
Run on IDE
// Program 2
#include <stdio.h>

struct Test {
    int x; // x is public
};
int main()
{
  Test t;
  t.x = 20; // works fine because x is public
  getchar();
  return 0;
}

2) เมื่อได้รับ struct จากคลาส / struct ตัวระบุการเข้าถึงเริ่มต้นสำหรับคลาส / โครงสร้างพื้นฐานจะเป็นแบบสาธารณะ และเมื่อได้รับคลาสตัวระบุการเข้าถึงเริ่มต้นจะเป็นส่วนตัว

ตัวอย่างเช่นโปรแกรม 3 ล้มเหลวในการรวบรวมและโปรแกรม 4 ทำงานได้ดี

// Program 3
#include <stdio.h>

class Base {
public:
    int x;
};

class Derived : Base { }; // is equilalent to class Derived : private Base {}

int main()
{
  Derived d;
  d.x = 20; // compiler error becuase inheritance is private
  getchar();
  return 0;
}
Run on IDE
// Program 4
#include <stdio.h>

class Base {
public:
    int x;
};

struct Derived : Base { }; // is equilalent to struct Derived : public Base {}

int main()
{
  Derived d;
  d.x = 20; // works fine becuase inheritance is public
  getchar();
  return 0;
}

ข้อแตกต่างอื่น ๆ คือการสืบทอดคลาสและโครงสร้างเริ่มต้นซึ่งไม่น่าแปลกใจคือส่วนตัวและสาธารณะตามลำดับ

1. สมาชิกของโครงสร้างเป็นสาธารณะโดยค่าเริ่มต้นสมาชิกของคลาสเป็นส่วนตัวโดยค่าเริ่มต้น
2. การสืบทอดเริ่มต้นสำหรับโครงสร้างจากโครงสร้างหรือคลาสอื่นคือ public การเริ่มต้นการสืบทอดสำหรับคลาสจากโครงสร้างหรือคลาสอื่นเป็นแบบส่วนตัว

class A{    
public:    
    int i;      
};

class A2:A{    
};

struct A3:A{    
};


struct abc{    
    int i;
};

struct abc2:abc{    
};

class abc3:abc{
};


int _tmain(int argc, _TCHAR* argv[])
{    
    abc2 objabc;
    objabc.i = 10;

    A3 ob;
    ob.i = 10;

    //A2 obja; //privately inherited
    //obja.i = 10;

    //abc3 obss;
    //obss.i = 10;
}

นี่คือ VS2005

ไม่ได้อยู่ในสเปคไม่ ความแตกต่างที่สำคัญคือความคาดหวังของโปรแกรมเมอร์เมื่อพวกเขาอ่านโค้ดของคุณใน 2 ปี structs มักจะถือว่าเป็น POD Structs ยังใช้ในการ metaprogramming แม่แบบเมื่อคุณกำหนดประเภทเพื่อวัตถุประสงค์อื่นนอกเหนือจากการกำหนดวัตถุ

สิ่งอื่นที่ควรทราบหากคุณอัปเดตแอปรุ่นเก่าที่มีโครงสร้างการใช้คลาสคุณอาจพบปัญหาต่อไปนี้:

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

เมื่อฟังก์ชั่นเสมือนอยู่ในคลาสแล้วภายในคอมไพเลอร์จะเพิ่มตัวชี้พิเศษให้กับข้อมูลคลาสเพื่อชี้ไปที่ฟังก์ชั่น

วิธีนี้จะทำลายรหัสมรดกเก่าได้อย่างไรถ้าในรหัสเก่าที่โครงสร้างถูกล้างโดยใช้ memfill เพื่อล้างมันทั้งหมดให้เป็นศูนย์นี่จะกระทืบข้อมูลตัวชี้พิเศษเช่นกัน

1. สมาชิกของคลาสที่กำหนดด้วยคำสำคัญclassนั้นเป็นprivateค่าเริ่มต้น สมาชิกของคลาสที่กำหนดด้วยคำหลักstruct(หรือunion) เป็นpublicค่าเริ่มต้น

2. ในกรณีที่ไม่มีการระบุการเข้าถึงสำหรับชั้นฐานpublicสันนิษฐานเมื่อมาระดับมีการประกาศstructและสันนิษฐานว่าเมื่อเรียนมีการประกาศprivateclass

3. คุณสามารถประกาศแต่ไม่ได้เป็นenum classenum struct

4. คุณสามารถใช้แต่ไม่template<class T>template<struct T>

โปรดทราบว่ามาตรฐาน C ++ ช่วยให้คุณสามารถส่งต่อชนิดเป็นstructและจากนั้นใช้classเมื่อประกาศประเภทและในทางกลับกัน นอกจากนี้ยังstd::is_class<Y>::valueเป็นที่trueสำหรับ Y เป็นstructและclassแต่สำหรับfalseenum class

ความแตกต่างระหว่างclassและstructคือความแตกต่างระหว่างคำหลักไม่ใช่ระหว่างชนิดข้อมูล สองนี้

struct foo : foo_base { int x;};
class bar : bar_base { int x; };

ทั้งกำหนดประเภทของคลาส ความแตกต่างของคำหลักในบริบทนี้คือการเข้าถึงเริ่มต้นที่แตกต่างกัน:

• foo::xเป็นแบบสาธารณะและfoo_baseสืบทอดต่อสาธารณะ
• bar::xเป็นแบบส่วนตัวและbar_baseสืบทอดแบบส่วนตัว

นี่คือคำอธิบายที่ดี: http://carcino.gen.nz/tech/cpp/struct_vs_class.php

ดังนั้นอีกครั้ง: ใน C ++ โครงสร้างจะเหมือนกันกับคลาสยกเว้นว่าสมาชิกของ struct มีการเปิดเผยข้อมูลสาธารณะตามค่าเริ่มต้น แต่สมาชิกของคลาสจะมีการเปิดเผยส่วนตัวตามค่าเริ่มต้น

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

ISO IEC 14882-2003

9 คลาส

วรรค 3

โครงสร้างเป็นชั้นที่กำหนดไว้กับชั้นที่สำคัญ struct ; สมาชิกและคลาสพื้นฐาน (ข้อ 10) เป็นสาธารณะโดยค่าเริ่มต้น (ข้อ 11)

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

template<class T> // OK
template<struct T> // ERROR, struct not allowed here

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

สิ่งที่อาจจะสนใจที่จะทราบ (โดยเฉพาะอย่างยิ่งตั้งแต่ถามมีแนวโน้มที่จะใช้ MSVC ++ ตั้งแต่เขาระบุว่า "ไม่มีการจัดการ" C ++) เป็นที่ Visual C ++ บ่นภายใต้สถานการณ์บางอย่างถ้าชั้นจะประกาศด้วยclassและกำหนดด้วยแล้วstruct(หรืออาจจะเป็นรอบวิธีอื่น ๆ ) แม้ว่ามาตรฐานบอกว่ามันถูกกฎหมายอย่างสมบูรณ์

• . ในชั้นเรียนสมาชิกทั้งหมดโดยค่าเริ่มต้นเป็นส่วนตัว แต่ในโครงสร้างสมาชิกเป็นสาธารณะโดยค่าเริ่มต้น

  1. ไม่มีคำเหมือน constructor และ destructor สำหรับ structs แต่สำหรับคอมไพเลอร์คลาสจะสร้างค่าเริ่มต้นหากคุณไม่ได้ระบุไว้

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

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

  ในระยะสั้นการประชุมคือการใช้ struct เมื่อมีวัตถุประสงค์เพื่อจัดกลุ่มข้อมูลและใช้คลาสเมื่อเราต้องการข้อมูลที่เป็นนามธรรมและอาจเป็นมรดก

  ในโครงสร้างและคลาส C ++ จะถูกส่งผ่านโดยค่าเว้นแต่จะยกเลิกการอ้างอิงอย่างชัดเจน ในชั้นเรียนภาษาและโครงสร้างอื่น ๆ อาจมีความหมายที่แตกต่าง - เช่น วัตถุ (อินสแตนซ์ของคลาส) อาจถูกส่งผ่านโดยการอ้างอิงและโครงสร้างอาจถูกส่งผ่านตามค่า หมายเหตุ: มีความคิดเห็นที่เกี่ยวข้องกับคำถามนี้ ดูหน้าการสนทนาเพื่อเพิ่มในการสนทนา

ในขณะที่บอกเป็นนัยโดยคำตอบอื่น ๆ แต่ก็ไม่ได้กล่าวถึงอย่างชัดเจน - structs นั้นเข้ากันได้กับ C ขึ้นอยู่กับการใช้งาน ชั้นเรียนไม่ได้

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

คุณอาจพิจารณาแนวทางนี้เมื่อจะไป struct หรือระดับhttps://msdn.microsoft.com/en-us/library/ms229017%28v=vs.110%29.aspx

√พิจารณากำหนด struct แทนคลาสหากอินสแตนซ์ของประเภทมีขนาดเล็กและอายุสั้นทั่วไปหรือถูกฝังอยู่ในวัตถุอื่น ๆ

X AVOID กำหนดโครงสร้างเว้นแต่ประเภทมีลักษณะดังต่อไปนี้ทั้งหมด:

มันมีเหตุผลแสดงถึงค่าเดียวคล้ายกับประเภทดั้งเดิม (int, double, ฯลฯ )

มีขนาดอินสแตนซ์ที่ต่ำกว่า 16 ไบต์

มันไม่เปลี่ยนรูป

มันจะไม่ต้องมีกล่องบ่อย

คลาสมีความหมายเฉพาะในบริบทของวิศวกรรมซอฟต์แวร์ ในบริบทของโครงสร้างข้อมูลและอัลกอริทึมคลาสและโครงสร้างจะไม่แตกต่างกัน ไม่มีกฎใด ๆ ที่ จำกัด ว่าจะต้องอ้างอิงสมาชิกของคลาส

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

หากคุณอ่านหลักการวิศวกรรมซอฟต์แวร์บางอย่างคุณจะพบว่ามาตรฐานส่วนใหญ่ไม่สามารถนำไปปฏิบัติได้อย่างง่ายดายหากไม่มีคลาส ตัวอย่างเช่น: http://en.wikipedia.org/wiki/SOLID_%28object-oriented_design%29

BTW, เมื่อโครงสร้างจัดสรรหน่วยความจำที่ จำกัด และรวมถึงตัวแปรหลายตัวตัวแปรประเภทค่าจะระบุว่ามีการฝังค่าในตำแหน่งที่โครงสร้างถูกจัดสรร ในทางตรงกันข้ามค่าของตัวแปรประเภทการอ้างอิงเป็นค่าภายนอกและการอ้างอิงโดยตัวชี้ซึ่งฝังอยู่ในที่ที่จัดสรรโครงสร้าง

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

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

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

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

** อัปเดต: ** โปรดละเว้นคำตอบนี้ ฉันไม่ได้พิจารณาความเป็นไปได้ที่ว่าสำหรับ struct ค่านั้นไม่ได้กำหนดค่าเริ่มต้น แต่เพิ่งเกิดขึ้นที่ 0 ไม่มีความแตกต่างในการเริ่มต้นระหว่าง struct และคลาส

ฉันเห็นความแตกต่างอื่นระหว่าง structs และคลาสที่เกี่ยวข้องกับการกำหนดค่าเริ่มต้น

struct Foo {
    int a;
};

class Bar {
    int a;
};

class Tester {
    Foo m_Foo = Foo();
    Bar m_Bar = Bar();

public:
    Tester() {}
};

int main() {
    auto myTester = Tester();
}

เรียกใช้รหัสนั้นและตรวจสอบ myTester คุณจะพบว่าสำหรับ m_Foo โครงสร้าง m_Foo.a นั้นถูกเตรียมใช้งานเป็น 0 แต่สำหรับ m_Bar คลาส m_Bar.a จะไม่เริ่มต้น ดังนั้นจึงดูเหมือนว่าจะมีความแตกต่างในสิ่งที่ผู้สร้างเริ่มต้นทำสำหรับ struct กับคลาส ฉันเห็นสิ่งนี้ด้วย Visual Studio

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

-> อีกสิ่งที่มีประโยชน์ที่ฉันเจอใน class vs struct คือขณะที่นำไฟล์ไปใช้ในโปรแกรมถ้าคุณต้องการให้การดำเนินการของ struct อีกครั้งและอีกครั้งในชุดปฏิบัติการใหม่ทุกครั้งที่คุณต้องแยกฟังก์ชั่นและคุณต้อง ส่งผ่าน object ของ struct หลังจากอ่านจากไฟล์เพื่อทำการดำเนินการบางอย่างกับมัน ในขณะที่อยู่ในชั้นเรียนถ้าคุณทำฟังก์ชั่นที่จะทำการดำเนินการบางอย่างกับข้อมูลที่จำเป็นทุกครั้ง .. มันง่ายที่คุณจะต้องอ่านวัตถุจากไฟล์และเรียกใช้ฟังก์ชัน

แต่มันขึ้นอยู่กับโปรแกรมเมอร์ซึ่งวิธีการที่เขา / เธอพบว่าเหมาะสม ... ตามฉันฉันชอบชั้นเรียนทุกครั้งเพียงเพราะมันรองรับ OOPs และนั่นคือเหตุผลที่มีการใช้งานในเกือบทุกภาษาและคุณสมบัติที่ยอดเยี่ยมของการเขียนโปรแกรมตลอดเวลา; - )

และใช่ความแตกต่างที่ไม่คาดคิดที่สุดที่ฉันลืมพูดถึงคือคลาสนั้นรองรับการซ่อนข้อมูลและสนับสนุนการดำเนินการที่สร้างขึ้นในชนิดข้อมูลในขณะที่ struct ไม่ได้!

ฉันพบความแตกต่างอื่น ๆ หากคุณไม่ได้กำหนดตัวสร้างในคลาสคอมไพเลอร์จะกำหนดหนึ่ง แต่ใน struct หากคุณไม่ได้กำหนด constructor คอมไพเลอร์ก็ไม่ได้กำหนด constructor เช่นกัน ดังนั้นในบางกรณีที่เราไม่ต้องการตัวสร้างจริง struct เป็นตัวเลือกที่ดีกว่า (เคล็ดลับประสิทธิภาพ) และขอโทษสำหรับภาษาอังกฤษที่ไม่ดีของฉัน

ชั้นเรียนเป็นประเภทอ้างอิงและโครงสร้างเป็นประเภทค่า
เมื่อฉันพูดว่า Classes เป็นประเภทอ้างอิง
โดยพื้นฐานแล้วพวกเขาจะมีที่อยู่ของตัวแปรอินสแตนซ์

ตัวอย่างเช่น:

Class MyClass
{
    Public Int DataMember;  //By default, accessibility of class data members 
                            //will be private. So I am making it as Public which 
                            //can be accessed outside of the class.
}

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

Static Public void Main (string[] arg)
{
    MyClass _myClassObject1 = new MyClass();
    _myClassObject1.DataMember = 10;

    MyClass _myClassObject2 = _myClassObject1;
    _myClassObject2.DataMember=20;
}

ในโปรแกรมด้านบน MyClass _myClassObject2 = _myClassObject1; คำสั่งระบุว่าตัวแปรทั้งสองประเภท MyClass

1. myClassObject1
2. myClassObject2

และจะชี้ไปที่ตำแหน่งหน่วยความจำเดียวกัน
โดยทั่วไปจะกำหนดตำแหน่งหน่วยความจำเดียวกันเป็นตัวแปรประเภทเดียวกันอีกประเภทหนึ่ง

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

"_myClassObject1.DataMember = 10;" ที่บรรทัดนี้ทั้งข้อมูลสมาชิกของวัตถุจะมีค่า 10
"_myClassObject2.DataMember = 20;" ที่บรรทัดนี้ทั้งข้อมูลสมาชิกของวัตถุจะมีค่าเป็น 20
ในที่สุดเรากำลังเข้าถึงดาต้ามิเตอร์ของวัตถุผ่านพอยน์เตอร์

โครงสร้างเป็นประเภทค่า ตัวอย่างเช่น:

Structure MyStructure
{
    Public Int DataMember;  //By default, accessibility of Structure data 
                            //members will be private. So I am making it as 
                            //Public which can be accessed out side of the structure.
}

Static Public void Main (string[] arg)
{
    MyStructure _myStructObject1 = new MyStructure();
    _myStructObject1.DataMember = 10;

    MyStructure _myStructObject2 = _myStructObject1;
    _myStructObject2.DataMember = 20;
}

ในโปรแกรมข้างต้น
การทำให้วัตถุของ MyStructure เป็นอินสแตนซ์โดยใช้ตัวดำเนินการใหม่และการ
จัดเก็บที่อยู่ลงในตัวแปร _myStructObject ของประเภท MyStructure และ
กำหนดค่า 10 ให้กับสมาชิกข้อมูลของโครงสร้างโดยใช้ "_myStructObject1.DataMember = 10"

ในบรรทัดถัดไป
ฉันประกาศอีกตัวแปร _myStructObject2 ประเภท MyStructure และกำหนด _myStructObject1 ลงในนั้น
ที่นี่. NET C # คอมไพเลอร์สร้างอีกสำเนาของวัตถุ _myStructureObject1 และ
กำหนดตำแหน่งหน่วยความจำนั้นให้กับตัวแปร MyStructure _myStructObject2

ดังนั้นการเปลี่ยนแปลงใด ๆ ก็ตามที่เราทำกับ _myStructObject1 จะไม่มีผลกับตัวแปรอื่น _myStructObject2 ประเภท MyStructrue
นั่นเป็นเหตุผลที่เราพูดว่าโครงสร้างเป็นประเภทค่า

ดังนั้นคลาสฐานทันทีสำหรับคลาสคือ Object และคลาสฐานทันทีสำหรับโครงสร้างคือ ValueType ซึ่งสืบทอดจาก Object
ชั้นเรียนจะสนับสนุนการสืบทอดในขณะที่โครงสร้างจะไม่

เราจะพูดอย่างไร
และอะไรคือเหตุผลที่อยู่เบื้องหลัง
คำตอบคือคลาส

มันอาจเป็นนามธรรมปิดผนึกคงที่และบางส่วนและไม่สามารถเป็นส่วนตัวได้รับการป้องกันและป้องกันภายใน

มีความแตกต่างพื้นฐาน 3 ประการระหว่างโครงสร้างและคลาส

1St- หน่วยความจำถูกสงวนไว้สำหรับโครงสร้างในหน่วยความจำสแต็ค (ซึ่งใกล้เคียงกับภาษาการเขียนโปรแกรม) ไม่ว่าสำหรับคลาสในหน่วยความจำสแต็กจะถูกสงวนไว้สำหรับการอ้างอิงเท่านั้นและหน่วยความจำจริงจะถูกสงวนไว้ในหน่วยความจำฮีป

2Nd - ตามโครงสร้างเริ่มต้นถือว่าเป็นสาธารณะไม่ว่าคลาสจะถือว่าเป็นส่วนตัวหรือไม่

3Rd- ไม่สามารถใช้รหัสซ้ำในโครงสร้างได้ แต่ในชั้นเรียนเราสามารถใช้รหัสเดิมซ้ำได้หลายครั้งในเวลาที่เรียกว่า inhertence