คุณใช้คลาสใน C อย่างไร [ปิด]

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

ข้อ จำกัด:

• ฉันต้องใช้ C และไม่ใช่ OOP เพราะฉันกำลังเขียนรหัสสำหรับระบบฝังตัวและคอมไพเลอร์และฐานรหัสที่มีอยู่ก่อนหน้านี้อยู่ใน C
• ไม่มีการจัดสรรหน่วยความจำแบบไดนามิกเพราะเรามีหน่วยความจำไม่เพียงพอที่จะสันนิษฐานว่าเราจะไม่หมดถ้าเราเริ่มการจัดสรรแบบไดนามิก
• คอมไพเลอร์ที่เราทำงานด้วยไม่มีปัญหากับพอยน์เตอร์ของฟังก์ชัน

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

typedef struct {
  float (*computeArea)(const ShapeClass *shape);
} ShapeClass;

float shape_computeArea(const ShapeClass *shape)
{
  return shape->computeArea(shape);
}

สิ่งนี้จะช่วยให้คุณสามารถใช้คลาสได้โดย "การสืบทอด" คลาสพื้นฐานและการใช้งานฟังก์ชันที่เหมาะสม:

typedef struct {
  ShapeClass shape;
  float width, height;
} RectangleClass;

static float rectangle_computeArea(const ShapeClass *shape)
{
  const RectangleClass *rect = (const RectangleClass *) shape;
  return rect->width * rect->height;
}

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

void rectangle_new(RectangleClass *rect)
{
  rect->width = rect->height = 0.f;
  rect->shape.computeArea = rectangle_computeArea;
}

หากคุณต้องการตัวสร้างที่แตกต่างกันคุณจะต้อง "ตกแต่ง" ชื่อฟังก์ชั่นคุณไม่สามารถมีมากกว่าหนึ่งrectangle_new()ฟังก์ชั่น:

void rectangle_new_with_lengths(RectangleClass *rect, float width, float height)
{
  rectangle_new(rect);
  rect->width = width;
  rect->height = height;
}

นี่คือตัวอย่างพื้นฐานที่แสดงการใช้งาน:

int main(void)
{
  RectangleClass r1;

  rectangle_new_with_lengths(&r1, 4.f, 5.f);
  printf("rectangle r1's area is %f units square\n", shape_computeArea(&r1));
  return 0;
}

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

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

ฉันต้องทำมันเหมือนกันเพื่อทำการบ้าน ฉันทำตามวิธีนี้:

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

ตัวอย่างง่ายๆก็คือ:

/// Queue.h
struct Queue
{
    /// members
}
typedef struct Queue Queue;

void push(Queue* q, int element);
void pop(Queue* q);
// etc.
/// 

หากคุณต้องการเพียงคลาสเดียวให้ใช้อาร์เรย์ของstructs เป็นข้อมูล "วัตถุ" และส่งต่อพอยน์เตอร์ไปยังฟังก์ชัน "สมาชิก" คุณสามารถใช้typedef struct _whatever Whateverก่อนที่จะประกาศstruct _whateverเพื่อซ่อนการใช้งานจากรหัสลูกค้า ไม่มีความแตกต่างระหว่าง "วัตถุ" และFILEวัตถุไลบรารีมาตรฐาน C

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

นอกจากนี้ยังมีหนังสือเกี่ยวกับเทคนิคในการออนไลน์นี้ใช้ได้ - เขียนโปรแกรมเชิงวัตถุมาตรฐาน ANSI C

คุณสามารถดู GOBject มันเป็นห้องสมุดระบบปฏิบัติการที่ให้วิธีการทำวัตถุอย่างละเอียด

http://library.gnome.org/devel/gobject/stable/

การเชื่อมต่อและการใช้งาน C: เทคนิคการสร้างซอฟต์แวร์ที่สามารถใช้ซ้ำได้ David R. Hanson

http://www.informit.com/store/product.aspx?isbn=0201498413

หนังสือเล่มนี้ทำงานได้อย่างยอดเยี่ยมในการครอบคลุมคำถามของคุณ มันอยู่ในซีรีส์ Addison Wesley Professional Computing

