Question

我有四个const char[][]数组，每个数组大约50个元素，每个元素包含另外40个值，这些数据将被发送到图形LCD，以绘制某个字母，数字，符号...... / p>

现在，问题是，我正在开发一个资源非常有限的嵌入式系统。虽然所有四个阵列对我之前工作的项目很有用，但我需要大部分角色，现在我只需要5或10个。

我可以从我不需要的数组字符中删除，但我希望有更好的方法可以禁止那些字符写入RAM / FLASH。

我在考虑使用#ifdef和#endif。但是为每个元素执行此操作，代码会变得混乱。

还有其他办法吗？

提前致谢！

修改

现在，我有#ifdef和#endif更大的部分，例如：

#define ARRAY1_BIG_LETTERS
#define ARRAY1_SMALL_LETTERS
#define ARRAY1_NUMBERS
#define ARRAY1_OTHER

#define ARRAY2_BIG_LETTERS
#define ARRAY2_SMALL_LETTERS
#define ARRAY2_NUMBERS
#define ARRAY2_OTHER

...

但是，我仍然需要对内容进行更好的控制。

EDIT2：

这是（较小的）数组之一：

const char writting_8x8[][9] = {
    #ifdef ARRAY1_OTHER
    {32, 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0},                        /*   */
    {45, 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0},                        /* - */
    {46, 0 , 0 , 96 , 96 , 0 , 0 , 0 , 0},                      /* . */
    {58, 0 , 0 , 108 , 108 , 0 , 0 , 0 , 0},                    /* : */
    {61, 0 , 36 , 36 , 36 , 36 , 36 , 0 , 0},                   /* = */
    #endif
    #ifdef ARRAY1_NUMBERS
    {48, 0 , 62 , 81 , 73 , 69 , 62 , 0 , 0},                   /* 0 */
    {49, 0 , 0 , 66 , 127 , 64 , 0 , 0 , 0},                    /* 1 */
    {50, 0 , 98 , 81 , 73 , 73 , 70 , 0 , 0},                   /* 2 */
    {51, 0 , 34 , 73 , 73 , 73 , 54 , 0 , 0},                   /* 3 */
    {52, 0 , 24 , 20 , 18 , 127 , 16 , 0 , 0},                  /* 4 */
    {53, 0 , 47 , 73 , 73 , 73 , 49 , 0 , 0},                   /* 5 */
    {54, 0 , 60 , 74 , 73 , 73 , 48 , 0 , 0},                   /* 6 */
    {55, 0 , 1 , 113 , 9 , 5 , 3 , 0 , 0},                      /* 7 */
    {56, 0 , 54 , 73 , 73 , 73 , 54 , 0 , 0},                   /* 8 */
    {57, 0 , 6 , 73 , 73 , 41 , 30 , 0 , 0},                    /* 9 */
    #endif
    #ifdef ARRAY1_BIG_LETTERS
    {65, 0 , 126 , 17 , 17 , 17 , 126 , 0 , 0},                 /* A */
    {66, 0 , 127 , 73 , 73 , 73 , 54 , 0 , 0},                  /* B */
    {67, 0 , 62 , 65 , 65 , 65 , 34 , 0 , 0},                   /* C */
    {68, 0 , 127 , 65 , 65 , 65 , 62 , 0 , 0},                  /* D */
    {69, 0 , 127 , 73 , 73 , 73 , 65 , 0 , 0},                  /* E */
    {70, 0 , 127 , 9 , 9 , 9 , 1 , 0 , 0},                      /* F */
    {71, 0 , 62 , 65 , 73 , 73 , 122 , 0 , 0},                  /* G */
    {72, 0 , 127 , 8 , 8 , 8 , 127 , 0 , 0},                    /* H */
    {73, 0 , 0 , 65 , 127 , 65 , 0 , 0 , 0},                    /* I */
    {74, 0 , 48 , 64 , 64 , 64 , 63 , 0 , 0},                   /* J */
    {75, 0 , 127 , 8 , 20 , 34 , 65 , 0 , 0},                   /* K */
    {76, 0 , 127 , 64 , 64 , 64 , 64 , 0 , 0},                  /* L */
    {77, 0 , 127 , 2 , 4 , 2 , 127 , 0 , 0},                    /* M */
    {78, 0 , 127 , 2 , 4 , 8 , 127 , 0 , 0},                    /* N */
    {79, 0 , 62 , 65 , 65 , 65 , 62 , 0 , 0},                   /* O */
    {80, 0 , 127 , 9 , 9 , 9 , 6 , 0 , 0},                      /* P */
    {81, 0 , 62 , 65 , 81 , 33 , 94 , 0 , 0},                   /* Q */
    {82, 0 , 127 , 9 , 9 , 25 , 102 , 0 , 0},                   /* R */
    {83, 0 , 38 , 73 , 73 , 73 , 50 , 0 , 0},                   /* S */
    {84, 0 , 1 , 1 , 127 , 1 , 1 , 0 , 0},                      /* T */
    {85, 0 , 63 , 64 , 64 , 64 , 63 , 0 , 0},                   /* U */
    {86, 0 , 31 , 32 , 64 , 32 , 31 , 0 , 0},                   /* V */
    {87, 0 , 63 , 64 , 60 , 64 , 63 , 0 , 0},                   /* W */
    {88, 0 , 99 , 20 , 8 , 20 , 99 , 0 , 0},                    /* X */
    {89, 0 , 7 , 8 , 112 , 8 , 7 , 0 , 0},                      /* Y */
    {90, 0 , 113 , 73 , 69 , 67 , 0 , 0 , 0},                   /* Z */
    {200, 0 , 56 , 69 , 70 , 69 , 40 , 0 , 0},                  /* Č */
    #endif
    #ifdef ARRAY1_SMALL_LETTERS
    {97, 0 , 32 , 84 , 84 , 84 , 120 , 0 , 0},                  /* a */
    {98, 0 , 127 , 68 , 68 , 68 , 56 , 0 , 0},                  /* b */
    {99, 0 , 56 , 68 , 68 , 68 , 40 , 0 , 0},                   /* c */
    {100, 0 , 56 , 68 , 68 , 68 , 127 , 0 , 0},                 /* d */
    {101, 0 , 56 , 84 , 84 , 84 , 8 , 0 , 0},                   /* e */
    {102, 0 , 8 , 126 , 9 , 9 , 0 , 0 , 0},                     /* f */
    {103, 0 , 24 , 164 , 164 , 164 , 124 , 0 , 0},              /* g */
    {104, 0 , 127 , 4 , 4 , 120 , 0 , 0 , 0},                   /* h */
    {105, 0 , 0 , 0 , 125 , 64 , 0 , 0 , 0},                    /* i */
    {106, 0 , 64 , 128 , 132 , 125 , 0 , 0 , 0},                /* j */
    {107, 0 , 127 , 16 , 40 , 68 , 0 , 0 , 0},                  /* k */
    {108, 0 , 0 , 0 , 127 , 64 , 0 , 0 , 0},                    /* l */
    {109, 0 , 124 , 4 , 24 , 4 , 120 , 0 , 0},                  /* m */
    {110, 0 , 124 , 4 , 4 , 120 , 0 , 0 , 0},                   /* n */
    {111, 0 , 56 , 68 , 68 , 68 , 56 , 0 , 0},                  /* o */
    {112, 0 , 252 , 68 , 68 , 68 , 56 , 0 , 0},                 /* p */
    {113, 0 , 56 , 68 , 68 , 68 , 252 , 0 , 0},                 /* q */
    {114, 0 , 68 , 120 , 68 , 4 , 8 , 0 , 0},                   /* r */
    {115, 0 , 8 , 84 , 84 , 84 , 32 , 0 , 0},                   /* s */
    {116, 0 , 4 , 62 , 68 , 36 , 0 , 0 , 0},                    /* t */
    {117, 0 , 60 , 64 , 32 , 124 , 0 , 0 , 0},                  /* u */
    {118, 0 , 28 , 32 , 64 , 32 , 28 , 0 , 0},                  /* v */
    {119, 0 , 60 , 96 , 48 , 96 , 60 , 0 , 0},                  /* w */
    {120, 0 , 108 , 16 , 16 , 108 , 0 , 0 , 0},                 /* x */
    {121, 0 , 156 , 160 , 96 , 60 , 0 , 0 , 0},                 /* y */
    {122, 0 , 100 , 84 , 84 , 76 , 0 , 0 , 0},                  /* z */
    {154, 0 , 8 , 85 , 86 , 85 , 32 , 0 , 0},                   /* š */
    {158, 0 , 100 , 85 , 86 , 77 , 0 , 0 , 0},                  /* ž */
    {232, 0 , 56 , 69 , 70 , 69 , 40 , 0 , 0}                   /* č */
    #endif
};

