C 如何迭代复合文字数组

​如何迭代复合文字数组，以便打印

book\u id

和

value

#include <stdio.h>
#include <string.h>

typedef struct {
    int book_id;
    char value;
} BookCode;

typedef struct {
    BookCode *codes;
} Books;

int main() {
    Books MyBooks[] = { 
        (BookCode[]){ {1, 'a'},{2, 'b'} },
        (BookCode[]){ {1, 'd'},{2, 'c'}, {3, 'f'} },
    };  

    int i,j;
    int n1 = sizeof(MyBooks)/sizeof(MyBooks[0]);
    for(i = 0; i < n1; i++){
        printf("%d\n", i); 
        // how to iterate over compound literal array?
    }   
    return 0;
}

#包括
#包括
类型定义结构{
国际图书标识；
字符值；
}图书编码；
类型定义结构{
图书编码*编码；
}书籍；
int main（）{
Books MyBooks[]={
（图书编码[]）{{1，'a'}，{2，'b'}，
（图书编码[]）{{1，'d'}，{2，'c'}，{3，'f'}，
};  
int i，j；
int n1=sizeof（MyBooks）/sizeof（MyBooks[0]）；
对于（i=0；i

如何迭代复合文字数组

你不能

至少在没有提供关于两个

BookCode

数组携带的元素数量的附加信息的情况下是这样，即2和3。将这两个数组分配给

MyBooks

的指针类型元素会丢失后面的信息。在运行时期间无法再计算它

您可以做的是定义一个哨兵值，并向每个

BookCode

数组的末尾添加一个stopper元素等的实例。这样，可以在运行时（重新）计算每个阵列的大小

例如，可以如下所示进行此操作：

#include <stdio.h>
#include <string.h>

typedef struct
{
  int book_id;
  char value;
} BookCode;

#define BOOKCODE_STOPPER {-1, '\0'}
static const BookCode BookCodeStopper = BOOKCODE_STOPPER;

typedef struct
{
  BookCode *codes;
} Books;

size_t get_codes_count(Books * books)
{
  BookCode * bc = books->codes;

  while (bc->book_id != BookCodeStopper.book_id
      && bc->value != BookCodeStopper.value)
  /* doing "while (memcmp(bc, &BookCodeStopper, sizeof BookCodeStopper)" might be faster. */
  {
    ++bc;
  }

  return bc - books->codes;
}

int main(void)
{
  Books books[] = {
    {(BookCode[]) {{1, 'a'}, {2, 'b'}, BOOKCODE_STOPPER}},
    {(BookCode[]) {{1, 'd'}, {2, 'c'}, {3, 'f'}, BOOKCODE_STOPPER}}
  };

  size_t n1 = sizeof books / sizeof books[0];
  for (size_t i = 0; i < n1; ++i)
  {
    printf("%zu\n", i);

    size_t s = get_codes_count(books + i);
    for (size_t j = 0; j < s; ++j)
    {
      printf("Book code %zu: id=%d, value=%c\n", j, books[i].codes[j].book_id,
          books[i].codes[j].value);
    }
  }

  return 0;
}

#包括
#包括
类型定义结构
{
国际图书标识；
字符值；
}图书编码；
#定义图书代码{1'，\0'}
静态常量BookCode BookCodeStopper=BookCode\u STOPPER；
类型定义结构
{
图书编码*编码；
}书籍；
大小\u无法获取\u代码\u计数（书籍*书籍）
{
图书编码*bc=图书->编码；
while（bc->book\u id！=BookCodeStopper.book\u id
&&bc->value！=BookCodeStopper.value）
/*执行“while（memcmp（bc，&bookcodestuber，sizeof bookcodestuber）”可能会更快*/
{
++卑诗省；
}
返回bc-书籍->代码；
}
内部主（空）
{
书籍[]={
{（书籍代码[]）{{1，'a'}，{2，'b'}，书籍代码{u}}，
{（书籍代码[]）{{1，'d'}，{2，'c'}，{3，'f'}，书籍代码{u}
};
size_t n1=书籍大小/书籍大小[0]；
对于（尺寸i=0；i

---

这种方法意味着至少有一种可能的书籍代码组合不会出现。在上面的示例中，我为此选择了

{-1，'\0'}

。

添加一个组合就可以了。谢谢