In C99 you can assign each structure in a single line. I don't think that you can assign the array of structs in one line though.

C99 introduces compound literals. See the Dr. Dobbs article here: The New C: Compound Literals

theTest[0] = (test_t){7,8,9};
theTest[1] = (test_t){10,11,12};

You could assign to a pointer like this:

test_t* p; 
p = (test_t [2]){ {7,8,9}, {10,11,12} };

You could use memcpy as well:

memcpy(theTest, (test_t [2]){ {7,8,9}, {10,11,12} }, sizeof(test_t [2]);

Above tested with gcc -std=c99 (version 4.2.4) on linux.

You should read the Dr. Dobbs article to understand how compound literals work.

For your specific case where you initially have 0 and 1, the following might be faster. You'll have to bench mark it. You probably can't do much better with plain C though; you may need to dive into assembly if you want to take advantage of "x86 trickery" that may exist.

for(int i = 0; i < size ; i++){
  array[i] *= 123456;
}

EDIT:

Benchmark code:

#include <time.h>
#include <stdlib.h>
#include <stdio.h>

size_t diff(struct timespec *start, struct timespec *end)
{
  return (end->tv_sec - start->tv_sec)*1000000000 + end->tv_nsec - start->tv_nsec;
}

int main(void)
{
  const size_t size = 1000000;
  int array[size];

  for(size_t i=0; i<size; ++i) {
    array[i] = rand() & 1;
  }

  struct timespec start, stop;

  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
  for(size_t i=0; i<size; ++i) {
    array[i] *= 123456;
    //if(array[i]) array[i] = 123456;
  }
  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &stop);

  printf("size: %zu\t nsec: %09zu\n", size, diff(&start, &stop));
}

my results:

Computer: quad core AMD Phenom @2.5GHz, Linux, GCC 4.7, compiled with

$ gcc arr.c -std=gnu99 -lrt -O3 -march=native

• if version: ~5-10ms
• *= version: ~1.3ms

In c you can't pass a variable by reference, the array variable that you assign inside the function contains initially the same address as the passed pointer, but it's a copy of it so modifying it will not alter the passed pointer.

You need to pass the address of the pointer in order to be able to alter it, like this

// Change the pointer of the array
void change(int **array, int length)
{
    *array = malloc(length * sizeof(int));
    if (*array == NULL)
        return;
    for (int i = 0 ; i < length ; i++)
        (*array)[i] = 1;
}

Then in main() you cannot assign to an array, doing so through this kind of function is surely undefined behavior. The array defined in main() is allocated on the stack and you cannot assign anything to an array since they are non-writeable lvalues so you cannot make it point to a heap memory location obtained with malloc(), you need to pass a pointer like this

int *array;
change(&array, length);
free(array);

If you want the function to replace the previous array, it will have to free() the malloc()ed data (note that passing NULL to free() is well defined), so

// Change the pointer of the array
void change(int **array, int length)
{
    free(*array);

    *array = malloc(length * sizeof(int));
    if (*array == NULL)
        return;
    for (int i = 0 ; i < length ; i++)
        (*array)[i] = 1;
}

then in main()

int *array;
array = NULL;
change(&array, length);
change(&array, length);
change(&array, length);
change(&array, length);
free(array);

will do what you apparently want.

memcpy(myarray, (int [5]){a,b,c,d,e}, 5*sizeof(int));

Version 1:

#include <stdio.h>
#define MAX 20
typedef int Values[MAX];

int changeArr(int vals2[]) {
    vals2[0] = 200;
    vals2[1] = 100;
    printf("%d and ", vals2[0]);
    printf("%d\n", vals2[1]);
    return 0;
}   

int main (int argc, char *argv[]) {

    Values vals;
    changeArr(vals);
    printf("%d and ", vals[0]);
    printf("%d\n", vals[1]);
    return 0;

}

Instead of passing a pointer to the array, pass a pointer to the array's first element.

Version 2:

#include <stdio.h>
#define MAX 20
typedef int Values[MAX];

int changeArr(Values *vals2) {
    (*vals2)[0] = 200;
    (*vals2)[1] = 100;
    printf("%d and ", (*vals2)[0]);
    printf("%d\n", (*vals2)[1]);
    return 0;
}   

int main (int argc, char *argv[]) {

    Values vals;
    changeArr(&vals);
    printf("%d and ", vals[0]);
    printf("%d\n", vals[1]);
    return 0;

}

use parentheses to compensate for the precedence.

The problem in your code is that

*vals2[1]

is *(vals2[1]), so it dereferences a pointer one unit of Values after the passed pointer. You have no accessible memory allocated there, so it's undefined behaviour. In practice, it is the same as accessing

arr[1][0]

for an

int arr[2][MAX];

But your vals is only (equivalent to) an int arr[1][MAX];, so you are accessing out of bounds. But if nothing worse happens, *vals2[1] = 100; in changeArr sets vals[MAX] in main to 100. It may overwrite something crucial, though.

In int changeArr(Values *vals2) you are passing a pointer to an array of MAX ints, resp the first such array in an array of Values. Then vals2[1] is the second array in that array of Values (which doesn't exist here), and *vals2[1] == vals2[1][0] the first int in that second array. You want to modify elements of the first (and only) array in the pointed-to memory block, so you want to access vals2[0][1], or equivalently (*vals2)[1].

A picture:

vals2                          vals2[1]
 |                               |
 v                               v
|vals[0]|vals[1]|...|vals[MAX-1]|x

in changeArr, the pointer vals2 points to the array vals. Since it's a pointer to an int[MAX], vals2+1 points to an int[MAX] at an offset of MAX*sizeof(int) bytes after the start of vals (which is just behind the end of vals). vals2[1], or equivalently *(vals2 + 1), is that array just after vals (which doesn't exist).

You want to change vals[1], which is located in the array vals2[0], at an offset of 1*sizeof(int) bytes, so you need vals2[0][1] or equivalently (*vals2)[1].

There are fewer possibilities in C, but in case of an unsigned char and setting its values to zero you could use memset:

memset(&digit[4], 0, 4);

Demo.