Скрытие элементов в структуре C

Лично мне больше нравится вот это:

typedef struct {
  int _public_member;
  /*I know you wont listen, but don't ever touch this member.*/
  int _private_member;
} SomeStructSource;

В конце концов, это C, если люди хотят облажаться, им нужно разрешить это - не нужно ничего скрывать, кроме:

Если вам нужно поддерживать совместимость ABI/API, есть 2 подхода, которые более распространены из того, что я видел.

• Не давайте своим клиентам доступ к структуре, дайте им непрозрачный дескриптор (void* с красивым именем), предоставьте функции инициализации/уничтожения и доступа для всего. Это гарантирует, что вы можете изменить структуру даже без перекомпиляции клиентов, если вы пишете библиотеку.

• предоставьте непрозрачный дескриптор как часть вашей структуры, которую вы можете выделить по своему усмотрению. Этот подход используется даже в C++ для обеспечения совместимости с ABI.

e.g

 struct SomeStruct {
  int member;
  void* internals; //allocate this to your private struct
 };

sizeof(SomeStruct) != sizeof(SomeStructSource). Это приведет к тому, что кто-то когда-нибудь найдет вас и убьет.

У вас почти получилось, но вы не зашли достаточно далеко.

В заголовке:

struct SomeStruct;
typedef struct SomeStruct *SomeThing;


SomeThing create_some_thing();
destroy_some_thing(SomeThing thing);
int get_public_member_some_thing(SomeThing thing);
void set_public_member_some_thing(SomeThing thing, int value);

В .с:

struct SomeStruct {
  int public_member;
  int private_member;
};

SomeThing create_some_thing()
{
    SomeThing thing = malloc(sizeof(*thing));
    thing->public_member = 0;
    thing->private_member = 0;
    return thing;
}

... etc ...

Дело в том, что теперь потребители не знают о внутреннем устройстве SomeStruct, и вы можете безнаказанно изменять его, добавляя и удаляя элементы по своему желанию, даже без необходимости повторной компиляции потребителям. Они также не могут "случайно" манджировать элементы напрямую или размещать SomeStruct в стеке. Это, конечно, тоже можно рассматривать как недостаток.

Я не рекомендую использовать шаблон общедоступной структуры. Правильный шаблон проектирования для ООП в C состоит в том, чтобы предоставить функции для доступа ко всем данным, никогда не разрешая публичный доступ к данным. Данные класса должны быть объявлены в источнике, чтобы быть закрытыми, и на них можно ссылаться в прямом порядке, где Create и Destroy выполняют выделение и освобождают данные. Таким образом, дилеммы публичное/частное больше не будет.

/*********** header.h ***********/
typedef struct sModuleData module_t' 
module_t *Module_Create();
void Module_Destroy(module_t *);
/* Only getters and Setters to access data */
void Module_SetSomething(module_t *);
void Module_GetSomething(module_t *);

/*********** source.c ***********/
struct sModuleData {
    /* private data */
};
module_t *Module_Create()
{
    module_t *inst = (module_t *)malloc(sizeof(struct sModuleData));
    /* ... */
    return inst;
}
void Module_Destroy(module_t *inst)
{
    /* ... */
    free(inst);
}

/* Other functions implementation */

С другой стороны, если вы не хотите использовать Malloc/Free (что может быть лишним в некоторых ситуациях), я предлагаю вам скрыть структуру в частном файле. Частные члены будут доступны, но это зависит от пользователя.

/*********** privateTypes.h ***********/
/* All private, non forward, datatypes goes here */
struct sModuleData {
    /* private data */
};

/*********** header.h ***********/
#include "privateTypes.h"
typedef struct sModuleData module_t; 
void Module_Init(module_t *);
void Module_Deinit(module_t *);
/* Only getters and Setters to access data */
void Module_SetSomething(module_t *);
void Module_GetSomething(module_t *);

/*********** source.c ***********/
void Module_Init(module_t *inst)
{       
    /* perform initialization on the instance */        
}
void Module_Deinit(module_t *inst)
{
    /* perform deinitialization on the instance */  
}

/*********** main.c ***********/
int main()
{
    module_t mod_instance;
    module_Init(&mod_instance);
    /* and so on */
}

Никогда не делай этого. Если ваш API поддерживает что-либо, что принимает SomeStruct в качестве параметра (что, как я ожидаю, он и делает), тогда они могут выделить один в стеке и передать его. Вы получите серьезные ошибки, пытаясь получить доступ к частному члену, начиная с того, что компилятор выделенное для клиентского класса, не содержит для него места.

Классический способ скрыть члены в структуре — сделать ее пустой*. По сути, это дескриптор/куки, о котором знают только ваши файлы реализации. Почти каждая библиотека C делает это для частных данных.

Что-то похожее на предложенный вами метод действительно иногда используется (например, см. Различные варианты struct sockaddr* в API сокетов BSD), но его почти невозможно использовать, не нарушая строгие правила C99 по использованию псевдонимов.

Однако вы можете сделать это безопасно:

somestruct.h:

struct SomeStructPrivate; /* Opaque type */

typedef struct {
  int _public_member;
  struct SomeStructPrivate *private;
} SomeStruct;

somestruct.c:

#include "somestruct.h"

struct SomeStructPrivate {
    int _member;
};

SomeStruct *SomeStruct_Create()
{
    SomeStruct *p = malloc(sizeof *p);
    p->private = malloc(sizeof *p->private);
    p->private->_member = 0xWHATEVER;
    return p;
}

Я бы написал скрытую структуру и ссылался на нее с помощью указателя в общедоступной структуре. Например, ваш .h может иметь:

typedef struct {
    int a, b;
    void *private;
} public_t;

