ฉันควรเริ่มต้น C structs ผ่านพารามิเตอร์หรือโดยค่าตอบแทน? [ปิด]

บริษัท ที่ฉันทำงานอยู่นั้นกำลังเริ่มต้นโครงสร้างข้อมูลทั้งหมดผ่านฟังก์ชันเตรียมใช้งานเช่น:

//the structure
typedef struct{
  int a,b,c;  
} Foo;

//the initialize function
InitializeFoo(Foo* const foo){
   foo->a = x; //derived here based on other data
   foo->b = y; //derived here based on other data
   foo->c = z; //derived here based on other data
}

//initializing the structure  
Foo foo;
InitializeFoo(&foo);

ฉันได้รับแรงผลักดันบางอย่างพยายามเริ่มต้นโครงสร้างของฉันเช่นนี้:

//the structure
typedef struct{
  int a,b,c;  
} Foo;

//the initialize function
Foo ConstructFoo(int a, int b, int c){
   Foo foo;
   foo.a = a; //part of parameter input (inputs derived outside of function)
   foo.b = b; //part of parameter input (inputs derived outside of function)
   foo.c = c; //part of parameter input (inputs derived outside of function)
   return foo;
}

//initialize (or construct) the structure
Foo foo = ConstructFoo(x,y,z);

มีข้อได้เปรียบอย่างใดอย่างหนึ่งมากกว่าที่อื่น ๆ ?
ฉันควรทำสิ่งใดและฉันจะทำให้มันเป็นแนวปฏิบัติที่ดีขึ้นได้อย่างไร

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

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

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

ทั้งสองวิธีจะรวมรหัสการเริ่มต้นไว้ในการเรียกใช้ฟังก์ชันเดียว จนถึงตอนนี้ดีมาก

อย่างไรก็ตามมีสองประเด็นเกี่ยวกับวิธีที่สอง:

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

   สิ่งนี้ยิ่งแย่ลงเมื่อคุณได้รับคลาสDerivedจากFoo(structs ส่วนใหญ่ใช้สำหรับการวางแนววัตถุใน C): ด้วยวิธีที่สองฟังก์ชันConstructDerived()จะเรียกใช้ConstructFoo()คัดลอกFooวัตถุชั่วคราวที่เป็นผลลัพธ์ลงในสล็อตซูเปอร์Derivedคลาสของวัตถุ เสร็จสิ้นการเริ่มต้นของDerivedวัตถุนั้น เพียงเพื่อให้วัตถุที่เป็นผลลัพธ์ถูกคัดลอกมาอีกครั้งเมื่อกลับมา เพิ่มเลเยอร์ที่สามและสิ่งทั้งหมดกลายเป็นเรื่องไร้สาระอย่างสมบูรณ์

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

ในที่สุดไม่ได้ทั้งหมดstructsเป็นชั้นเรียนที่เต็มเปี่ยม บางstructsอย่างมีประสิทธิภาพเพียงรวมกลุ่มของตัวแปรเข้าด้วยกันโดยไม่มีข้อ จำกัด ภายในกับค่าของตัวแปรเหล่านี้ typedef struct Point { int x, y; } Point;จะเป็นตัวอย่างที่ดีของสิ่งนี้ สำหรับการใช้งานฟังก์ชั่นการเริ่มต้นเหล่านี้ดูเหมือนจะเกินความจริง ในกรณีเหล่านี้ไวยากรณ์ตัวอักษรผสมอาจสะดวก (เป็น C99):

Point = { .x = 7, .y = 9 };

หรือ

Point foo(...) {
    //other stuff

    return (Point){ .x = n, .y = n*n };
}

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

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

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

อาร์กิวเมนต์หนึ่งที่สนับสนุนรูปแบบ "พารามิเตอร์เอาต์พุต" คืออนุญาตให้ฟังก์ชันส่งคืนรหัสข้อผิดพลาด

struct MyStruct {
    int x;
    char *y;
    // ...
};

int MyStruct_init(struct MyStruct *out) {
    // ...
    char *c = malloc(n);
    if (!c) {
        return -1;
    }
    out->y = c;
    return 0;  // Success!
}

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

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

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