char * 或 char ** 可以伪装成 FILE * 吗？

Question

在 C 语言中，我经常希望以相同的方式处理从文件读取的数据和从字符串数组读取的数据。通常从文件中读取是为了生产，从字符串中读取是为了测试。我最终写了很多这样的代码：

void handle_line(char *line, Things *things) {
    ...
}

Things *read_from_chars(char *lines[]) {
    Things *things = Things_new();

    for (int i = 0; lines[i] != NULL; i++) {
        handle_line(lines[i], things);
    }

    return things;
}

Things *read_from_input(FILE *input) {
    char *line = NULL;
    size_t linelen = 0;

    Things *things = Things_new();

    while (getline(&line, &linelen, input) > 0) {
        handle_line(line, things);
    }

    return things;
}

这是重复劳动。

有没有办法让字符串数组伪装成FILE * 指针？或相反亦然？还是有更好的模式来处理这个问题？

对于加分：解决方案应使char * 或char ** 可与fgets 和getline 等标准文件函数一起使用。

Answer 1

您可以使用包含FILE* 和指向数组的指针的可区分联合，然后编写一个get_next 函数来处理正确的事情。

typedef struct {
    enum { is_file, is_array } type;
    union {
        FILE *file;
        struct {
            int index;
            int size;
            char **lines;
        } array;
    } data;
} file_or_array;

char *get_next(file_or_array foa) {
    if (foa.type == is_file) {
        char *line = NULL;
        size_t linelen = 0;
        getline(&line, &linelen, foa.data.file);
        return line;
    } else {
        if (foa.data.array.index < foa.data.array.size) {
            return strdup(foa.data.array.lines[foa.data.array.index++]);
        } else {
            return NULL;
        }
    }
}

调用strdup() 是使这项工作始终如一所必需的。由于getline() 返回一个新分配的字符串，调用者需要释放它，所以它在从数组中返回一个字符串时也会做同样的事情。然后调用者可以在这两种情况下安全地释放它。

Answer 2

有没有更好的模式来处理这个问题？

我建议的解决方案是进行函数重载。

提供所有可能的参数：

Things* readThings(FILE *f, char *l[])
{
    char *line = NULL;
    size_t linelen = 0;
    Things *things = Things_new();

    if (f)
    {
        while(getline(&line, &linelen, input) > 0)
            handle_line(line, things);
    }
    else
    {
        for(int i = 0; lines[i] != NULL; i++)
            handle_line(lines[i], things);
    }

    return things;
}

Things* readThingsChar(char *l[]){ return readThings(0, l); }

Things* readThingsFile(FILE *f){ return readThings(f, 0); }

如何使用

FILE *f;
char *l[100];

..

Things *a = readThings(f,0); // or readThingsFile(f)
Things *b = readThings(0,l); // or readThingsChar(l)

---

您可以将其嵌入数据中：

Things* readThings(char *l[])
{
    char *line = NULL;
    size_t linelen = 0;
    Things *things = Things_new();
    FILE *f = NULL;

    if (l[0][0]==UNIQUE_IDENTIFIER)
    {
        f = fopen(l[0]+1);

        while(getline(&line, &linelen, input) > 0)
            handle_line(line, things);

        fclose(f);
    }
    else
    {
        for(int i = 0; lines[i] != NULL; i++)
            handle_line(lines[i], things);
    }

    return things;
}

如何使用

char *f[1] = { "_file.txt" };
char *l[100] = { "first line", .. "last line" };

f[0][0] = UNIQUE_IDENTIFIER;

Things *a = readThings(f);
Things *b = readThings(l);

Answer 3

如果您仅需要此功能进行调试，请将fopen_strings(char *list[]) 函数写入：

• 创建一个临时文件
• 使用fopen 模式"r+" 打开它
• 将所有字符串写入其中
• 删除文件（FILE* 仍然可以对其进行操作，直到它在程序结束时显式或隐式关闭。在某些阻止删除打开文件的操作系统上，您可能需要跳过此步骤。
• rewind流
• 返回流并让您的程序像使用常规文件一样使用它。

Answer 4

这是一个使用fcookieopen [IIRC，BSD 有类似的东西] 的实现：

// control for string list
struct cookie {
    char **cook_list;                       // list of strings
    int cook_maxcount;                      // maximum number of strings

    int cook_curidx;                        // current index into cook_list
    int cook_curoff;                        // current offset within item
};

int cookie_close(void *vp);
ssize_t cookie_read(void *vp,char *buf,size_t size);

cookie_io_functions_t cook_funcs = {
    .read = cookie_open;
    .close = cookie_close;
};

