C中的命名空间

Posted 2021-04-18

有没有办法（ab）使用C预处理器来模拟C中的命名空间？

我正在考虑以下几点：

#define NAMESPACE name_of_ns
some_function() {
    some_other_function();
}

这将被翻译为：

name_of_ns_some_function() {
    name_of_ns_some_other_function();
}

答案

使用名称空间前缀时，我通常会为缩短的名称添加宏，这些名称可以在包含标题之前通过#define NAMESPACE_SHORT_NAMES激活。标题foobar.h可能如下所示：

// inclusion guard
#ifndef FOOBAR_H_
#define FOOBAR_H_

// long names
void foobar_some_func(int);
void foobar_other_func();

// short names
#ifdef FOOBAR_SHORT_NAMES
#define some_func(...) foobar_some_func(__VA_ARGS__)
#define other_func(...) foobar_other_func(__VA_ARGS__)
#endif

#endif

如果我想在包含文件中使用短名称，我会这样做

#define FOOBAR_SHORT_NAMES
#include "foobar.h"

我发现这比使用Vinko Vrsalovic所描述的命名空间宏（在评论中）更清晰，更有用。

另一答案

另一种方法是声明一个struct来保存你的所有函数，然后静态地定义你的函数。然后，您只需要担心全局名称struct的名称冲突。

// foo.h
#ifndef FOO_H
#define FOO_H
typedef struct { 
  int (* const bar)(int, char *);
  void (* const baz)(void);
} namespace_struct;
extern namespace_struct const foo;
#endif // FOO_H

// foo.c
#include "foo.h"
static int my_bar(int a, char * s) { /* ... */ }
static void my_baz(void) { /* ... */ }
namespace_struct const foo = { my_bar, my_baz }

// main.c
#include <stdio.h>
#include "foo.h"
int main(void) {
  foo.baz();
  printf("%d", foo.bar(3, "hello"));
  return 0;
}

在上面的例子中，my_bar和my_baz不能直接从main.c调用，只能通过foo调用。

如果您有一堆声明具有相同签名的函数的命名空间，那么您可以标准化该集合的命名空间结构，并选择在运行时使用哪个命名空间。

// goo.h
#ifndef GOO_H
#define GOO_H
#include "foo.h"
extern namespace_struct const goo;
#endif // GOO_H

// goo.c
#include "goo.h"
static int my_bar(int a, char * s) { /* ... */ }
static void my_baz(void) { /* ... */ }
namespace_struct const goo = { my_bar, my_baz };

// other_main.c
#include <stdio.h>
#include "foo.h"
#include "goo.h"
int main(int argc, char** argv) {
  namespace_struct const * const xoo = (argc > 1 ? foo : goo);
  xoo->baz();
  printf("%d", xoo->bar(3, "hello"));
  return 0;
}

my_bar和my_baz的多个定义不会发生冲突，因为它们是静态定义的，但底层函数仍然可以通过适当的命名空间结构访问。

另一答案

你可以使用##运算符：

#define FUN_NAME(namespace,name) namespace ## name

并将函数声明为：

void FUN_NAME(MyNamespace,HelloWorld)()

看起来很尴尬。

另一答案

我想出了以下方案：

（标题）

// NS_PREFIX controls the prefix of each type and function declared in this
// header, in order to avoid name collision.
#define NS_PREFIX myprefix_

// Makes a string from argument (argument is not macro-expanded).
#define stringify(arg) #arg

// Concatenation that macro-expands its arguments.
#define concat(p1, p2) _concat(p1, p2) // Macro expands the arguments.
#define _concat(p1, p2) p1 ## p2       // Do the actual concatenation.

// Append the namespace prefix to the identifier.
#define ns(iden) concat(NS_PREFIX, iden)

// header content, for instance :
void ns(my_function)(int arg1, ns(t) arg2, int arg3);

// Allow implementation files to use namespacing features, else
// hide them from the including files.
#ifndef _IMPL
#undef NS_PREFIX
#undef ns
#undef stringify
#undef concat
#undef _concat
#endif // _IMPL

（实现）

#define  _IMPL 
#include "header.h"
#undef   __IMPL

另一答案

我使用基于结构的方法，有两个改进：我添加子结构来创建分层命名空间，当我想简化命名空间的路径时，我定义了一些简单的宏。

我们以Foobar图书馆为例。

foob​​ar.h中

#ifndef __FOOBAR_H__
#define __FOOBAR_H__

// definition of the namespace's hierarchical structure
struct _foobar_namespace {
    struct {
        void (*print)(char *s);
    } text;
    struct {
        char *(*getDateString)(void);
    } date;
};

