Reason for choosing an array of one element instead of one object?

Question

I wonder about if there is a reason to use an array, consisted of one element object, instead of just to use one object.

Like, f.e.

int a[1] = {10};

instead of just

int a = 10;

---

Of course, there is a big difference in the context of accessing the value of 10 in the later code between both cases, by the use of a:

1. When a is declared as an array, like

int a[1] = {10};

a decays to a pointer to the first element object of the array of a, thus a evaluates to type int*, when a is used later in the program.

2. When a is declared as an identifier for a certain object, like

int a = 10;

a is of type int.

If we would want to pass the value of 10 to a function, we have to take attention on that and must distinguish between both uses.

But that does not answer my question for why I use the one way instead of the other one.

---

• Are there any places in C and/or C++, where an array is needed instead of just one object?
• Is there are physical difference in the size of the allocation in memory?
• Do C and C++ differ in this context?
• Is there a reason for choosing an array of one element instead of one object?

  ---

Reason for tagging with C and C++: I tagged it with both language tags because both statements are valid in C and C++, and at the actual moment, I don´t know of any difference between both languages in that case. If there is a difference, please mind it.

Thanks for your help.

Answer 1

In my opinion there is no point in declaring an array for one object. I would strongly recommend to use the basic: a = 10 ;

Answer 2

Are there any places in C and/or C++, where an array is needed instead of just one object?

I think you mostly will encounter a C-style array with one object as the end-case of a recursive function on one object. If you have a function that takes an array in a C-like manner (f(int* array, int length)) you could use this to apply the function to only one input without providing another overload. But you could do the same with int a = 42; f(&a, 1);.

Is there are physical difference in the size of the allocation in memory?

No. int a[1] = {42} and int a = 42 do exactly the same to the stack.

Do C and C++ differ in this context?

No.

Why do I use an array of one element instead of just one object?

An array with compile-time size of 1 (like you did above) is probably used very little. There is a difference between

int a[1] = {42};
// and
int b = 42;
int *a = &b;

since an array is not a pointer but only decays to one. But the difference in using them is very minor. The most notable difference in using them (thx @Scheff) should be that you can use std::begin(a) and std::end(a) on int a[1] but not on int *a. This is only a difference in C++. Note that this disappears once the array has decayed to a pointer. Then you substitute them by a and a+1 respectively.

I could imagine, that one do int a[1] = {42};, if one wants to initialize an object on the stack and directly have a pointer to it (and not really use the value itself), since it is a bit shorter. But I have never seen that myself and I would actually consider it bad style. I would think that it would be very uncommon in C++ code, since raw-pointers themselves are not that common.

I have actually more often seen an array of length 0, see for usage here. Since those seem to be technically illegal in older versions of C are invalid in C (thx for the comments), one could use an array of length 1 to be legal. But to the best of my knowledge, most compilers implemented 0 length arrays since pretty much forever, so most people would probably ignore that and use a 0 length array.

Answer 3

Are there any places in C and/or C++, where an array is needed instead of just one object?

Why do I use an array of one element instead of just one object?

There are many functions that can work on arrays, that take a pointer argument. However, as machine_1 already pointed out, you can easily get the pointer to a regular object and pass that to a function.

There are a few cases where it does make a difference though. In C++, if you would want to use range-for to iterate over a number of objects, you can write:

int a[1] = {42};
for (auto &value: a)
     ...

But you can't write:

int a = 42;
for (auto &value: a)
     ...

The above example looks silly on its own, but it becomes a real problem when you define generic functions using templates. So sometimes you'd want to store a value in an array of length 1 just to make it easier to use those functions.

In C99 and later, but not in C++, you can also use flexible array members. Such members work like arrays, but they take up no space, as if they have zero length. Consider having a network packet with a header and a variable amount of data. A struct that represents a packet could look like:

struct packet {
    address_t source;
    address_t destination;
    size_t length;
    char data[]; // flexible array member
};

One would allocate memory for such a struct like so:

size_t data_length;
...
struct packet *pkt = malloc(sizeof(*pkt) + data_length);

And then one can read and write to the data portion like so:

for (size_t i = 0; i < data_length; i++)
     pkt->data[i] = ...;

You don't need the data[] array here, since you could also access the data by doing something like ((char *)pkt + sizeof(*pkt))[i], using an array member at the end of the struct allows writing much more compact, readable and safe code.

It is possible to do a similar trick in C++ by using an array of length 1.

Is there are physical difference in the size of the allocation in memory?

No.

Do C and C++ differ in this context?

No.

Answer 4

Sometimes a function written for the common case will mean taking an array, for example in C you might have something like :

#define CULL_OBJECTS(objs) {\ 
           for(int i = 0; i < sizeof(objs)/sizeof(objs[0]); ++i)\ 
           {\ 
                ++culled_objects;\ 
                cull_subobjects(objs[i]);\ 
           }\

or in C++ :

template<typename T>
void CullObjects(T& objs)
{
    for(int i = 0; i < sizeof(objs)/sizeof(objs[0]); ++i)
    {
        ++culled_objects;
        cull_subobjects(objs[i]);
    }
}

Which could either be called by passing Obj objArr[1000] or Obj obj[1].

Answer 5

You should not declare an array consisting of one object. If you need a single variable, then declare it as such. But to answer your question, one would want to write something like:

int a[1];

probably for convenience when working with functions that take a pointer as an argument. Take for example the function memset() declared as:

void * memset (void *ptr, int value, size_t num );

If you declare a single variable and want to use memset() on it, the you must call it as:

int a;
memset(&a, val, sizeof(int));

whilst if you declare a as int a[1], then you'd call it as:

memset(a, val, sizeof(int));

However, the former use is for doing something either weird or unusual!

Answer 6

There is no reason to use int a[1]; instead of int a;. Use &a to pass the pointer to it when needed. Other people will be very confused with int a[1]; if you ever write it - it will look like a bug.

Then you probably ask why would it be even needed in the language?

This is simple. Say you want a fixed array of size N, e.g., int a[N]; and you don't know the value of N. This is either a macro, result of a constexpr computation, or parameter of a template. Thus int a[1] needs to be supported for it to work.