18

I know in C that I can do the following.

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

Now this is only legal when declaring the array. However I was wondering why this is not legal to do later? But then later in the program it is not legal to do the following.

test[5] = {10, 20, 30, 40, 50};

Or something similar. Why is this? I know it's not legal, and I'm not complaining, but could someone give me a more technical explanation of why I can't do this? (i.e. don't just say the C spec does not allow it or something like that)

I'm assuming it has to do something with the time when memory gets allocated on the stack for the array, so at that point C can auto fill in my values, but then why can't it do it later?

Thanks guys

John
  • 646
  • 2
  • 10
  • 16
  • 2
    So if, hypothetically, it was the case that the C standard just would not allow this (although it would be technically possible), we'd have to make something different up instead? Or would you prefer not to get an answer at all? Just want to be sure. – Niklas B. Mar 05 '12 at 15:05
  • 1
    @NiklasB.: I guess in that case a well-argued educated guess as to *why* the designers of the C language decided to omit this feature would be fine as an answer. – Heinzi Mar 05 '12 at 15:07
  • It seems like it would be possible for that to work, but I'm not sure why you would want to do it. – Vaughn Cato Mar 05 '12 at 15:17

5 Answers5

21

It's not just arrays, you cannot provide an initializer for anything at any point other than in a definition. People sometimes refer to the second statement of something like int i; i = 0; as "initializing i". In fact it's assigning to i, which previously holds an indeterminate value because it wasn't initialized. It's very rarely confusing to call this "initializing", but as far as the language is concerned there's no initializer there.

Assignment and initialization are separate things to the language, even though they both use the = character. Arrays are not assignable.

The reason arrays are not assignable is covered elsewhere, for example Why does C++ support memberwise assignment of arrays within structs, but not generally?. The short answer is, "historical reasons". I don't think there's any killer technical reason why the language could not be changed to allow array assignment.

There's a secondary issue, that grammatically {1, 2, 3, 4, 5} is an initializer, not an array literal, and hence could not be used in assignment even if arrays were assignable. I'm not sure exactly why C89 doesn't have array literals, probably just nobody got around to requiring them. C99 introduces a syntax for "compound literals" in general and array literals in particular: (int[]) {1, 2, 3, 4, 5}. You still can't assign to an array from it.

Community
  • 1
  • 1
Steve Jessop
  • 265,622
  • 35
  • 449
  • 690
8

The point is that using int array[]={ } is declaring and initializing the object that you have created.

You can actually assign values to an array after it has been declared:

int array[5];
array[0] = 1, array[1] = 2, ...

What you were doing was assigning several values to one single array entry:

array[5] = {1,2,3,4,5}; // array[5] can only contain one value

This would be legal instead:

array[5] = 6;

Hope this makes sense. Just a question of syntax.

Gil
  • 3,239
  • 1
  • 14
  • 24
5

Here's The Solution

//Declaration
int a[5];
int a_temp[5] = {1, 2, 3, 4, 5 };
memcpy(a, a_temp, sizeof(a));
//Now array a have values 1, 2, 3, 4, 5
Siraj Alam
  • 7,620
  • 6
  • 46
  • 63
5

Note that the C99 compound literal allows you to 'pass arrays to functions':

int your_func(int *test)
{
    ...use test as an array...
}

void other_func(void)
{
    int x = rand();
    if (your_func((int[]){ 0, 1, 2, x, 3, 4 }) > 0 ||
        your_func((int[]){ 9, x, 8, 7, 6, 5 }) > 0)
        ...whatever...
}

This isn't the same as re-initializing an array with different values, but it may be sufficiently close that it works for you.

Jonathan Leffler
  • 698,132
  • 130
  • 858
  • 1,229
0

The reason for that at the surface is that arrays are almost everywhere converted to a pointer to the first element. If you have two arrays

double A[5];
double B[5];

in an expression such as

A = B;

both are already converted to pointers. The A on the left is in particular not an "lvalue" so you can't assign to it.

This sounds like a lame excuse, but my guess is that historically it just happened like that. C (and C++ with it) was trapped in an early syntax choice and if you want to stay compatible with legacy code there is probably not much way out of it.

Jens Gustedt
  • 74,635
  • 5
  • 99
  • 170
  • Do you have any citation that this was the reason behind the design decision? – David Heffernan Mar 05 '12 at 18:53
  • @DavidHeffernan, no unfortunately not, otherwise I would have given it. In C11, 6.7.1 p6 (plus footnote) still shows that this obligation to convert to a pointer is taken as very basic feature of arrays. I think this is unfortunate, in particular assignment and designators would be good features to have. But it would be unrealistic to expect such a modification to happen. – Jens Gustedt Mar 06 '12 at 07:23
  • But without citation this is speculation. And I can't actually see a technical reason why assignment of arrays could not be implemented. – David Heffernan Mar 06 '12 at 07:35
  • @DavidHeffernan, I said it like that, I thought in English the usage of "I guess" has exactly that meaning, marking a statement as speculative. And I can't see a real technical reason either, but that that they probably wanted the interpretation be as simple as possible. If you'd like we could create an initiative "make C arrays first class citizens", it should be not too difficult to come up with some proposals, as I said, for designators and assignment, and perhaps for initialization, too. – Jens Gustedt Mar 06 '12 at 08:29