我预先选择了我要使用的哪个值。所以这可能需要以某种方式与preproccessors完成......

Answer 1

首先，我建议您创建结构列表。此外，你的显示器是8x8，但你只使用6x8（你的边框总是0），如果你用简单的char替换第一个，你就不必写评论＆＃34;什么字母是它实际上是＃34;。还有一个技巧可以添加＆＃34;终结符＆＃34; （或停止序列）到表。然后你不必知道数组的大小（我假设您正在为数组循环以找到正确的字母）。 SO：

typedef struct _dsp_letter {
  const char ascii;
  const char pixels[6];
} dsp_letter_t;

const dsp_letter_t writing[] = {
  #ifdef ARRAY1_OTHER
    {' ', { 0 , 0 , 0 , 0 , 0 , 0 } },
    {'-', { 0 , 0 , 0 , 0 , 0 , 0 } },
    {'.', { 0 , 96 , 96 , 0 , 0 , 0 } },
    {':', { 0 , 108 , 108 , 0 , 0 , 0 } },
    {'=', { 36 , 36 , 36 , 36 , 36 , 0 } },
    #endif
    // ...
    { 0 }
}

使用如下：

int i = 0;
while (writing[i].ascii != 0) {
    // do stuff, add if or anything
    ++i;
}

这种改变需要改变显示功能，但保存的内存可能是值得的。