กระบวนทัศน์พื้นฐานคืออะไร:

/* for data structure foo */

FOO *myfoo;
myfoo = foo_create(...);
foo_something(myfoo, ...);
myfoo = foo_append(myfoo, ...);
foo_delete(myfoo);

ฉันจะให้ตัวอย่างง่ายๆว่า OOP ควรทำอย่างไรใน C. ฉันรู้ว่า thead นี้มาจาก 2009 แต่ต้องการเพิ่มในตอนนี้

/// Object.h
typedef struct Object {
    uuid_t uuid;
} Object;

int Object_init(Object *self);
uuid_t Object_get_uuid(Object *self);
int Object_clean(Object *self);

/// Person.h
typedef struct Person {
    Object obj;
    char *name;
} Person;

int Person_init(Person *self, char *name);
int Person_greet(Person *self);
int Person_clean(Person *self);

/// Object.c
#include "object.h"

int Object_init(Object *self)
{
    self->uuid = uuid_new();

    return 0;
}
uuid_t Object_get_uuid(Object *self)
{ // Don't actually create getters in C...
    return self->uuid;
}
int Object_clean(Object *self)
{
    uuid_free(self->uuid);

    return 0;
}

/// Person.c
#include "person.h"

int Person_init(Person *self, char *name)
{
    Object_init(&self->obj); // Or just Object_init(&self);
    self->name = strdup(name);

    return 0;
}
int Person_greet(Person *self)
{
    printf("Hello, %s", self->name);

    return 0;
}
int Person_clean(Person *self)
{
    free(self->name);
    Object_clean(self);

    return 0;
}

/// main.c
int main(void)
{
    Person p;

    Person_init(&p, "John");
    Person_greet(&p);
    Object_get_uuid(&p); // Inherited function
    Person_clean(&p);

    return 0;
}

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

ข้อตกลงนี้และการตั้งชื่อบางอย่างสำหรับฟังก์ชั่นคอนสตรัคเตอร์, destructors, การจัดสรรและการจัดสรรคืน

ในฐานะที่เป็นฟังก์ชั่นเสมือนจริงให้ใช้ตัวชี้ฟังก์ชั่นใน struct อาจมี Class_func (... ); เสื้อคลุมเกินไป สำหรับเทมเพลต (ง่าย) ให้เพิ่มพารามิเตอร์ size_t เพื่อกำหนดขนาดต้องการตัวชี้โมฆะ * หรือต้องการประเภท 'คลาส' ที่มีเพียงฟังก์ชันที่คุณสนใจ (เช่น int GetUUID (Object * self); GetUUID (& p);)

ใช้ a structเพื่อจำลองข้อมูลสมาชิกของคลาส ในแง่ของขอบเขตเมธอดคุณสามารถจำลองเมธอดส่วนตัวโดยวางต้นแบบฟังก์ชันส่วนตัวลงในไฟล์. c และฟังก์ชั่นสาธารณะในไฟล์. h

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <uchar.h>

/**
 * Define Shape class
 */
typedef struct Shape Shape;
struct Shape {
    /**
     * Variables header...
     */
    double width, height;

    /**
     * Functions header...
     */
    double (*area)(Shape *shape);
};

/**
 * Functions
 */
double calc(Shape *shape) {
        return shape->width * shape->height;
}

/**
 * Constructor
 */
Shape _Shape() {
    Shape s;

    s.width = 1;
    s.height = 1;

    s.area = calc;

    return s;
}

/********************************************/

int main() {
    Shape s1 = _Shape();
    s1.width = 5.35;
    s1.height = 12.5462;

    printf("Hello World\n\n");

    printf("User.width = %f\n", s1.width);
    printf("User.height = %f\n", s1.height);
    printf("User.area = %f\n\n", s1.area(&s1));

    printf("Made with \xe2\x99\xa5 \n");

    return 0;
};

ในกรณีของคุณประมาณที่ดีของการเรียนอาจจะเป็นที่ADT แต่ก็ยังคงไม่เหมือนเดิม

กลยุทธ์ของฉันคือ:

• กำหนดรหัสทั้งหมดสำหรับชั้นเรียนในไฟล์แยกต่างหาก
• กำหนดอินเตอร์เฟสทั้งหมดสำหรับคลาสในไฟล์ส่วนหัวแยก
• ฟังก์ชันสมาชิกทั้งหมดใช้ "ClassHandle" ซึ่งย่อมาจากชื่ออินสแตนซ์ (แทน o.foo (), เรียก foo (oHandle)
• ตัวสร้างจะถูกแทนที่ด้วยฟังก์ชั่นโมฆะ ClassInit (ClassHandle h, int x, int y, ... ) หรือ ClassHandle ClassInit (int x, int y, ... ) ขึ้นอยู่กับกลยุทธ์การจัดสรรหน่วยความจำ
• ตัวแปรสมาชิกทั้งหมดจะถูกจัดเก็บในฐานะสมาชิกของโครงสร้างแบบคงที่ในไฟล์คลาสห่อหุ้มไว้ในไฟล์ป้องกันไม่ให้ไฟล์ภายนอกเข้าถึงได้
• วัตถุถูกเก็บไว้ในอาร์เรย์ของโครงสร้างคงที่ด้านบนพร้อมที่จับที่กำหนดไว้ล่วงหน้า (มองเห็นได้ในส่วนต่อประสาน) หรือขีด จำกัด คงที่ของวัตถุที่สามารถยกตัวอย่างได้
• หากมีประโยชน์ชั้นเรียนสามารถมีฟังก์ชั่นสาธารณะที่จะวนรอบอาร์เรย์และเรียกใช้ฟังก์ชั่นของวัตถุที่สร้างอินสแตนซ์ทั้งหมด (RunAll () เรียกแต่ละ Run (oHandle)
• ฟังก์ชัน Deinit (ClassHandle h) ทำให้หน่วยความจำที่จัดสรร (ดัชนีอาร์เรย์) เป็นอิสระในกลยุทธ์การจัดสรรแบบไดนามิก

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

ดูคำตอบนี้และคำตอบนี้

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

การซ่อนข้อมูลด้วยฟังก์ชั่น get / set นั้นใช้งานง่ายใน C แต่หยุดอยู่ตรงนั้น ฉันได้เห็นหลายครั้งในสภาพแวดล้อมแบบฝังตัวและในที่สุดมันก็เป็นปัญหาการบำรุงรักษาเสมอ

เนื่องจากคุณทุกคนพร้อมมีปัญหาการบำรุงรักษาฉันจะคัดท้ายชัดเจน

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

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

คอมไพเลอร์ c ++ แรกจริง ๆ แล้วเป็นตัวประมวลผลล่วงหน้าซึ่งแปลรหัส C ++ เป็น C

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

GTK นั้นสร้างขึ้นทั้งหมดบน C และใช้แนวคิด OOP มากมาย ฉันได้อ่านซอร์สโค้ดของ GTK และมันค่อนข้างน่าประทับใจและอ่านง่ายขึ้น แนวคิดพื้นฐานคือ "คลาส" แต่ละคลาสนั้นเป็นเพียงโครงสร้างและฟังก์ชันคงที่ที่เกี่ยวข้อง ฟังก์ชั่นแบบคงที่ทุกคนยอมรับ "อินสแตนซ์" struct เป็นพารามิเตอร์ทำสิ่งที่ต้องการแล้วและส่งคืนผลลัพธ์หากจำเป็น ตัวอย่างเช่นคุณอาจมีฟังก์ชัน "GetPosition (CircleStruct obj)" ฟังก์ชั่นจะขุดผ่านโครงสร้างแยกหมายเลขตำแหน่งอาจสร้างวัตถุ PositionStruct ใหม่ติด x และ y ใน PositionStruct ใหม่แล้วส่งคืน GTK ยังใช้การสืบทอดด้วยวิธีนี้โดยการฝัง structs ภายใน structs ค่อนข้างฉลาด

คุณต้องการวิธีการเสมือนหรือไม่?

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

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

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

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

นอกจากนี้หากคุณสามารถใช้ C คุณสามารถใช้ C ++ และเรียนได้