C의 함수 포인터를 사용하여 C에서 객체 지향 프로그래밍을 수행 할 수 있습니다.

예를 들어 다음 줄은 C로 작성됩니다.

String s1 = newString();
s1->set(s1, "hello");

그렇습니다. ->그리고 new연산자 의 부족은 죽은 것입니다. 그러나 우리가 어떤 String클래스 의 텍스트를로 설정한다는 것을 의미 합니다 "hello".

함수 포인터를 사용 하면 C의 메소드를 에뮬레이트 할 수 있습니다 .

이것이 어떻게 이루어 집니까?

String클래스는 사실이다 struct시뮬레이션 방법에 대한 방법으로 역할을 함수 포인터의 무리와 함께. 다음은 String클래스 의 부분 선언입니다 .

typedef struct String_Struct* String;

struct String_Struct
{
    char* (*get)(const void* self);
    void (*set)(const void* self, char* value);
    int (*length)(const void* self);
};

char* getString(const void* self);
void setString(const void* self, char* value);
int lengthString(const void* self);

String newString();

보다시피, String클래스 의 메소드 는 실제로 선언 된 함수에 대한 함수 포인터입니다. 인스턴스의 제조에서 String의 newString기능들은 각각의 기능에 대한 함수 포인터를 설정하기 위해 호출된다 :

String newString()
{
    String self = (String)malloc(sizeof(struct String_Struct));

    self->get = &getString;
    self->set = &setString;
    self->length = &lengthString;

    self->set(self, "");

    return self;
}

예를 들어, 메소드 getString를 호출하여 호출되는 get함수는 다음과 같이 정의됩니다.

char* getString(const void* self_obj)
{
    return ((String)self_obj)->internal->value;
}

주목할 수있는 것은 객체의 인스턴스에 대한 개념이없고 실제로 객체의 일부인 메소드를 가지므로 각 호출마다 “자체 객체”를 전달해야한다는 것입니다. (그리고 internal앞 struct의 코드 목록에서 생략 된 것은 숨겨져 있습니다. 정보 숨기기를 수행하는 방법이지만 함수 포인터와 관련이 없습니다.)

따라서 할 수있는 것이 아니라 s1->set("hello");객체를 전달하여에 대한 작업을 수행해야합니다 s1->set(s1, "hello").

그 작은 설명이 방해가되지 않는 자신을 언급해야하므로 다음 부분으로 넘어갑니다 .C의 상속입니다 .

하자 우리의 서브 클래스를 만들고 싶어 말을 String을 말한다 ImmutableString. 문자열을 변경할 수 없도록하기 위해 and에 set대한 액세스를 유지 하면서이 메소드에 액세스 할 수 없으며 “생성자”가 다음을 승인하도록합니다 .getlengthchar*

typedef struct ImmutableString_Struct* ImmutableString;

struct ImmutableString_Struct
{
    String base;

    char* (*get)(const void* self);
    int (*length)(const void* self);
};

ImmutableString newImmutableString(const char* value);

기본적으로 모든 서브 클래스에서 사용 가능한 메소드는 다시 함수 포인터입니다. 이번에는 set메소드에 대한 선언 이 없으므로에서 호출 할 수 없습니다 ImmutableString.

의 구현과 ImmutableString관련하여 유일한 관련 코드는 “생성자”함수입니다 newImmutableString.

ImmutableString newImmutableString(const char* value)
{
    ImmutableString self = (ImmutableString)malloc(sizeof(struct ImmutableString_Struct));

    self->base = newString();

    self->get = self->base->get;
    self->length = self->base->length;

    self->base->set(self->base, (char*)value);

    return self;
}

를 인스턴스화 ImmutableString할 때 getand length메소드에 대한 함수 포인터는 실제로 내부에 저장된 객체 인 변수를 통해 String.getand 및 String.length메소드를 참조 합니다.baseString

함수 포인터를 사용하면 수퍼 클래스에서 메소드를 상속받을 수 있습니다.

우리는 C 에서 다형성을 계속할 수 있습니다 .

예를 들어 어떤 이유로 클래스의 모든 시간 length을 반환 하도록 메서드 의 동작을 변경하려면 다음을 수행해야합니다.0ImmutableString

