ทำไมฟังก์ชั่นมากมายที่ส่งกลับโครงสร้างใน C จริง ๆ แล้วส่งกลับพอยน์เตอร์ไปยังโครงสร้าง

ข้อดีของการส่งกลับตัวชี้ไปยังโครงสร้างต่างจากการส่งคืนโครงสร้างทั้งหมดในreturnคำสั่งของฟังก์ชันคืออะไร

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

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

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

การคืนโครงสร้างที่เต็มไปด้วยความNULLยากลำบากฉันคิดว่าหรือมีประสิทธิภาพน้อยกว่า นี่เป็นเหตุผลที่ถูกต้องหรือไม่

มีเหตุผลเชิงปฏิบัติหลายประการว่าทำไมฟังก์ชั่นเช่นพfopenอยน์เตอร์พอยน์เตอร์ถึงแทนที่จะเป็นอินสแตนซ์structประเภท:

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

ในกรณีที่มีประเภทเช่นFILE *นั้นเป็นเพราะคุณไม่ต้องการเปิดเผยรายละเอียดเกี่ยวกับการเป็นตัวแทนของผู้ใช้ประเภท - FILE *วัตถุทำหน้าที่เป็นตัวจัดการทึบแสงและคุณเพิ่งผ่านหมายเลขอ้างอิงนั้นไปยังรูทีน I / O ต่างๆ (และFILEบ่อยครั้ง ใช้งานเป็นstructประเภทไม่จำเป็นต้องมี )

ดังนั้นคุณสามารถแสดงประเภทที่ไม่สมบูรณ์ structในส่วนหัวบางแห่ง:

typedef struct __some_internal_stream_implementation FILE;

ในขณะที่คุณไม่สามารถประกาศอินสแตนซ์ของชนิดที่ไม่สมบูรณ์คุณสามารถประกาศตัวชี้ ดังนั้นผมจึงสามารถสร้างFILE *และกำหนดให้มันผ่านfopen, freopenฯลฯ แต่ผมไม่สามารถจัดการกับวัตถุที่จะชี้ไปที่

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

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

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

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

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

นอกจากคำตอบอื่น ๆ บางครั้งการคืนค่าเล็กน้อย structก็คุ้มค่า ตัวอย่างเช่นหนึ่งสามารถส่งคืนข้อมูลหนึ่งคู่และรหัสข้อผิดพลาด (หรือความสำเร็จ) ที่เกี่ยวข้องกับข้อมูลนั้น

ในการรับตัวอย่างfopenส่งคืนข้อมูลเพียงหนึ่งตัว (เปิดFILE*) และในกรณีที่มีข้อผิดพลาดให้รหัสข้อผิดพลาดผ่านerrnoตัวแปรหลอกส่วนกลาง แต่มันอาจจะดีกว่าถ้าส่งคืนstructสมาชิกสองคน: FILE*หมายเลขอ้างอิงและรหัสข้อผิดพลาด (ซึ่งจะถูกตั้งค่าหากหมายเลขอ้างอิงไฟล์เป็นNULL) ด้วยเหตุผลทางประวัติศาสตร์ไม่ใช่กรณี (และมีการรายงานข้อผิดพลาดerrnoทั่วโลกซึ่งวันนี้เป็นมาโคร)

ขอให้สังเกตว่าภาษาโกมีสัญกรณ์ที่ดีในการส่งคืนค่าสอง (หรือสองสาม)

โปรดสังเกตว่าบน Linux / x86-64 ABIและการเรียกการประชุม (ดูหน้าx86-psABI ) ระบุว่าstructสมาชิกสเกลาร์สองคน (เช่นตัวชี้และจำนวนเต็มหรือตัวชี้สองตัวหรือจำนวนเต็มสองตัว) จะถูกส่งคืนผ่านรีจิสเตอร์สองตัว (และนี่มีประสิทธิภาพมากและไม่ผ่านหน่วยความจำ)

ดังนั้นในรหัส C ใหม่การคืนค่า C ขนาดเล็กstructสามารถอ่านได้ง่ายขึ้นเป็นมิตรกับเธรดและมีประสิทธิภาพมากขึ้น

คุณมาถูกทางแล้ว

ทั้งเหตุผลที่คุณกล่าวถึงนั้นถูกต้อง:

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

