隐藏C结构中的成员

我一直在阅读有关C语言中的OOP的知识，但我从未喜欢过如何像C ++中那样拥有私有数据成员。但是后来我想到可以创建2个结构。一个在头文件中定义，另一个在源文件中定义。

// =========================================
// in somestruct.h
typedef struct {
  int _public_member;
} SomeStruct;

// =========================================
// in somestruct.c

#include "somestruct.h"

typedef struct {
  int _public_member;
  int _private_member;
} SomeStructSource;

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

从这里您可以将一个结构转换为另一个结构。这被认为是不良做法吗？还是经常做？

就个人而言，我更喜欢这样：

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 *），为所有内容提供init / destroy和accessor函数。如果要编写库，这可以确保即使不重新编译客户端也可以更改结构。

• 提供一个不透明的句柄作为结构的一部分，您可以随意分配它。此方法甚至在C ++中用于提供ABI兼容性。

例如

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

在.c中：

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语言中的OOP而言，正确的设计模式是提供访问每个数据的功能，而决不允许公开访问数据。类数据应在源宣布，为了是私有的，并且在前进的方式来引用，其中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作为参数的任何东西（我希望它能做到），那么他们可以在堆栈上分配一个参数并将其传递给您。尝试访问私有成员会遇到重大错误，因为该成员是编译器为客户端类分配的空间不包含空间。

在结构中隐藏成员的经典方法是使其成为void *。它基本上是一个只有您的实现文件知道的句柄/ cookie。几乎每个C库都针对私有数据执行此操作。

确实确实有时会使用与您提出的方法类似的方法（例如，struct sockaddr*在BSD套接字API中查看不同的变量），但是在不违反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;

而您的.c：

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。

由BSD Unix定义的sockets API使用的方法稍有不同，它是用于的样式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;
};

struct person的第一个成员是未命名的位域。64-bit pointer在这种情况下用于。它是完全隐藏的，不能通过结构变量name进行访问。

由于此结构中的前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文件中，但实际上并没有阻止客户端将其复制出来，甚至#include直接阻止该.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;
}