Início / coding / Perguntas / 79353235
Accepted
Mike
Asked: 2025-01-14 03:14:40 +0800 CST

Declarar array com base no tamanho de outro array

  • 772

Tenho um array de códigos de cores, cujo tamanho é conhecido em tempo de compilação. Quero declarar outro array do mesmo tamanho. Mas o código abaixo gera um erro.

Posso, é claro, declarar o tamanho como uma constante global e então usar isso na declaração de ambos os arrays. Mas não quero continuar ajustando a constante de tamanho quando adiciono novas cores. Existe uma maneira de fazer isso? (As variáveis ​​são globais.)

static const char *colors[] = {"#0000ff",
                                "#00ff00",
                                "#ff0000",
                                "#ffff00",
                                "#ff00ff",
                                "#00ffff",
                                "#ffffff",
                                "#000000",
                                "#ff8040",
                                "#c0c0c0",
                                "#808080",
                                "#804000"};

static const int NUM_COLORS = sizeof(colors) / sizeof(colors[0]);
static ColorButtons color_buttons[NUM_COLORS];
arrays

5 respostas

  1. Em C, ao contrário de C++, variáveis ​​com o qualificador constnão fazem parte de expressões constantes de tempo de compilação. E você não pode definir um array de comprimento variável com duração de armazenamento estático em um escopo de arquivo ou em um escopo de bloco com especificador de classe de armazenamento static.

    Em vez disso, você poderia escrever, por exemplo

    static enum { NUM_COLORS = sizeof(colors) / sizeof(colors[0]) };
static ColorButtons color_buttons[NUM_COLORS];

    Outra abordagem é a seguinte

    static ColorButtons color_buttons[sizeof(colors) / sizeof(colors[0])];
static const size_t NUM_COLORS = sizeof(colors) / sizeof(colors[0]);

    embora haja duas vezes em que a expressão é usada sizeof(colors) / sizeof(colors[0]).

    Ou se o seu compilador suporta C23 então

    constexpr size_t NUM_COLORS = sizeof(colors) / sizeof(colors[0]);
static ColorButtons color_buttons[NUM_COLORS];
    • 7
  2. Best Answer

    O tamanho de uma matriz de escopo de arquivo, se especificado, deve ser uma expressão constante inteira . Uma variável qualificada com constnão se qualifica como tal como expressão (isso difere de C++ que permite isso).

    Em vez de criar NUM_COLORSuma variável, crie um símbolo de pré-processador:

    #define NUM_COLORS  (sizeof(colors) / sizeof(colors[0]))

    A expressão para a qual isso se expande é uma expressão constante inteira e, portanto, pode ser usada como o tamanho de uma matriz.

    A única coisa que você precisa observar é certificar-se de não redefinir colorsem um escopo menor, onde você também usaria NUM_COLORS.

    • 5

  3. static const int NUM_COLORS- constvariáveis ​​não são expressões constantes necessárias como tamanho das matrizes de duração de armazenamento estático.

    Você precisa criar uma macrodefinição:

    #define NUM_COLORS (sizeof(colors) / sizeof(colors[0]))
    • 2

  4. Para complementar as respostas anteriores :

    #define ARRAY_SIZE(X) (sizeof X / sizeof X[0])

    Também é reutilizável.

    Se você não tiver certeza se seu array tem algum elemento (também conhecido como ponteiro nulo), você pode retornar 0 neste caso:

    #define ARRAY_SIZE(X) (X == NULL ? 0 : sizeof X / sizeof X[0])

    int  full[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int* empty  = NULL;
    
printf("full size = %u\n", ARRAY_SIZE(full));   // 10
printf("empty size = %u\n", ARRAY_SIZE(empty)); //  0
    • 1

  5. Apenas para propagar novamente para macros X - esta é uma tarefa perfeita para eles. Tudo o que você precisa fazer é manter uma lista de macros X no topo e então você pode ter literais de string, valores, contagem de itens, tabelas de consulta etc etc tudo em tempo de compilação. Bastante poderoso e sustentável, mas ao custo da legibilidade para aqueles que não estão acostumados a ler código de macro X.

    Exemplo:

    #include <stdio.h>
#include <stdint.h>

#define COLOR_LIST(X) \
/*  index  val    */  \
  X(0,     0000ff)    \
  X(1,     00ff00)    \
  X(2,     ff0000)    \

/* declare an array of strings with a certain format: */
#define COLOR_STRING(index, val) [index] = "#" #val,
static const char *color_str[] = { COLOR_LIST(COLOR_STRING) };

/* declare an enum to translate indices to values: */
#define COLOR_ENUM(index, val) color_##index = 0x##val,
typedef enum : uint32_t
{
  COLOR_LIST(COLOR_ENUM)
} color_t;

/* declare an enum for the sole purpose of counting items: */
#define COLOR_COUNT(index, val) color_count_##index,
typedef enum
{
  COLOR_LIST(COLOR_COUNT)
  NUM_COLORS
} color_count_t;


int main() 
{
  printf("Total colors: %d\n", NUM_COLORS);
  printf("[0] string: %s  value: %.6X\n", color_str[0], color_0);
  printf("[1] string: %s  value: %.6X\n", color_str[1], color_1);
  printf("[2] string: %s  value: %.6X\n", color_str[2], color_2);

  // ...or if you will
  #define COLOR_PRINT(index,val) printf("[" #index "] string: %s  value: %.6X\n", color_str[index], color_##index);
  COLOR_LIST(COLOR_PRINT)

}

    Saída:

    Total colors: 3
[0] string: #0000ff  value: 0000FF
[1] string: #00ff00  value: 00FF00
[2] string: #ff0000  value: FF0000
    • 1

relate perguntas