C 클래스를 어떻게 구현합니까? [닫은]

C (C ++ 또는 객체 지향 컴파일러 없음)를 사용해야하고 동적 메모리 할당이 없다고 가정하면 클래스를 구현하는 데 사용할 수있는 기술이나 클래스의 근사값은 무엇입니까? "클래스"를 별도의 파일로 분리하는 것이 항상 좋은 생각입니까? 고정 된 수의 인스턴스를 가정하거나 컴파일 시간 전에 각 객체에 대한 참조를 상수로 정의하여 메모리를 사전 할당 할 수 있다고 가정하십시오. 구현해야 할 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에서 성공적이고 풍부한 객체 지향 프레임 워크를 보려면 glib의 GObject 라이브러리를 살펴보십시오 .

또한 위에서 모델링 한 명시적인 "클래스"가 없으며 각 객체에는 일반적으로 C ++에서 찾을 수있는 것보다 약간 더 유연한 고유 한 메서드 포인터가 있습니다. 또한 메모리 비용이 듭니다. class구조체 에서 메서드 포인터를 채워서 각 개체 인스턴스가 클래스를 참조 할 수있는 방법을 만들어서 그로부터 벗어날 수 있습니다 .

숙제도 한 번해야 했어요. 나는이 접근법을 따랐다.

1. 구조체에서 데이터 멤버를 정의하십시오.
2. 구조체에 대한 포인터를 첫 번째 인수로 사용하는 함수 멤버를 정의하십시오.
3. 하나의 헤더와 하나의 c 에서이 작업을 수행하십시오. 구조체 정의 및 함수 선언을위한 헤더, 구현을위한 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하기 전에 사용할 수 있습니다 . 이러한 "객체"와 C 표준 라이브러리 사이에는 차이가 없습니다FILE 객체 .

상속과 가상 함수를 가진 클래스를 두 개 이상 원한다면 구조체의 멤버로 함수에 대한 포인터 또는 가상 함수 테이블에 대한 공유 포인터를 갖는 것이 일반적입니다. G 객체의 라이브러리는 모두 이것과 타입 정의의 트릭을 사용하고 널리 사용된다.

ANSI C를 이용한 온라인 객체 지향 프로그래밍 에 대한 기술에 관한 책도 있습니다 .

GOBject를 살펴볼 수 있습니다. 객체를 수행하는 자세한 방법을 제공하는 OS 라이브러리입니다.

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);

나는 C에서 OOP가 어떻게 수행되어야하는지에 대한 간단한 예를 제시 할 것이다. 나는이 주제가 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 바이트에 액세스하면 '상속 된 클래스'의 처음 4 바이트에도 액세스합니다 (미친 최적화 가정). 이제 구조체의 포인터가 '상속 된 클래스'로 캐스트되면 '상속 된 클래스'는 정상적으로 멤버에 액세스하는 것과 같은 방식으로 '상속 된 값'에 액세스 할 수 있습니다.

생성자, 소멸자, 할당 및 할당 해제 함수 (init, clean, new, free 권장)에 대한 이것과 일부 명명 규칙은 먼 길을 갈 것입니다.