// see the foobar.c file
// it must be the only one defining the FOOBAR macro
# ifndef FOOBAR
    // definition of the namespace global variable
    extern struct _foobar_namespace foobar;
# endif // FOOBAR

#endif // __FOOBAR_H__

foob​​ar.c但是

// the FOOBAR macro is needed to avoid the
// extern foobar variable declaration
#define FOOBAR

#include "foobar.h"
#include "foobar_text.h"
#include "foobar_date.h"

// creation of the namespace global variable
struct _foobar_namespace foobar = {
    .text = {
        .print = foobar_text__print
    },
    .date = {
        .getDateString = foobar_date__getDateString
    }
};

然后，可以使用命名空间：

#include "foobar.h"

void main() {
    foobar.text.print("it works");
}

但是foobar_text__print()和foobar.text.print()之间并没有那么大的区别。我认为第二个更具可读性，但这是值得怀疑的。因此，通过定义一些宏来简化这些命名空间变得非常有用：

#include "foobar.h"

#define txt    foobar.text
#define date   foobar.date

void main() {
    char *today = date.getDateString();
    txt.print(today);
}

这种分层命名空间可以快速定义，易于理解并减少代码冗长。

---

只是为了好玩，这里是foobar.text代码的文件：

foob​​ar_text.h

#ifndef __FOOBAR_TEXT_H__
#define __FOOBAR_TEXT_H__

void foobar_text__print(char *s);

#endif // __FOOBAR_TEXT_H__

foob​​ar_text.c

#include <stdio.h>
#include "foobar_text.h"

void foobar_text__print(char *s) {
    printf("%s
", s);
}

另一答案

我写了一篇关于如何使用C获得命名空间和/或模板优势的教程。

Namespaces and templates in C

Namespaces and templates in C (using Linked Lists)

对于基本命名空间，可以简单地将命名空间名称作为约定加前缀。

namespace MY_OBJECT {
  struct HANDLE;
  HANDLE *init();
  void destroy(HANDLE * & h);

  void do_something(HANDLE *h, ... );
}

可写成

struct MY_OBJECT_HANDLE;
struct MY_OBJECT_HANDLE *my_object_init();
void my_object_destroy( MY_OBJECT_HANDLE * & h );

void my_object_do_something(MY_OBJECT_HANDLE *h, ... );

我需要使用命名空间和模板概念的第二种方法是使用宏连接和包含。例如，我可以创建一个

template<T> T multiply<T>( T x, T y ) { return x*y }

使用模板文件如下

乘template.h

_multiply_type_ _multiply_(multiply)( _multiply_type_ x, _multiply_type_ y);

乘template.c

_multiply_type_ _multiply_(multiply)( _multiply_type_ x, _multiply_type_ y) {
  return x*y;
}

我们现在可以如下定义int_multiply。在这个例子中，我将创建一个int_multiply.h / .c文件。

int_multiply.h

#ifndef _INT_MULTIPLY_H
#define _INT_MULTIPLY_H

#ifdef _multiply_
#undef _multiply_
#endif
#define _multiply_(NAME) int ## _ ## NAME 

#ifdef _multiply_type_
#undef _multiply_type_
#endif
#define _multiply_type_ int 

#include "multiply-template.h" 
#endif

int_multiply.c

#include "int_multiply.h"
#include "multiply-template.c"

在所有这些结束时，您将拥有一个函数和头文件。

int int_multiply( int x, int y ) { return x * y }

我在提供的链接上创建了更详细的教程。希望这有助于某人！

另一答案

类似于公认答案的方法如下：

// inclusion guard
#ifndef FOOBAR_H_
#define FOOBAR_H_

// long names
void foobar_some_func(int);
void foobar_other_func();

// qualified names
#ifdef FOOBAR_SHORT_NAMES
extern struct _foobar {
     void (*some_func)(int);
     void (*other_func)();
} foobar;
#endif

#endif

此头文件应附带.c文件：

#include "foobar.h"
struct _foobar foobar = {
    foobar_some_func;
    foobar_other_func;
};

使用这些功能时

foobar.some_func(10);
foobar.other_func();

另一答案

这是一个构建上述方法的示例，并将它们组合为func和结构，以创建伪命名空间NAMESPACE1和NAMESPACE2。这种结构保持功能的好处是结构保持功能方法需要跨多个伪名称空间的标准化结构，这并不总是可行的（根本不可能，或者没有大量的工作可以说是不改进代码）或理想的。

不确定宏扩展顺序是否可能是一个问题，但这适用于GCC并且似乎最小化所需的代码更改量，同时保持良好（虽然远非理想）可读性。

---

applicat