1. 재정의 length방법 으로 사용할 함수를 추가하십시오 .
2. “생성자”로 이동하여 함수 포인터를 재정의 length메소드 로 설정하십시오 .

재정의 length방법 ImmutableString을 추가하려면 lengthOverrideMethod다음 을 추가하십시오 .

int lengthOverrideMethod(const void* self)
{
    return 0;
}

그런 다음 length생성자 의 메소드에 대한 함수 포인터 는 다음에 연결됩니다 lengthOverrideMethod.

ImmutableString newImmutableString(const char* value)
{
    ImmutableString self = (ImmutableString)malloc(sizeof(struct ImmutableString_Struct));

    self->base = newString();

    self->get = self->base->get;
    self->length = &lengthOverrideMethod;

    self->base->set(self->base, (char*)value);

    return self;
}

이제, 오히려 대한 동일한 동작 갖는보다 length메소드 ImmutableString는 AS 클래스 String클래스 지금 length에있어서, 상기에 정의 된 동작을 참조한다 lengthOverrideMethod기능.

C에서 객체 지향 프로그래밍 스타일로 작성하는 방법을 여전히 배우고 있다는 고지 사항을 추가해야하므로 아마도 잘 설명하지 않았거나 OOP를 구현하는 가장 좋은 방법이라는 점에서 잘못되었을 수 있습니다 그러나 C의 목적은 함수 포인터를 많이 사용하는 방법 중 하나를 설명하는 것이 었습니다.

C에서 객체 지향 프로그래밍을 수행하는 방법에 대한 자세한 내용은 다음 질문을 참조하십시오.

• C의 객체 지향?
• C로 객체 지향 코드를 작성할 수 있습니까?

답변

// at global scope
const char swap[] = "\x8b\x44\x24\x04\x8b\x5c\x24\x08\x8b\x00\x8b\x1b\x31\xc3\x31\xd8\x31\xc3\x8b\x4c\x24\x04\x89\x01\x8b\x4c\x24\x08\x89\x19\xc3 <- This swaps the values of a and b";

00000000 <swap>:
   0:   8b 44 24 04             mov    eax,DWORD PTR [esp+0x4]   # load int *a arg from the stack
   4:   8b 5c 24 08             mov    ebx,DWORD PTR [esp+0x8]   # ebx = b
   8:   8b 00                   mov    eax,DWORD PTR [eax]       # dereference: eax = *a
   a:   8b 1b                   mov    ebx,DWORD PTR [ebx]
   c:   31 c3                   xor    ebx,eax                # pointless xor-swap
   e:   31 d8                   xor    eax,ebx                # instead of just storing with opposite registers
  10:   31 c3                   xor    ebx,eax
  12:   8b 4c 24 04             mov    ecx,DWORD PTR [esp+0x4]  # reload a from the stack
  16:   89 01                   mov    DWORD PTR [ecx],eax     # store to *a
  18:   8b 4c 24 08             mov    ecx,DWORD PTR [esp+0x8]
  1c:   89 19                   mov    DWORD PTR [ecx],ebx
  1e:   c3                      ret    

  not shown: the later bytes are ASCII text documentation
  they're not executed by the CPU because the ret instruction sends execution back to the caller

#include <stdio.h>
#define MAX_COLORS  256

typedef struct {
    char* name;
    int red;
    int green;
    int blue;
} Color;

Color Colors[MAX_COLORS];


void eachColor (void (*fp)(Color *c)) {
    int i;
    for (i=0; i<MAX_COLORS; i++)
        (*fp)(&Colors[i]);
}

void printColor(Color* c) {
    if (c->name)
        printf("%s = %i,%i,%i\n", c->name, c->red, c->green, c->blue);
}

int main() {
    Colors[0].name="red";
    Colors[0].red=255;
    Colors[1].name="blue";
    Colors[1].blue=255;
    Colors[2].name="black";

    eachColor(printColor);
}

typedef int ReturnFunction(char);
typedef int ParameterFunction(void);
ReturnFunction *f(ParameterFunction *p);

function taking 
    [pointer to [function taking [void] returning [int]]] 