// cookie_open -- open stream
FILE *
cookie_open(char **strlist,int count,const char *mode)
// strlist -- list of strings
// count -- number of elements in strlist
// mode -- file open mode
{
    cookie *cook;
    FILE *stream;

    cook = calloc(1,sizeof(cookie));
    cook->cook_list = strlist;
    cook->cook_maxcount = count;

    stream = fopencookie(cook,mode,&cook_funcs);

    return stream;
}

// cookie_close -- close stream
int
cookie_close(void *vp)
{

    free(vp);

    return 0;
}

// cookie_read -- read stream
ssize_t
cookie_read(void *vp,char *buf,size_t size)
{
    cookie *cook = vp;
    char *base;
    ssize_t totcnt;

    totcnt = 0;

    while (size > 0) {
        // bug out if all strings exhausted
        if (cook->cook_curidx >= cook->cook_maxcount)
            break;

        base = cook->cook_list[cook->cook_curidx];
        base += cook->cook_curoff;

        // if at end of current string, start on the next one
        if (*base == 0) {
            cook->cook_curidx += 1;
            cook->cook_curoff = 0;
            continue;
        }

        // store character and bump buffer and count
        *buf++ = *base;
        size -= 1;
        totcnt += 1;

        cook->cook_curoff += 1;
    }

    return totcnt;
}

Answer 5

给这只特定的猫换皮的方法不止一种，但一般来说，解决这个问题的方法是将公共接口的实现隐藏在允许您注入单独“实现”的间接后面。

（您的问题的这种化身也与确保代码版本之间的 ABI 兼容性的一些不同问题密切相关。）

要在 C 中解决此问题，您可以使用类似于 C++ 中的带有继承的 pimpl（受保护而不是私有 d 指针，具有覆盖的受保护构造函数）：

您创建一个不透明的“阅读器”/“流”对象（指向在 C 中使用 typedef 前向声明的结构的指针）和适当命名的构造函数来实例化注入所需实现的不透明对象。

让我们勾勒出示例头文件，让您了解这些函数是如何组合在一起的。让我们从胆量开始，d-pointer/p-impl 对象的定义（注意：我省略了一些样板文件，如标头保护）：

reader-private.h：

/* probably should be in its proper C file, but here for clarification */
struct FileReaderPrivateData {
   FILE * fp;
};

/* probably should be in its proper C file, but here for clarification */
struct StringReaderPrivateData {
   size_t nlines;
   size_t cursor;
   char ** lines;
};

/* in C we don't have inheritance, but we can 'fix' it using callbacks */
struct ReaderPrivate {
   int (* close)(void* pData); /* impl callback */
   ssize_t (* readLine)(void* pData, char** into); /* impl callback */
   /* impl-specific data object, callbacks can type cast safely */
   void * data;
};

/* works like a plain p-impl/d-pointer, delegates to the callbacks */
struct Reader {
    struct ReaderPrivate * dPtr;
}

reader.h：

typedef struct Reader* Reader;
/* N.B.: buf would be a pointer to set to a newly allocated line buffer. */
ssize_t readLine(Reader r, char ** buf); 
int close(Reader r);

file-reader.h

#include "reader.h"
Reader createFileReader(FILE * fp);
Reader createFileReader(const char* path);

string-reader.h

#include "reader.h"
Reader createStringReader(const char**, size_t nlines);

这是在 C 中使用继承来执行 pimpl/d-pointer 的一般模式，因此您可以在通过不透明指针访问的公共接口后面抽象实现内容。这种机制通常有助于保证公共接口的各种实现之间的 API 和 ABI 兼容性以及实现简单的继承模式。

Answer 6

处理此问题的最强大方法之一是通过流。我用它们来隐藏文件/字符串/串行端口等

我推出了自己的流库，主要用于嵌入式系统

总体思路是：-

typedef struct stream_s stream_t;

struct stream_s
{
    BOOL (*write_n)(stream_t* stream,  char* s, WORD n);
    BOOL (*write_byte)(stream_t* stream,  BYTE b);
    BOOL (*can_write)(stream_t* stream);
    BOOL (*can_read)(stream_t* stream);
    BYTE (*read_byte)(stream_t* stream);
    void* context;
};

然后你做了一大堆函数

BOOL stream_create(stream_t* stream);
BOOL stream_write_n(stream_t* stream, char* s, WORD n);
BOOL stream_can_read(stream_t* stream);
BYTE stream_read_byte(stream_t* stream);

等

使用那些基本函数回调。

流结构中的上下文，用于指向串行、字符串、文件或任何您想要的结构。然后你有像file_create_stream(stream_t* stream, char* filename) 这样的东西，它将使用文件相关函数填充stream 上的回调。然后对于字符串，你有类似但处理字符串的东西

Answer 7

有一个非标准函数fmemopen 可让您打开一个 char[] 进行读取或写入。我认为它在大多数版本的 GNU libc 和大多数版本的 Linux 中都可用。

（这使您可以读取或写入单个字符串，而不是您询问的字符串数组。）