Como inicializar todos os membros de uma matriz para o mesmo valor?

Eu tenho uma grande matriz em C (não C ++, se isso faz a diferença). Eu quero inicializar todos os membros do mesmo valor.

Eu poderia jurar que uma vez soube uma maneira simples de fazer isso. Eu poderia usar memset()no meu caso, mas não existe uma maneira de fazer isso incorporada diretamente à sintaxe C?

A menos que esse valor seja 0 (nesse caso, você pode omitir parte do inicializador e os elementos correspondentes serão inicializados como 0), não há uma maneira fácil.

Não negligencie a solução óbvia:

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 };

Os elementos com valores ausentes serão inicializados em 0:

int myArray[10] = { 1, 2 }; // initialize to 1,2,0,0,0...

Portanto, isso inicializará todos os elementos para 0:

int myArray[10] = { 0 }; // all elements 0

No C ++, uma lista de inicialização vazia também inicializará todos os elementos para 0. Isso não é permitido com C:

int myArray[10] = {}; // all elements 0 in C++

Lembre-se de que objetos com duração de armazenamento estático serão inicializados como 0 se nenhum inicializador for especificado:

static int myArray[10]; // all elements 0

E que "0" não significa necessariamente "todos os bits-zero", portanto, usar o acima é melhor e mais portátil que memset (). (Os valores de ponto flutuante serão inicializados em +0, ponteiros para valor nulo etc.)

Se o seu compilador for o GCC, você poderá usar a seguinte sintaxe:

int array[1024] = {[0 ... 1023] = 5};

Confira a descrição detalhada: http://gcc.gnu.org/onlinedocs/gcc-4.1.2/gcc/Designated-Inits.html

Para inicializar estaticamente uma grande matriz com o mesmo valor, sem várias copiar e colar, você pode usar macros:

#define VAL_1X     42
#define VAL_2X     VAL_1X,  VAL_1X
#define VAL_4X     VAL_2X,  VAL_2X
#define VAL_8X     VAL_4X,  VAL_4X
#define VAL_16X    VAL_8X,  VAL_8X
#define VAL_32X    VAL_16X, VAL_16X
#define VAL_64X    VAL_32X, VAL_32X

int myArray[53] = { VAL_32X, VAL_16X, VAL_4X, VAL_1X };

Se você precisar alterar o valor, precisará fazer a substituição em apenas um local.

Editar: possíveis extensões úteis

(cortesia de Jonathan Leffler )

Você pode generalizar isso facilmente com:

#define VAL_1(X) X
#define VAL_2(X) VAL_1(X), VAL_1(X)
/* etc. */

Uma variante pode ser criada usando:

#define STRUCTVAL_1(...) { __VA_ARGS__ }
#define STRUCTVAL_2(...) STRUCTVAL_1(__VA_ARGS__), STRUCTVAL_1(__VA_ARGS__)
/*etc */ 

que trabalha com estruturas ou matrizes compostas.

#define STRUCTVAL_48(...) STRUCTVAL_32(__VA_ARGS__), STRUCTVAL_16(__VA_ARGS__)

struct Pair { char key[16]; char val[32]; };
struct Pair p_data[] = { STRUCTVAL_48("Key", "Value") };
int a_data[][4] = { STRUCTVAL_48(12, 19, 23, 37) };

nomes de macro são negociáveis.

Se você deseja garantir que todos os membros da matriz sejam explicitamente inicializados, apenas omita a dimensão da declaração:

int myArray[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };

O compilador deduzirá a dimensão da lista de inicializadores. Infelizmente, para matrizes multidimensionais, apenas a dimensão mais externa pode ser omitida:

int myPoints[][3] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

está bem, mas

int myPoints[][] = { { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9} };

não é.

Eu vi algum código que usava esta sintaxe:

char* array[] = 
{
    [0] = "Hello",
    [1] = "World"
};   

Onde isso se torna particularmente útil é se você estiver criando uma matriz que usa enumerações como índice:

enum
{
    ERR_OK,
    ERR_FAIL,
    ERR_MEMORY
};

#define _ITEM(x) [x] = #x

char* array[] = 
{
    _ITEM(ERR_OK),
    _ITEM(ERR_FAIL),
    _ITEM(ERR_MEMORY)
};   

Isso mantém as coisas em ordem, mesmo que você escreva alguns valores enum fora de ordem.

Mais sobre esta técnica pode ser encontrada aqui e aqui .