И ваш .с:

typedef struct {
    int c, d;
} private_t;

Это, очевидно, не защищает от арифметики указателей и добавляет немного накладных расходов для выделения/освобождения, но я думаю, что это выходит за рамки вопроса.

Используйте следующий обходной путь:

#include <stdio.h>

#define C_PRIVATE(T)        struct T##private {
#define C_PRIVATE_END       } private;

#define C_PRIV(x)           ((x).private)
#define C_PRIV_REF(x)       (&(x)->private)

struct T {
    int a;

C_PRIVATE(T)
    int x;
C_PRIVATE_END
};

int main()
{
    struct T  t;
    struct T *tref = &t;

    t.a = 1;
    C_PRIV(t).x = 2;

    printf("t.a = %d\nt.x = %d\n", t.a, C_PRIV(t).x);

    tref->a = 3;
    C_PRIV_REF(tref)->x = 4;

    printf("tref->a = %d\ntref->x = %d\n", tref->a, C_PRIV_REF(tref)->x);

    return 0;
}

Результат:

t.a = 1
t.x = 2
tref->a = 3
tref->x = 4

Есть лучшие способы сделать это, например, использовать указатель void * на приватную структуру в публичной структуре. То, как вы это делаете, обманываете компилятор.

Этот подход является действительным, полезным, стандартным C.

Немного другой подход, используемый API сокетов, который был определен BSD Unix, - это стиль, используемый для struct sockaddr.

Мое решение состояло бы в том, чтобы предоставить только прототип внутренней структуры, а затем объявить определение в файле .c. Очень полезно показать интерфейс C и использовать C++ позади.

.h :

struct internal;

struct foo {
   int public_field;
   struct internal *_internal;
};

.c :

struct internal {
    int private_field; // could be a C++ class
};

Примечание. В этом случае переменная должна быть указателем, потому что компилятор не может знать размер внутренней структуры.

Я обнаружил, что bit-field может быть хорошим решением, если вы действительно хотите что-то скрыть.

struct person {
    unsigned long :64;
    char          *name;
    int           age;
};

struct wallet {
    char *currency;
    double balance;
};

Первым членом структуры person является безымянное битовое поле. используется для 64-bit pointer в этом случае. Он полностью скрыт и не может быть доступен по имени структурной переменной.

Поскольку первый 64-бит в этой структуре не используется, мы можем использовать его как приватный указатель. Мы можем получить доступ к этому члену по его адресу памяти вместо имени переменной.

void init_person(struct person* p, struct wallet* w) {
    *(unsigned long *)p = (unsigned long)w;
    // now the first 64-bit of person is a pointer of wallet
}

struct wallet* get_wallet(struct person* p) {
    return (struct wallet*)*(unsigned long *)p;
}

Небольшой рабочий пример, проверенный на моем Intel Mac:

//
// Created by Rieon Ke on 2020/7/6.
//

#include <stdlib.h>
#include <string.h>
#include <assert.h>


#if __x86_64__ || __LP64__
#define PRIVATE_SET(obj, val) *(unsigned long *) obj = (unsigned long) val;
#define PRIVATE_GET(obj, type) (type)*(unsigned long *) obj;
#define PRIVATE_POINTER unsigned long:64
#else
#define PRIVATE_SET(obj, val) *(unsigned int *) obj = (unsigned int) val;
#define PRIVATE_GET(obj, type) (type)*(unsigned int *) obj;
#define PRIVATE_POINTER unsigned int:32
#endif

struct person {
    PRIVATE_POINTER;
    char *name;
    int age;
};

struct wallet {
    char *currency;
    double balance;
};

int main() {

    struct wallet w;
    w.currency = strdup("$$");
    w.balance = 99.9;

    struct person p;
    PRIVATE_SET(&p, &w) //set private member

    p.name = strdup("JOHN");
    p.age = 18;

    struct wallet *pw = PRIVATE_GET(&p, struct wallet*) //get private member

    assert(strcmp(pw->currency, "$$") == 0);
    assert(pw->balance == 99.9);

    free(w.currency);
    free(p.name);

    return 0;
}

Не очень конфиденциально, учитывая, что вызывающий код может возвращаться к (SomeStructSource *). Кроме того, что происходит, когда вы хотите добавить еще одного открытого участника? Вам придется сломать бинарную совместимость.

РЕДАКТИРОВАТЬ: я пропустил, что он был в файле .c, но на самом деле ничто не мешает клиенту скопировать его или, возможно, даже напрямую #includeing файл .c.

Родственники, хотя и не особо скрываемые.

Является условным прекращением поддержки членов.

Обратите внимание, что это работает для GCC/Clang, но MSVC и другие компиляторы также могут устареть, поэтому можно придумать более переносимую версию.

Если вы строите с довольно строгими предупреждениями или предупреждениями об ошибках, это, по крайней мере, позволяет избежать случайного использования.

// =========================================
// in somestruct.h

#ifdef _IS_SOMESTRUCT_C
#  if defined(__GNUC__)
#    define HIDE_MEMBER __attribute__((deprecated))
#  else
#    define HIDE_MEMBER  /* no hiding! */
#  endif
#else
#  define HIDE_MEMBER
#endif

typedef struct {
  int _public_member;
  int _private_member  HIDE_MEMBER;
} SomeStruct;

#undef HIDE_MEMBER


// =========================================
// in somestruct.c
#define _IS_SOMESTRUCT_C
#include "somestruct.h"

SomeStruct *SomeStruct_Create()
{
  SomeStructSource *p = (SomeStructSource *)malloc(sizeof(SomeStructSource));
  p->_private_member = 42;
  return (SomeStruct *)p;
}