那是一部分。现在，这就是它们之间的区别 const char str [] =＆＃34; Str＆＃34 ;; 和 const char * pStr =＆＃34; Str＆＃34 ;; ？

尺寸！

const char str[] = "My long C-style string";
const char *pStr = "My long C-style string";

printf("str: %d vs pStr: %d", sizeof(str), sizeof(pStr));
// str: 23 vs pStr: 8

const char str [] 在堆栈上分配，它实际上是数组，在写入运行时数据时。

const char * pStr 在堆上分配，在运行时只写入指向数据的指针，并且数据在应用程序的全局内存中。 / p>

这是什么意思？ onst char writting_8x8 [] [9] = {...}; 分配大量内存。在嵌入式设备上，这可以......好吧，假设我不推荐它。

怎么办？您可以将所有大数组拆分为较小的数组。

typedef struct _dsp_letter {
    const char ascii;
    const char pixels[6];
} dsp_letter_t;

#ifdef ADD_OTHER
const dsp_letter_t other[] = {
    {' ', { 0 , 0 , 0 , 0 , 0 , 0 } },
    {'-', { 0 , 0 , 0 , 0 , 0 , 0 } },
    {'.', { 0 , 96 , 96 , 0 , 0 , 0 } },
    {':', { 0 , 108 , 108 , 0 , 0 , 0 } },
    {'=', { 36 , 36 , 36 , 36 , 36 , 0 } },
    { 0 }
};
#endif ADD_OTHER

#ifdef ADD_SMALL
const dsp_letter_t small[] = {
    {'a', { 0 , 0 , 0 , 0 , 0 , 0 } },
    {'b', { 0 , 0 , 0 , 0 , 0 , 0 } },
    {'c', { 0 , 96 , 96 , 0 , 0 , 0 } },
    {'d', { 0 , 108 , 108 , 0 , 0 , 0 } },
    { 0 }
};
#endif ADD_SMALL

现在，您可以在编译时或运行时将它们全部放在一个地方

编译时（就像之前的那样）：

const dsp_letter_t *writting[] = {
#ifdef ADD_OTHER 
    other,
#endif
#ifdef ADD_SMALL 
    small,
#endif
    0
};

或运行时：

#define ADD_OTHER 1
#define ADD_SMALL 0

int size = ADD_OTHER + ADD_SMALL;
int i = 0;
dsp_letter_t **writting = (dsp_letter_t *writting(malloc)(size* sizeof (dsp_letter_t *writting));

#ifdef ADD_OTHER 
writting[i++] = other;
#endif

#ifdef ADD_SMALL 
writting[i++] = small;
#endif

你可以使用它：）

不幸的是，如果不把 #ifdef ... endif 全部放在这个地方，我就不知道如何做得更好：/

启用const数组的部分

1 个答案: