C 如何静态初始化一组结构？

我想用a的副本初始化

b

。但是，我不能用

memcpy（）

来触摸

static const

东西。我需要

b

成为

static const

，因为这样它就会被放入闪存而不是ram内存

---

我该如何使这项工作。编译器是带有

-std=c89的
arm-none-eabi-gcc
，我认为。
在linux上这符合gcc-std=c89（不知道arm交叉编译器）

类型定义结构A{
int a；int b；
}TA；
类型定义结构ARR3{
TA-a[3]；
}TARR3；
类型定义结构ARR33{
tarr3b[3]；
}TARR33；
静态常数TA a={.a=1.b=42}；
TARR33 aa={
.b[0]={.a[0]={.a=1、.b=1}、.a[1]={.a=2、.b=2}、.a[2]={.a=3、.b=3}，
.b[1]={.a[0]={.a=4、.b=4}、.a[1]={.a=5、.b=5}、.a[2]={.a=1、.b=2}，
.b[2]={.a[0]={.a=1、.b=1}、.a[1]={.a=1、.b=2}、.a[2]={.a=1、.b=2}
};
main（）
{
返回0；
}
我建议您将这些阵列放在单独的模块中，以实现封装。然后，在该模块中，不需要将B设为常量，而是将其设为静态。
对该数据的任何访问都必须通过如下getter和setter完成：

typedef struct A{
    int a; int b;
} TA;

typedef struct ARR3 {
    TA a[3];
} TARR3;


typedef struct ARR33 {
 TARR3 b[3];
} TARR33;

static const TA a = {.a = 1, .b = 42};

TARR33 aa = {
   .b[0] = { .a[0] = {.a = 1, .b = 1}, .a[1] = {.a = 2, .b = 2}, .a[2] = {.a = 3, .b = 3} },
   .b[1] = { .a[0] = {.a = 4, .b = 4}, .a[1] = {.a = 5, .b = 5}, .a[2] = {.a = 1, .b = 2} },
   .b[2] = { .a[0] = {.a = 1, .b = 1}, .a[1] = {.a = 1, .b = 2}, .a[2] = {.a = 1, .b = 2} }
            };

main()
{
  return 0;
}

mydata.h
#定义BAU尺寸666
结构A{
int a；int b；
};
结构B{
构造一个东西[BA_SIZE]；
};
void init（void）；
结构A*getB（无符号整数i）；
void setB（无符号整数i，结构A元素）；
mydata.c:
#包括“mydata.h”
静态常量结构A={.A=1.b=42}；
静态结构B；
void init（void）
{
int i；
对于（i=0；i<BA_SIZE；i++）{
b、 stuff[i]=a；
}
} 
结构A*getB（无符号整数i）
{
退货（&b.stuff[i]）；
}
void setB（无符号整数i，结构A元素）
{
if（i> BA_SIZE）{return；}
b、 stuff[i].a=element.a；
b、 stuff[i].b=element.b；
}
main.c:
#包括<stdio.h>
#包括“mydata.h”
内部主（空）
{
init（）；
无符号整数num=1；
结构A*something=getB（num）；
printf（“元素[%u]a=%i b=%i\n”，num，something->a，something->b）；
返回（0）；
}
您可以尝试此方法，尽管它特别适用于您指定的尺寸（666 x 510）：

请参阅
.a1=1
：未知字段的答案。而不是c89。检查链接器脚本中放入flash的部分，然后添加一个
部分
，将其放入该部分。那么您想要666*510份相同数据对的副本？你想让它变成常量？我只是好奇这会有什么用处。@BLUEPIXY，它是ANSIC和gnu扩展的巧妙结合。例如，
for（inti=0；i<5；i++）
无法编译。当然，您仍然需要键入所有数字。在我的例子中，数组比3x3大得多。看来这是唯一的答案。但它真他妈的丑！使数据
静态常量
允许链接器将其放入闪存，而不是宝贵的ram。我可以做到，因为我只需要阅读这些数据。另一方面，对于更改数据，您的示例看起来很不错。有点混乱，但还有很长的路要走。他们说宏是语言的支柱。谢谢！
typedef struct A{
    int a; int b;
} TA;

typedef struct ARR3 {
    TA a[3];
} TARR3;


typedef struct ARR33 {
 TARR3 b[3];
} TARR33;

static const TA a = {.a = 1, .b = 42};

TARR33 aa = {
   .b[0] = { .a[0] = {.a = 1, .b = 1}, .a[1] = {.a = 2, .b = 2}, .a[2] = {.a = 3, .b = 3} },
   .b[1] = { .a[0] = {.a = 4, .b = 4}, .a[1] = {.a = 5, .b = 5}, .a[2] = {.a = 1, .b = 2} },
   .b[2] = { .a[0] = {.a = 1, .b = 1}, .a[1] = {.a = 1, .b = 2}, .a[2] = {.a = 1, .b = 2} }
            };

main()
{
  return 0;
}

mydata.h

#define BA_SIZE 666

struct A{
    int a; int b;
};

struct B{
    struct A stuff[BA_SIZE];
};

void init(void);
struct A * getB(unsigned int i);
void setB(unsigned int i, struct A element);

mydata.c:

#include "mydata.h"

static const struct A a = {.a = 1, .b = 42};
static struct B b;

void init(void)
{
    int i;
    for(i=0; i<BA_SIZE; i++) {
        b.stuff[i] = a;
    }
} 

struct A * getB(unsigned int i)
{
    return(&b.stuff[i]);
}

void setB(unsigned int i, struct A element)
{
    if (i > BA_SIZE) { return; }
    b.stuff[i].a = element.a;
    b.stuff[i].b = element.b;
}


main.c:
#include <stdio.h>
#include "mydata.h"

int main(void)
{
    init();
    unsigned int num=1;
    struct A * something = getB(num);
    printf("element [%u] a=%i b=%i \n", num, something->a, something->b);

    return(0);
}



#define X001 {1,42}
#define X002 X001,X001
#define X004 X002,X002
#define X008 X004,X004
#define X016 X008,X008
#define X032 X016,X016
#define X064 X032,X032
#define X128 X064,X064
#define X256 X128,X128

#define Y001 {X256,X128,X064,X032,X016,X008,X004,X002}
#define Y002 Y001,Y001
#define Y004 Y002,Y002
#define Y008 Y004,Y004
#define Y016 Y008,Y008
#define Y032 Y016,Y016
#define Y064 Y032,Y032
#define Y128 Y064,Y064
#define Y256 Y128,Y128
#define Y512 Y256,Y256

static const struct A a = X001;
static const struct B b = {{Y512,Y128,Y016,Y008,Y002}};