เมื่อใดที่คุณควรใช้คลาส vs a struct ใน C ++

ในสถานการณ์ใดดีกว่าที่จะใช้structvs a classใน C ++

ความแตกต่างระหว่าง a classและ a structใน C ++ คือโครงสร้างที่มีpublicสมาชิกเริ่มต้นและฐานและคลาสมีprivateสมาชิกและฐานเริ่มต้น ทั้งการเรียนและ structs สามารถมีส่วนผสมของpublic, protectedและprivateสมาชิกสามารถใช้มรดกและสามารถมีฟังก์ชั่นสมาชิก

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

ในฐานะที่เป็นคนอื่น ๆ มีความแตกต่างจริงสองภาษาจริง:

• structค่าเริ่มต้นในการเข้าถึงสาธารณะและclassค่าเริ่มต้นในการเข้าถึงแบบส่วนตัว
• เมื่อสืบทอดให้ใช้structค่าเริ่มต้นเป็นpublicมรดกและclassค่าเริ่มต้นเป็นprivateมรดก (กระแทกแดกดันเช่นเดียวกับหลายสิ่งหลายอย่างใน C ++ ค่าเริ่มต้นคือย้อนกลับ: การpublicสืบทอดเป็นตัวเลือกที่ใช้กันทั่วไปมากกว่า แต่ผู้คนไม่ค่อยประกาศstructเพียงเพื่อประหยัดการพิมพ์publicคำหลัก ""

แต่ความแตกต่างที่แท้จริงในทางปฏิบัติคือระหว่างclass/ structที่ประกาศตัวสร้าง / destructor และที่ไม่ได้ มีการรับประกันบางอย่างสำหรับประเภท POD "ข้อมูลเก่าแก่" ซึ่งจะไม่มีผลบังคับใช้อีกต่อไปเมื่อคุณรับช่วงก่อสร้างของชั้นเรียน เพื่อให้ความแตกต่างนี้ชัดเจนคนจำนวนมากจงใจใช้เฉพาะstructสำหรับประเภท POD เท่านั้นและหากพวกเขาจะเพิ่มวิธีการใด ๆ ก็ตามให้ใช้classเอส ความแตกต่างระหว่างสองแฟรกเมนต์ด้านล่างนั้นไม่มีความหมาย:

class X
{
  public:

  // ...
};

struct X
{
  // ...
};

(อนึ่งนี่คือเธรดที่มีคำอธิบายที่ดีเกี่ยวกับความหมายของ "ประเภท POD" ที่แท้จริง: ประเภท POD ใน C ++ คืออะไร )

มีความเข้าใจผิดมากมายในคำตอบที่มีอยู่

ทั้งสองclassและstructประกาศชั้นเรียน

ใช่คุณอาจต้องจัดเรียงคำสำคัญการปรับเปลี่ยนการเข้าถึงของคุณใหม่ภายในคำจำกัดความของคลาสขึ้นอยู่กับคำหลักที่คุณใช้ในการประกาศคลาส

แต่นอกเหนือจากวากยสัมพันธ์เหตุผลเดียวที่เลือกได้มากกว่าอีกข้อคือการประชุม / สไตล์ / การตั้งค่า

บางคนชอบที่จะยึดstructคำหลักสำหรับคลาสที่ไม่มีฟังก์ชั่นสมาชิกเนื่องจากคำนิยามผลลัพธ์ "ดูเหมือนว่า" โครงสร้างที่เรียบง่ายจาก C

ในทำนองเดียวกันบางคนชอบที่จะใช้classคำหลักสำหรับชั้นเรียนที่มีฟังก์ชั่นสมาชิกและprivateข้อมูลเพราะมันบอกว่า "ระดับ" ในนั้นและดูเหมือนว่าตัวอย่างจากหนังสือเล่มโปรดของพวกเขาในการเขียนโปรแกรมเชิงวัตถุ

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

สองคลาสต่อไปนี้มีความเท่าเทียมกันทุกประการยกเว้นชื่อ:

struct Foo
{
   int x;
};

class Bar
{
public:
   int x;
};

คุณสามารถเปลี่ยนคำค้นหาเมื่อทำการประกาศใหม่:

class Foo;
struct Bar;

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

และนิพจน์ต่อไปนี้ทั้งคู่ประเมินว่าเป็นจริง:

std::is_class<Foo>::value
std::is_class<Bar>::value

ทำบันทึกได้ว่าคุณไม่สามารถเปลี่ยนคำหลักเมื่อกําหนด ; นี้เป็นเพียงเพราะ (ต่อกฎหนึ่งนิยาม) นิยามคลาสที่ซ้ำกันในหน่วยการแปลต้อง"ประกอบด้วยลำดับเดียวกันของสัญญาณ" ซึ่งหมายความว่าคุณไม่สามารถได้แลกเปลี่ยนconst int member;ด้วยint const member;และมีอะไรจะทำอย่างไรกับความหมายของหรือclassstruct

ครั้งเดียวที่ฉันใช้ struct แทนคลาสคือเมื่อประกาศ functor ก่อนที่จะใช้ในการเรียกใช้ฟังก์ชั่นและต้องการลดไวยากรณ์ให้น้อยที่สุดเพื่อความชัดเจน เช่น:

struct Compare { bool operator() { ... } };
std::sort(collection.begin(), collection.end(), Compare()); 

จากC ++ FAQ Lite :

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

struct และคลาสนั้นมีหน้าที่เทียบเท่ากัน

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

ที่เดียวที่ struct มีประโยชน์สำหรับฉันคือเมื่อฉันมีระบบที่ได้รับข้อความจัดรูปแบบคงที่ (over say, serial port) จากระบบอื่น คุณสามารถส่งกระแสข้อมูลไบต์ลงในโครงสร้างที่กำหนดเขตข้อมูลของคุณและเข้าถึงเขตข้อมูลได้อย่างง่ายดาย

typedef struct
{
    int messageId;
    int messageCounter;
    int messageData;
} tMessageType;

void processMessage(unsigned char *rawMessage)
{
    tMessageType *messageFields = (tMessageType *)rawMessage;
    printf("MessageId is %d\n", messageFields->messageId);
}

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

คุณสามารถใช้ "struct" ใน C ++ หากคุณกำลังเขียนไลบรารีที่มี internals เป็น C ++ แต่ API สามารถเรียกได้ด้วยรหัส C หรือ C ++ คุณเพียงแค่สร้างส่วนหัวเดียวที่มีฟังก์ชั่น structs และ API ระดับโลกที่คุณเปิดเผยให้ทั้งรหัส C และ C ++ ดังนี้:

// C access Header to a C++ library
#ifdef __cpp
extern "C" {
#endif

// Put your C struct's here
struct foo
{
    ...
};
// NOTE: the typedef is used because C does not automatically generate
// a typedef with the same name as a struct like C++.
typedef struct foo foo;

// Put your C API functions here
void bar(foo *fun);

#ifdef __cpp
}
#endif

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

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

struct myvec {
    int x;
    int y;
    int z;

    int length() {return x+y+z;}
};

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

ฉันมักจะใช้ struct สำหรับเก็บข้อมูลเท่านั้น ฉันจะอนุญาตให้ใช้ฟังก์ชันตัวช่วยสองสามอย่างถ้ามันทำให้การทำงานกับข้อมูลง่ายขึ้น อย่างไรก็ตามทันทีที่ข้อมูลต้องการการควบคุมการไหล (เช่นตัวรับ / ตัวตั้งค่าที่รักษาหรือปกป้องสถานะภายใน) หรือเริ่มรับฟังก์ชั่นที่สำคัญใด ๆ (โดยทั่วไปคล้ายกับวัตถุมากขึ้น) มันจะได้รับ

Structs ( PODs , โดยทั่วไป) มีประโยชน์เมื่อคุณมีอินเตอร์เฟสที่ใช้งานร่วมกับ C ได้ซึ่งมีการติดตั้ง C ++ เนื่องจากพวกมันพกพาข้ามพรมแดนภาษาและรูปแบบลิงเกอร์

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

Structs ยังมีประโยชน์สำหรับงาน metaprogramming ต่างๆเช่นเทมเพลตคุณลักษณะที่เพิ่งพิมพ์กลุ่มของการพิมพ์ที่ขึ้นอยู่กับ:

template <typename T> struct type_traits {
  typedef T type;
  typedef T::iterator_type iterator_type;
  ...
};

... แต่นั่นเป็นเพียงการใช้ประโยชน์จากระดับการป้องกันเริ่มต้นของ struct เป็นสาธารณะ ...

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

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

พวกมันค่อนข้างเหมือนกัน ด้วยความมหัศจรรย์ของ C ++ ทำให้โครงสร้างสามารถเก็บฟังก์ชันใช้การสืบทอดสร้างโดยใช้ "ใหม่" และอื่น ๆ เช่นเดียวกับคลาส

ความแตกต่างด้านการใช้งานเพียงอย่างเดียวคือคลาสเริ่มต้นด้วยสิทธิ์การเข้าถึงส่วนตัวในขณะที่โครงสร้างเริ่มต้นด้วยสาธารณะ นี่คือการรักษาความเข้ากันได้ย้อนหลังกับ C.

ในทางปฏิบัติฉันมักจะใช้ structs เป็นผู้ถือข้อมูลและคลาสเป็นวัตถุ

ตามที่คนอื่น ๆ ได้ชี้ให้เห็น

• ทั้งสองมีความเท่าเทียมกันนอกเหนือจากการมองเห็นเริ่มต้น
• อาจมีเหตุผลที่จะถูกบังคับให้ใช้อย่างใดอย่างหนึ่งด้วยเหตุผลใดก็ตาม

มีคำแนะนำที่ชัดเจนเกี่ยวกับเวลาที่ใช้จาก Stroustrup / Sutter:

ใช้คลาสถ้าคลาสมีค่าคงที่ ใช้ struct ถ้าสมาชิกข้อมูลสามารถแตกต่างกันอย่างอิสระ

อย่างไรก็ตามโปรดทราบว่าไม่ควรส่งต่อ sth เป็นคลาส ( class X;) และกำหนดเป็น struct ( struct X { ... }) มันอาจทำงานกับลิงเกอร์บางตัว (เช่น g ++) และอาจล้มเหลวกับลิงค์อื่น ๆ (เช่น MSVC) ดังนั้นคุณจะพบว่าตัวเองอยู่ในนรกนักพัฒนา

ชั้น

สมาชิกของคลาสจะเป็นส่วนตัวโดยค่าเริ่มต้น

class test_one {
    int main_one();
};

มีค่าเท่ากับ

class test_one {
  private:
    int main_one();
};

ดังนั้นหากคุณลอง

int two = one.main_one();

เราจะได้รับข้อผิดพลาด: main_one is privateเพราะมันไม่สามารถเข้าถึงได้ เราสามารถแก้ปัญหาได้โดยเริ่มต้นด้วยการระบุสาธารณะเช่น

class test_one {
  public:
    int main_one();
};

โครงสร้าง

struct คือคลาสที่สมาชิกเป็นแบบสาธารณะโดยค่าเริ่มต้น

struct test_one {
    int main_one;
};

หมายถึงmain_oneเป็นส่วนตัวเช่น

class test_one {
  public:
    int main_one;
};

ฉันใช้ structs สำหรับโครงสร้างข้อมูลที่สมาชิกสามารถรับค่าใด ๆ ได้ง่ายกว่านั้น

ข้อได้เปรียบของstructover classคือการบันทึกรหัสหนึ่งบรรทัดหากยึดมั่นใน "สมาชิกสาธารณะคนแรกแล้วส่วนตัว" ในแง่นี้ฉันพบว่าคำหลักclassไร้ประโยชน์

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

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

มันเป็นสิ่งเดียวกันกับค่าเริ่มต้นที่แตกต่างกัน (ส่วนตัวโดยค่าเริ่มต้นสำหรับclassและสาธารณะโดยค่าเริ่มต้นสำหรับstruct) ดังนั้นในทางทฤษฎีพวกเขาสามารถใช้แทนกันได้อย่างสมบูรณ์

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

โครงสร้างโดยค่าเริ่มต้นมีการเข้าถึงสาธารณะและคลาสโดยค่าเริ่มต้นมีการเข้าถึงแบบส่วนตัว

ส่วนตัวผมใช้ structs สำหรับ Data Transfer Objects หรือ Value Objects เมื่อใช้ฉันจะประกาศสมาชิกทั้งหมดว่าเป็น const เพื่อป้องกันการแก้ไขด้วยรหัสอื่น

ทั้งสองstructและclassเหมือนกันภายใต้ประทุนแม้ว่าจะมีค่าเริ่มต้นแตกต่างกันไปสำหรับการมองเห็นstructค่าเริ่มต้นคือสาธารณะและclassค่าเริ่มต้นเป็นแบบส่วนตัว คุณสามารถเปลี่ยนคนใดคนหนึ่งจะเป็นอื่น ๆ ที่มีการใช้งานที่เหมาะสมและprivate publicพวกเขาทั้งสองอนุญาตให้สืบทอดวิธีการก่อสร้างคอนสตรัคเตอร์และส่วนที่เหลือทั้งหมดของสินค้าของภาษาเชิงวัตถุ

อย่างไรก็ตามสิ่งที่แตกต่างกันอย่างมากระหว่างสองคือว่าstructเป็นคำหลักที่ได้รับการสนับสนุนใน C ในขณะที่classไม่ได้ ซึ่งหมายความว่าสามารถใช้structในรวมไฟล์ที่สามารถ#includeเข้าไปในทั้ง C ++ หรือ C ตราบเท่าที่structเป็นรูปแบบธรรมดา C structและทุกสิ่งทุกอย่างในแฟ้มรวมเข้ากันได้กับ C คือไม่มี c ++ คำหลักที่เฉพาะเจาะจงเช่นprivate, publicไม่มี วิธีการไม่มีมรดก ฯลฯ ฯลฯ ฯลฯ

AC style structสามารถใช้กับอินเตอร์เฟสอื่น ๆ ที่รองรับการใช้ C style structเพื่อนำข้อมูลไปมาผ่านทางอินเตอร์เฟส

AC style structเป็นเทมเพลตชนิดหนึ่ง (ไม่ใช่เท็มเพลต C ++ แต่เป็นรูปแบบหรือ stencil) ที่อธิบายโครงร่างของพื้นที่หน่วยความจำ กว่าปีที่อินเตอร์เฟซที่ใช้งานได้จาก C และ C ปลั๊กอิน (ที่นี่ที่มองหาที่คุณ Java และ Python และ Visual Basic) structได้รับการสร้างบางส่วนของที่ทำงานที่มีสไตล์

ในทางเทคนิคทั้งสองจะเหมือนกันใน C ++ - ตัวอย่างเช่นเป็นไปได้ที่ struct จะมีตัวดำเนินการมากเกินไปเป็นต้น

อย่างไรก็ตาม:

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

หวังว่ามันจะช่วย

#include <string>
#include <map>
using namespace std;

struct student
{
    int age;
    string name;
    map<string, int> grades
};

class ClassRoom
{
    typedef map<string, student> student_map;
  public :
    student getStudentByName(string name) const 
    { student_map::const_iterator m_it = students.find(name); return m_it->second; }
  private :
    student_map students;
};

ตัวอย่างเช่นฉันกลับนักเรียน struct ในการรับ ...

คุณจะเลือกใช้ struct เมื่อใดและควรใช้คลาสใดใน C ++

ผมใช้structเมื่อฉันกำหนดและfunctors มิฉะนั้นการใช้งานผมPODclass

// '()' is public by default!
struct mycompare : public std::binary_function<int, int, bool>
{
    bool operator()(int first, int second)
    { return first < second; }
};

class mycompare : public std::binary_function<int, int, bool>
{
public:
    bool operator()(int first, int second)
    { return first < second; }
};

ฉันใช้ structs เมื่อฉันต้องการสร้างประเภท POD หรือ functor

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

ฉันใช้ struct เฉพาะเมื่อฉันต้องการเก็บข้อมูลบางอย่างโดยไม่มีฟังก์ชั่นสมาชิกใด ๆ ที่เกี่ยวข้อง (เพื่อดำเนินการกับข้อมูลสมาชิก) และเข้าถึงตัวแปรข้อมูลโดยตรง

เช่นการอ่าน / เขียนข้อมูลจากไฟล์และสตรีมซ็อกเก็ตเป็นต้นการส่งผ่านอาร์กิวเมนต์ของฟังก์ชันในโครงสร้างที่อาร์กิวเมนต์ของฟังก์ชันมีมากเกินไปและไวยากรณ์ของฟังก์ชันดูยาวเกินไป

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

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

:(

ฉันไม่เคยใช้ "struct" ใน C ++

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

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

เช่น

class PublicInputData {
    //data members
 };