가상 함수의 경우 구조체에서 함수 포인터를 사용하십시오 (Class_func (...); 래퍼도. (간단한) 템플릿의 경우 size_t 매개 변수를 추가하여 크기를 결정하거나 void * 포인터가 필요하거나 관심있는 기능 만있는 '클래스'유형이 필요합니다. (예 : 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) 호출
• 생성자는 메모리 할당 전략에 따라 void ClassInit (ClassHandle h, int x, int y, ...) 또는 ClassHandle ClassInit (int x, int y, ...) 함수로 대체됩니다.
• 모든 멤버 변수는 클래스 파일에 정적 구조체의 멤버로 저장되어 파일에 캡슐화되어 외부 파일이 액세스하지 못하게합니다.
• 객체는 사전 정의 된 핸들 (인터페이스에 표시) 또는 인스턴스화 할 수있는 고정 된 객체 제한과 함께 위의 정적 구조체 배열에 저장됩니다.
• 유용한 경우 클래스는 배열을 반복하고 모든 인스턴스화 된 객체의 함수를 호출하는 공용 함수를 포함 할 수 있습니다 (RunAll ()은 각 Run (oHandle)을 호출합니다.
• Deinit (ClassHandle h) 함수는 동적 할당 전략에서 할당 된 메모리 (배열 색인)를 해제합니다.

이 접근 방식의 변형으로 인한 문제점, 허점, 잠재적 함정 또는 숨겨진 이점 / 단점을 아는 사람이 있습니까? 디자인 방법을 재발 명하고 있어야한다고 생각한다면 그 이름을 알려 주시겠습니까?

또한 볼 이 답변 하고 이 일을

것이 가능하다. 그것은 항상 좋은 생각처럼 보이지만 나중에는 유지 보수의 악몽이됩니다. 코드가 모든 것을 묶는 코드 조각으로 가득 차 있습니다. 함수 포인터를 사용하면 어떤 함수가 호출되는지 명확하지 않기 때문에 새로운 프로그래머는 코드를 읽고 이해하는 데 많은 문제가 있습니다.

get / set 함수를 사용한 데이터 숨기기는 C에서 구현하기 쉽지만 중지하십시오. 임베디드 환경에서 여러 번 시도했지만 결국 유지 관리 문제입니다.

모든 유지 보수 문제가 있으므로 준비를 분명히해야합니다.

내 접근 방식은 주로 관련된struct 모든 것을 이동하는 것입니다 기능을 별도의 소스 파일 "휴대용"으로 사용할 수 있도록하는 것입니다.

컴파일러에 따라 수도 에 기능을 포함 할 수 struct있지만,이 A의 매우 컴파일러 특정 확장하고, 일상적으로 사용되는 표준 I의 마지막 버전과는 아무 상관이 없습니다 :)

첫 번째 c ++ 컴파일러는 실제로 C ++ 코드를 C로 변환 한 전 처리기였습니다.

따라서 C로 클래스를 가질 수 있습니다. 오래된 C ++ 전처리기를 파헤쳐 서 어떤 종류의 솔루션을 만드는지 알아볼 수 있습니다.

GTK는 전적으로 C를 기반으로하며 많은 OOP 개념을 사용합니다. GTK의 소스 코드를 읽었으며 꽤 인상적이며 읽기 쉽습니다. 기본 개념은 각 "클래스"가 단순한 구조체 및 관련 정적 함수라는 것입니다. 정적 함수는 모두 "인스턴스"구조체를 매개 변수로 받아들이고 필요한 모든 작업을 수행하며 필요한 경우 결과를 반환합니다. 예를 들어 "GetPosition (CircleStruct obj)"기능이있을 수 있습니다. 이 함수는 단순히 구조체를 파고, 위치 번호를 추출하고, 새로운 PositionStruct 객체를 만들고, 새 PositionStruct에 x와 y를 붙이고 반환합니다. GTK는 구조체 안에 구조체를 삽입하여 이런 식으로 상속을 구현합니다. 꽤 영리합니다.

가상 방법을 원하십니까?

그렇지 않으면 구조체 자체에 함수 포인터 세트를 정의하기 만하면됩니다. 모든 함수 포인터를 표준 C 함수에 할당하면 C ++에서와 유사한 구문으로 C에서 함수를 호출 할 수 있습니다.

가상 메소드를 원하면 더 복잡해집니다. 기본적으로 각 구조체에 고유 한 VTable을 구현하고 호출되는 함수에 따라 VTable에 함수 포인터를 할당해야합니다. 그런 다음 구조체 자체에 VTable의 함수 포인터를 호출하는 함수 포인터 세트가 필요합니다. 이것은 본질적으로 C ++의 기능입니다.

TBH 그러나 ... 후자를 원한다면 프로젝트를 사용하고 다시 컴파일 할 수있는 C ++ 컴파일러를 찾는 것이 좋습니다. 나는 C ++에 대한 집착이 임베디드에서 사용할 수 없다는 것을 결코 이해하지 못했습니다. 나는 그것을 한 번에 많이 사용했으며 작동 속도가 빠르고 메모리 문제가 없습니다. 물론 당신이하는 일에 대해 조금 더 조심해야하지만 실제로 그렇게 복잡하지는 않습니다.

C는 OOP 언어가 아니기 때문에 올바른 클래스를 작성하는 기본 방법은 없습니다. 가장 좋은 방법은 구조체 와 함수 포인터 를 보는 것입니다.이 클래스를 사용하면 대략적인 클래스를 만들 수 있습니다. 그러나 C가 절차 적이므로 더 많은 C와 같은 코드를 작성하는 것이 좋습니다 (예 : 클래스를 사용하지 않고).

또한 C를 사용할 수 있다면 C ++을 사용하고 클래스를 얻을 수 있습니다.