Assign array to array

Question

So I am playing around with some arrays, and I cannot figure out why this won\'t work.

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


        

Answer 1

Arrays have a variety of ugly behavior owing to C++'s backward compatibility with C. One of those behaviors is that arrays are not assignable. Use std::array or std::vector instead.

#include <array>
...
std::array<int,5> numbers = {1,2,3};
std::array<int,5> values = {};
values = numbers;

If, for some reason, you must use arrays, then you will have to copy the elements via a loop, or a function which uses a loop, such as std::copy

#include <algorithm>
...
int numbers[5] = {1, 2, 3};
int values[5] = {};
std::copy(numbers, numbers + 5, values);

As a side note, you may have noticed a difference in the way I initialized the values array, simply providing an empty initializer list. I am relying on a rule from the standard that says that if you provide an initializer list for an aggregate, no matter how partial, all unspecified elements are value initialized. For integer types, value initialization means initialization to zero. So these two are exactly equivalent:

int values[5] = {0, 0, 0, 0, 0};
int values[5] = {};

Answer 2

std::array is a good idea, but this is also possible:

struct arr { int values[5]; };

struct arr a{{1, 2, 3}};
struct arr b{{}};

a = b;

Otherwise, use std::memcpy or std::copy.

Answer 3

values = numbers; Because numbers and values are pointers.

int numbers[5] = {1, 2, 3};
int values[5] = {0, 0, 0, 0, 0};
for(int i = 0;i < 5; i ++){
    values[i] = numbers[i];
}

Answer 4

Array names are constant not modifiable l-value, you can't modify it.

values = numbers; 
// ^
// is array name

Read compiler error message: "error C2106: '=' : left operand must be l-value" an l-value is modifiable can be appear at lhs of =.

You can assign array name to a pointer, like:

int* ptr = numbers;

Note: array name is constant but you can modify its content e.g. value[i] = number[i] is an valid expression for 0 <= i < 5.

Why can't I do like that?

Basically this constrain is imposed by language, internally array name uses as base address and by indexing with base address you can access content continue memory allocated for array. So in C/C++ array names with be appear at lhs not a l-value.

Answer 5

You can't assign arrays in C++, it's stupid but it's true. You have to copy the array elements one by one. Or you could use a built in function like memcpy or std::copy.

Or you could give up on arrays, and use std::vector instead. They can be assigned.

Answer 6

I think the reason for non-assignability is that C wants to make sure that any pointers to any element in the array would pretty much always remain valid.

Think about vectors that allow dynamic resizing: the older pointers become invalid (horribly) after resizing happens automatically.

PS. With the design philosophy for vectors, the following block works well.

vector<int> v = {1, 5, 16, 8};
vector<int> v_2 = {7, 5, 16, 8};
v_2 = v;