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

You are definitely overthinking this one.

You only need to replace one value in the array, so find the offset, cast correctly, dereference and assign:

* (int *) ((char *) array->array + index * array->elem) = replacement_value;

Or, continue to work with memcpy when building base functionality, and use that to create further abstractions.

void array_set(Array *array, size_t index, void *data) {
    memcpy(
        (char *) array->array + index * array->elem,
        data,
        array->elem);
}

void int_array_set(Array *array, size_t index, int value)
{
    array_set(array, index, &value);
}

Might want to check that index is valid.

 for(&k==1, y > 6, y++)

I imagine this is one of the problems you are having.

First off, you need to delimit for() statements with ;.

Second, you are accessing the address of k, and checking for equality. The first part of a for statement generally sets a variable. You need to rethink your logic.

        while(x>10 && y >> 10)

>> is not he same as >, be careful.

Something else that is not exactly pertinent to your question but is interesting nonetheless, is that although arrays cannot be assigned to, structs containing arrays can be assigned to:

struct test
{
    float someArray[100];
};


struct test s1 = { /* initialise with some data*/ };
struct test s2 = { /* initialise with some other data */ };

s1 = s2; /* s1's array now contains contents of s2's array */

This also makes it possible to return fixed-length arrays of data from functions (since returning plain arrays is not allowed):

struct test FunctionThatGenerates100Floats(void)
{
    struct test result;
    for (int i = 0; i < 100; i++)
        result.someArray[i] = randomfloat();

    return result;
}