int i;
for (i = 0; i < ARRAY_SIZE; ++i)
{
  myArray[i] = VALUE;
}

Eu acho que isso é melhor do que

int myArray[10] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5...

caso o tamanho da matriz seja alterado.

Você pode fazer toda a coisa do inicializador estático, conforme detalhado acima, mas pode ser uma chatice quando o tamanho da sua matriz muda (quando sua matriz embiggens, se você não adicionar os inicializadores extras apropriados, obterá lixo).

O memset fornece um hit de tempo de execução para o trabalho, mas nenhum hit de tamanho de código feito corretamente é imune a alterações no tamanho da matriz. Eu usaria essa solução em quase todos os casos em que a matriz era maior do que, digamos, algumas dezenas de elementos.

Se fosse realmente importante que a matriz fosse declarada estaticamente, eu escreveria um programa para escrever o programa para mim e fazer parte do processo de compilação.

Aqui está outra maneira:

static void
unhandled_interrupt(struct trap_frame *frame, int irq, void *arg)
{
    //this code intentionally left blank
}

static struct irqtbl_s vector_tbl[XCHAL_NUM_INTERRUPTS] = {
    [0 ... XCHAL_NUM_INTERRUPTS-1] {unhandled_interrupt, NULL},
};

Vejo:

Extensões C

Unidades designadas

Em seguida, faça a pergunta: quando alguém pode usar extensões C?

O exemplo de código acima está em um sistema incorporado e nunca verá a luz de outro compilador.

Para inicializar tipos de dados 'normais' (como matrizes int), você pode usar a notação de colchete, mas zerará os valores após o último se ainda houver espaço na matriz:

// put values 1-8, then two zeroes
int list[10] = {1,2,3,4,5,6,7,8};

Se a matriz for int ou qualquer coisa com o tamanho de int ou o tamanho do seu padrão de mem se encaixar vezes exatas em um int (ou seja, todos os zeros ou 0xA5A5A5A5), a melhor maneira é usar memset () .

Caso contrário, chame memcpy () em um loop para mover o índice.

Uma resposta levemente explícita; escreva a declaração

array = initial_value

na sua linguagem favorita de capacidade de array (a minha é Fortran, mas existem muitas outras) e vincule-a ao seu código C. Você provavelmente desejaria agrupá-lo para ser uma função externa.

Existe uma maneira rápida de inicializar uma matriz de qualquer tipo com determinado valor. Funciona muito bem com matrizes grandes. O algoritmo é o seguinte:

• inicialize o primeiro elemento da matriz (maneira usual)
• copiar parte que foi ajustada em parte que não foi ajustada, dobrando o tamanho a cada próxima operação de cópia

Para a matriz de 1 000 000elementos int, é 4 vezes mais rápido que a inicialização normal do loop (i5, 2 núcleos, 2,3 GHz, memória 4GiB, 64 bits):

loop runtime 0.004248 [seconds]

memfill() runtime 0.001085 [seconds]

#include <stdio.h>
#include <time.h>
#include <string.h>
#define ARR_SIZE 1000000

void memfill(void *dest, size_t destsize, size_t elemsize) {
   char   *nextdest = (char *) dest + elemsize;
   size_t movesize, donesize = elemsize;

   destsize -= elemsize;
   while (destsize) {
      movesize = (donesize < destsize) ? donesize : destsize;
      memcpy(nextdest, dest, movesize);
      nextdest += movesize; destsize -= movesize; donesize += movesize;
   }
}    
int main() {
    clock_t timeStart;
    double  runTime;
    int     i, a[ARR_SIZE];

    timeStart = clock();
    for (i = 0; i < ARR_SIZE; i++)
        a[i] = 9;    
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("loop runtime %f [seconds]\n",runTime);

    timeStart = clock();
    a[0] = 10;
    memfill(a, sizeof(a), sizeof(a[0]));
    runTime = (double)(clock() - timeStart) / (double)CLOCKS_PER_SEC;
    printf("memfill() runtime %f [seconds]\n",runTime);
    return 0;
}

Ninguém mencionou a ordem do índice para acessar os elementos da matriz inicializada. Meu código de exemplo fornecerá um exemplo ilustrativo.

#include <iostream>