การส่งคืนโครงสร้างแบบเต็มที่เป็นค่า NULL นั้นยากกว่าที่คิดหรือมีประสิทธิภาพน้อยกว่า นี่เป็นเหตุผลที่ถูกต้องหรือไม่

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

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

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

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

ในความคิดเห็นฉันเห็นว่ามีคำถามว่าคุณสามารถคืนค่า struct จากฟังก์ชันได้หรือไม่ คุณสามารถทำสิ่งนี้ได้แน่นอน ต่อไปนี้ควรทำงาน:

struct s1 {
   int integer;
};

struct s1 f(struct s1 input){
   struct s1 returnValue = xinput
   return returnValue;
}

int main(void){
   struct s1 a = { 42 };
   struct s1 b= f(a);

   return 0;
}

บางอย่างเช่น a FILE*ไม่ใช่ตัวชี้ไปยังโครงสร้างที่เกี่ยวข้องกับรหัสลูกค้า แต่เป็นรูปแบบของตัวระบุทึบแสงที่เกี่ยวข้องกับเอนทิตีอื่น ๆเช่นไฟล์ เมื่อโปรแกรมเรียกfopenใช้โดยทั่วไปจะไม่สนใจเกี่ยวกับเนื้อหาใด ๆ ของโครงสร้างที่ส่งคืน - สิ่งที่มันจะสนใจก็คือฟังก์ชั่นอื่น ๆ เช่นfreadจะทำสิ่งที่พวกเขาต้องการจะทำกับมัน

หากไลบรารีมาตรฐานเก็บไว้ในFILE*ข้อมูลเกี่ยวกับเช่นตำแหน่งการอ่านปัจจุบันภายในไฟล์นั้นการเรียกไปยังfreadจะต้องสามารถอัปเดตข้อมูลนั้นได้ ต้องfreadได้รับตัวชี้ไปที่FILEทำให้ง่าย หากfreadได้รับ a แทนFILEจะไม่มีวิธีอัปเดตFILEออบเจกต์ที่ถือโดยผู้โทร

การซ่อนข้อมูล

ข้อดีของการส่งกลับตัวชี้ไปยังโครงสร้างต่างจากการส่งคืนโครงสร้างทั้งหมดในคำสั่ง return ของฟังก์ชันคืออะไร

หนึ่งที่พบมากที่สุดคือที่หลบซ่อนข้อมูล C ไม่ได้พูดความสามารถในการสร้างเขตข้อมูลของstructส่วนตัวให้คนเดียวให้วิธีการในการเข้าถึงพวกเขา

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

ความเข้ากันได้ไบนารี

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

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

อย่างมีประสิทธิภาพ

การคืนโครงสร้างที่เป็น NULL นั้นยากขึ้นฉันคิดว่าหรือมีประสิทธิภาพน้อยกว่า นี่เป็นเหตุผลที่ถูกต้องหรือไม่

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

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

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

ฮอตสปอตและการแก้ไข

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

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

struct Foo
{
   /* priv_* indicates that you shouldn't tamper with these fields! */
   int priv_internal_field;
   int priv_other_one;
};

struct Foo foo_create(void);
void foo_destroy(struct Foo* foo);
void foo_something(struct Foo* foo);

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

struct Foo
{
   /* priv_* indicates that you shouldn't tamper with these fields! */
   int priv_internal_field;
   int priv_other_one;

   /* reserved for possible future uses (emergency backup plan).
     currently just set to null. */
   void* priv_reserved;
};

พื้นที่สงวนนั้นค่อนข้างสิ้นเปลือง แต่สามารถช่วยชีวิตหากเราพบในอนาคตที่เราต้องการเพิ่มข้อมูลเพิ่มเติมFooโดยไม่ทำลายไบนารีที่ใช้ห้องสมุดของเรา

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

int foo_create(struct Foo* foo);
...
/* In the client code: */
struct Foo foo;
if (foo_create(&foo))
{
    foo_something(&foo);
    foo_destroy(&foo);
}

... เพื่อเริ่มต้นFooจากสแต็กโดยไม่มีความเป็นไปได้ของสำเนาฟุ่มเฟือย หรือลูกค้ายังมีอิสระที่จะจัดสรรFooบนกองหากพวกเขาต้องการด้วยเหตุผลบางอย่าง