Простое объявление / вопрос о назначении массива C

вы можете объявить статический массив с данными для инициализации:

static int initvalues[3] = {1,2,3};
…
if(1)
    memmove(values,initvalues,sizeof(values));

Вы можете выполнять множественное присвоение массива только при объявлении массива:

int values[3] = {1,2,3};

После объявления вам нужно будет присвоить каждое значение индивидуально, т.е.

if (1) 
{
  values[0] = 1;
  values[1] = 2;
  values[2] = 3;
}

Или вы можете использовать цикл, в зависимости от того, какие значения вы хотите использовать.

if (1)
{
  for (i = 0 ; i < 3 ; i++)
  { 
    values[i] = i+1;
  }
}

В C99, используя составные литералы, вы могли:

memcpy(values, (int[3]){1, 2, 3}, sizeof(int[3]));

or

int* values = (int[3]){1, 2, 3};

Также возможно скрыть memcpy, используя блочную копию структур компилятора. Это делает код уродливым из-за всех .i и i :, но, возможно, это решает вашу конкретную проблему.

typedef struct {
    int i[3];
} inta;

int main()
{
    inta d = {i:{1, 2, 3}};

    if (1)
        d = (inta){i:{4, 5, 6}};

    printf("%d %d %d\n", d.i[0], d.i[1], d.i[2]);

    return 0;
}

Есть еще такая ... :)

char S[16]="";
strncpy(S,"Zoodlewurdle...",sizeof(S)-1);

Проверьте, что произойдет, если вы объявите S [8] или S [32], чтобы понять, почему это так эффективно.

Я написал свои собственные строковые функции, основанные на логике strlcpy OpenBSD, направленные на обеспечение того, чтобы байт терминатора ДОЛЖЕН существовать в случае переполнения, а стандартный strncpy не будет этого делать, поэтому вы должны внимательно следить за тем, как вы его используете.

Вышеупомянутый метод эффективен, потому что объявление ="" at гарантирует 0 байтов повсюду, а sizeof(S)-1 гарантирует, что если вы переборщите со строкой в ​​кавычках, переданной в strncpy, вы получите усечение и отсутствие нарушения последнего 0 байта, поэтому теперь это безопасно от переполнения, И при доступе к строке позже. Я нацелил это на ANSI C, поэтому он должен быть безопасным где угодно.

Я бы опубликовал это как комментарий, но у меня недостаточно репутации. Другой (возможно, грязный) способ инициализации массива - обернуть его структурой.

#include <stdio.h>

struct wrapper { int array[3]; };

int main(){
    struct wrapper a;
    struct wrapper b = {{1, 2, 3}};

    a = b;

    printf("%i %i %i", a.array[0], a.array[1], a.array[2]);

    return 0;
}

Это работает и оптимизируется лучше в gcc с -O3 (компилятор полностью удаляет код), тогда как memcpy заставляет копировать память во всех случаях.

template <typename Array>
struct inner
{
    Array x;
};


template <typename Array>
void assign(Array& lhs, const Array& rhs)
{
    inner<Array>& l( (inner<Array>&)(lhs));
    const inner<Array>& r( (inner<Array>&)(rhs));
    l = r;
}

int main()
{
    int x[100];
    int y[100];

    assign(x, y);
}