returning
    [pointer to [function taking [char] returning [int]]]

D1(char);

(*D2)(char);

(*D3(<parameters>))(char)

(*D3(   (*ID1)(void)))(char)

int (*ID0(int (*ID1)(void)))(char)

ID0(<parameters>)

*ID0(<parameters>)

(*ID0(<parameters>))(char)

pointer to: *ID1
... function taking void returning: (*ID1)(void)

int (*ID0(int (*ID1)(void)))(char)

int v = (*ID0(some_function_pointer))(some_char);

// First, undefine all macros associated with version.h
#undef DEBUG_VERSION
#undef RELEASE_VERSION
#undef INVALID_VERSION


// Define which version we want to use
#define DEBUG_VERSION       // The current version
// #define RELEASE_VERSION  // To be uncommented when finished debugging

#ifndef __VERSION_H_      /* prevent circular inclusions */
    #define __VERSION_H_  /* by using protection macros */
    void board_init();
    void noprintf(const char *c, ...); // mimic the printf prototype
#endif

// Mimics the printf function prototype. This is what I'll actually 
// use to print stuff to the screen
void (* zprintf)(const char*, ...);

// If debug version, use printf
#ifdef DEBUG_VERSION
    #include <stdio.h>
#endif

// If both debug and release version, error
#ifdef DEBUG_VERSION
#ifdef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

// If neither debug or release version, error
#ifndef DEBUG_VERSION
#ifndef RELEASE_VERSION
    #define INVALID_VERSION
#endif
#endif

#ifdef INVALID_VERSION
    // Won't allow compilation without a valid version define
    #error "Invalid version definition"
#endif

#include "version.h"

/*****************************************************************************/
/**
* @name board_init
*
* Sets up the application based on the version type defined in version.h.
* Includes allowing or prohibiting printing to STDOUT.
*
* MUST BE CALLED FIRST THING IN MAIN
*
* @return    None
*
*****************************************************************************/
void board_init()
{
    // Assign the print function to the correct function pointer
    #ifdef DEBUG_VERSION
        zprintf = &printf;
    #else
        // Defined below this function
        zprintf = &noprintf;
    #endif
}

/*****************************************************************************/
/**
* @name noprintf
*
* simply returns with no actions performed
*
* @return   None
*
*****************************************************************************/
void noprintf(const char* c, ...)
{
    return;
}

#include "version.h"
#include <stdlib.h>
int main()
{
    // Must run board_init(), which assigns the function
    // pointer to an actual function
    board_init();

    void *ptr = malloc(100); // Allocate 100 bytes of memory
    // malloc returns NULL if unable to allocate the memory.

    if (ptr == NULL)
    {
        zprintf("Unable to allocate memory\n");
        return 1;
    }

    // Other things to do...
    return 0;
}

#include <stdio.h>

#define NUM_A 1
#define NUM_B 2

// define a function pointer type
typedef int (*two_num_operation)(int, int);

// an actual standalone function
static int sum(int a, int b) {
    return a + b;
}

// use function pointer as param,
static int sum_via_pointer(int a, int b, two_num_operation funp) {
    return (*funp)(a, b);
}

// use function pointer as return value,
static two_num_operation get_sum_fun() {
    return &sum;
}

// test - use function pointer as variable,
void test_pointer_as_variable() {
    // create a pointer to function,
    two_num_operation sum_p = &sum;
    // call function via pointer
    printf("pointer as variable:\t %d + %d = %d\n", NUM_A, NUM_B, (*sum_p)(NUM_A, NUM_B));
}

// test - use function pointer as param,
void test_pointer_as_param() {
    printf("pointer as param:\t %d + %d = %d\n", NUM_A, NUM_B, sum_via_pointer(NUM_A, NUM_B, &sum));
}

// test - use function pointer as return value,
void test_pointer_as_return_value() {
    printf("pointer as return value:\t %d + %d = %d\n", NUM_A, NUM_B, (*get_sum_fun())(NUM_A, NUM_B));
}

int main() {
    test_pointer_as_variable();
    test_pointer_as_param();
    test_pointer_as_return_value();

    return 0;
}