void PrintArray(int a[3][3])
{
    std::cout << "a11 = " << a[0][0] << "\t\t" << "a12 = " << a[0][1] << "\t\t" << "a13 = " << a[0][2] << std::endl;
    std::cout << "a21 = " << a[1][0] << "\t\t" << "a22 = " << a[1][1] << "\t\t" << "a23 = " << a[1][2] << std::endl;
    std::cout << "a31 = " << a[2][0] << "\t\t" << "a32 = " << a[2][1] << "\t\t" << "a33 = " << a[2][2] << std::endl;
    std::cout << std::endl;
}

int wmain(int argc, wchar_t * argv[])
{
    int a1[3][3] =  {   11,     12,     13,     // The most
                        21,     22,     23,     // basic
                        31,     32,     33  };  // format.

    int a2[][3] =   {   11,     12,     13,     // The first (outer) dimension
                        21,     22,     23,     // may be omitted. The compiler
                        31,     32,     33  };  // will automatically deduce it.

    int a3[3][3] =  {   {11,    12,     13},    // The elements of each
                        {21,    22,     23},    // second (inner) dimension
                        {31,    32,     33} };  // can be grouped together.

    int a4[][3] =   {   {11,    12,     13},    // Again, the first dimension
                        {21,    22,     23},    // can be omitted when the 
                        {31,    32,     33} };  // inner elements are grouped.

    PrintArray(a1);
    PrintArray(a2);
    PrintArray(a3);
    PrintArray(a4);

    // This part shows in which order the elements are stored in the memory.
    int * b = (int *) a1;   // The output is the same for the all four arrays.
    for (int i=0; i<9; i++)
    {
        std::cout << b[i] << '\t';
    }

    return 0;
}

A saída é:

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

a11 = 11                a12 = 12                a13 = 13
a21 = 21                a22 = 22                a23 = 23
a31 = 31                a32 = 32                a33 = 33

11      12      13      21      22      23      31      32      33

Cortando toda a conversa, a resposta curta é que, se você ativar a otimização em tempo de compilação, não fará melhor que isso:

int i,value=5,array[1000]; 
for(i=0;i<1000;i++) array[i]=value; 

Bônus adicionado: o código é realmente legível :)

1. Se sua matriz for declarada como estática ou global, todos os elementos na matriz já terão o valor padrão padrão 0.
2. Alguns compiladores configuram o padrão da matriz como 0 no modo de depuração.
3. É fácil definir o padrão como 0: int array [10] = {0};
4. No entanto, para outros valores, você usa memset () ou loop;

exemplo: matriz int [10]; memset (matriz, -1, 10 * sizeof (int));

#include<stdio.h>
int main(){
int i,a[50];
for (i=0;i<50;i++){
    a[i]=5;// set value 5 to all the array index
}
for (i=0;i<50;i++)
printf("%d\n",a[i]);
   return 0;
}

Ele dará o / p 5 5 5 5 5 5 ...... até o tamanho de toda a matriz

Sei que o usuário Tarskirespondeu a essa pergunta de maneira semelhante, mas adicionei mais alguns detalhes. Perdoe parte do meu C porque estou um pouco enferrujado, pois estou mais inclinado a querer usar o C ++, mas aqui está.

Se você souber o tamanho da matriz antes do tempo ...

#include <stdio.h>

typedef const unsigned int cUINT;
typedef unsigned int UINT;

cUINT size = 10;
cUINT initVal = 5;

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal );
void printArray( UINT* myArray ); 

int main() {        
    UINT myArray[size]; 
    /* Not initialized during declaration but can be
    initialized using a function for the appropriate TYPE*/
    arrayInitializer( myArray, size, initVal );

    printArray( myArray );

    return 0;
}

void arrayInitializer( UINT* myArray, cUINT size, cUINT initVal ) {
    for ( UINT n = 0; n < size; n++ ) {
        myArray[n] = initVal;
    }
}

void printArray( UINT* myArray ) {
    printf( "myArray = { " );
    for ( UINT n = 0; n < size; n++ ) {
        printf( "%u", myArray[n] );

        if ( n < size-1 )
            printf( ", " );
    }
    printf( " }\n" );
}

Existem algumas ressalvas acima; uma é que UINT myArray[size];não é inicializada diretamente na declaração; no entanto, o próximo bloco de código ou chamada de função inicializa cada elemento da matriz com o mesmo valor desejado. A outra ressalva é que você teria que escrever um initializing functionpara cada um dos quais typevocê apoiará e também teria que modificar a printArray()função para suportar esses tipos.

Você pode tentar esse código com um complier online encontrado aqui .

Para inicialização atrasada (isto é, inicialização do construtor do membro da classe), considere:

int a[4];

unsigned int size = sizeof(a) / sizeof(a[0]);
for (unsigned int i = 0; i < size; i++)
  a[i] = 0;

Eu sei que a pergunta original menciona explicitamente C e não C ++, mas se você (como eu) veio aqui procurando uma solução para matrizes C ++, aqui está um truque:

Se o seu compilador suportar expressões de dobra , você poderá usar a mágica do modelo e std::index_sequencegerar uma lista de inicializadores com o valor desejado. E você pode equilibrar constexpre se sentir como um chefe:

#include <array>

/// [3]
/// This functions's only purpose is to ignore the index given as the second
/// template argument and to always produce the value passed in.
template<class T, size_t /*ignored*/>
constexpr T identity_func(const T& value) {
    return value;
}

/// [2]
/// At this point, we have a list of indices that we can unfold
/// into an initializer list using the `identity_func` above.
template<class T, size_t... Indices>
constexpr std::array<T, sizeof...(Indices)>
make_array_of_impl(const T& value, std::index_sequence<Indices...>) {
    return {identity_func<T, Indices>(value)...};
}

/// [1]
/// This is the user-facing function.
/// The template arguments are swapped compared to the order used
/// for std::array, this way we can let the compiler infer the type
/// from the given value but still define it explicitly if we want to.
template<size_t Size, class T>
constexpr std::array<T, Size> 
make_array_of(const T& value) {
    using Indices = std::make_index_sequence<Size>;
    return make_array_of_impl(value, Indices{});
}

// std::array<int, 4>{42, 42, 42, 42}
constexpr auto test_array = make_array_of<4/*, int*/>(42);
static_assert(test_array[0] == 42);
static_assert(test_array[1] == 42);
static_assert(test_array[2] == 42);
static_assert(test_array[3] == 42);
// static_assert(test_array[4] == 42); out of bounds

Você pode dar uma olhada no código no trabalho (na Wandbox)

Não vejo requisitos na pergunta, portanto a solução deve ser genérica: inicialização de uma matriz multidimensional possivelmente não especificada, construída a partir de elementos de estrutura não especificados com um valor inicial de membro:

#include <string.h> 

void array_init( void *start, size_t element_size, size_t elements, void *initval ){
  memcpy(        start,              initval, element_size              );
  memcpy( (char*)start+element_size, start,   element_size*(elements-1) );
}

// testing
#include <stdio.h> 

struct s {
  int a;
  char b;
} array[2][3], init;

int main(){
  init = (struct s){.a = 3, .b = 'x'};
  array_init( array, sizeof(array[0][0]), 2*3, &init );

  for( int i=0; i<2; i++ )
    for( int j=0; j<3; j++ )
      printf("array[%i][%i].a = %i .b = '%c'\n",i,j,array[i][j].a,array[i][j].b);
}

Resultado:

array[0][0].a = 3 .b = 'x'
array[0][1].a = 3 .b = 'x'
array[0][2].a = 3 .b = 'x'
array[1][0].a = 3 .b = 'x'
array[1][1].a = 3 .b = 'x'
array[1][2].a = 3 .b = 'x'

EDIT: start+element_sizealterado para(char*)start+element_size

De volta ao dia (e não estou dizendo que é uma boa ideia), definiríamos o primeiro elemento e depois:

memcpy (&element [1], &element [0], sizeof (element)-sizeof (element [0]);

Nem tenho certeza de que funcionaria mais (isso dependeria da implementação do memcpy), mas funciona copiando repetidamente o elemento inicial para o próximo - até funciona para matrizes de estruturas.

Se você quer dizer em paralelo, acho que o operador de vírgula quando usado em conjunto com uma expressão pode fazer isso:

a[1]=1, a[2]=2, ..., a[indexSize]; 

ou se você quer dizer em uma única construção, você pode fazer isso em um loop for:

for(int index = 0, value = 10; index < sizeof(array)/sizeof(array[0]); index++, value--)
  array[index] = index;

// Observe que o operador de vírgula em uma lista de argumentos não é o operador paralelo descrito acima;

Você pode inicializar uma decleração de matriz:

array[] = {1, 2, 3, 4, 5};

Você pode fazer uma chamada para malloc / calloc / sbrk / alloca / etc para alocar uma região fixa de armazenamento para um objeto:

int *array = malloc(sizeof(int)*numberOfListElements/Indexes);

e acesse os membros por:

*(array + index)

Etc.