Thread: How do I make a function that accepts an array of objects as it's argument

You can pass an array to a function like so:

Code:

void takes_array(customer array[]) {}
customer array[9];
takes_array(array);

But it's really an alternative syntax for a pointer

Code:

void takes_array(customer *array) {}

so you can't do a sizeof() on the "array" and get the correct results. If you want to sizeof() the array, pass the size of the array to the function:

Code:

#include <cstddef>  // for size_t

void takes_array(customer array[], size_t size) {}

takes_array(array, sizeof(array) / sizeof(*array));

Actually arrays can't be passed to functions. When passed (by syntax), they will be converted to a pointer automatically. This is why sizeof() wont work there.

An array dimension should be initialized from a constant expression.

Instead of customer* array[50] you should instead consider the following:

Code:

const int size = 50;
customer* array[size];

It is then a matter of passing size as an argument to your function(s).

By passing an array to a function you still cannot ensure when the array ends. You will still have to provide the function with the array size. the number 50 by itself is a so-called magic-number and it will give you nothing but grief.

By making it a constant expression you make the definition of size central to one location. If later you need to change the size of the array, you just need to change this variable. You will not need to go to all the places where the array is being used and chenge every instance of 50 to the new dimension.

To pass your array to a function:

Code:

return_type function_name(customer* array, const int size)

where customer* array is in fact a pointer to the first position in the array. size is the size of the array. You have now all elements to properly handle the array while checking for out of bounds.

If you search the board you turn up many threads/debates on the topic. One such thread is http://cboard.cprogramming.com/showthread.php?t=82378

By making it a constant expression you make the definition of size central to one location. If later you need to change the size of the array, you just need to change this variable. You will not need to go to all the places where the array is being used and chenge every instance of 50 to the new dimension.

There's no need for an array dimension to be a constant size.

Code:

int *array = new int[lines_the_user_requested];

But either way, you can't determine the size of an array with sizeof() if that array has been passed to a function . . . you'll get the size of the pointer. It needs to be passed to the function unless you use a magic number or a global constant of some kind.

I agree that you shouldn't use "magic numbers" in your code like 50, though . . . unless you like tedious searching and replacing.

> There's no need for an array dimension to be a constant size.

It does when the array is not being dynamically allocated, which was the case at hand. There's also of course the situation where an array is initialized explicitly as in:

Code:

int array[] = {1, 2, 3};

But then and again no dimension is being given.

After C99 gets incorporated into C++, then there will be no longer this requirement.

Originally Posted by rakan

Actually, I will eventually need to make a dynamic array of objects.

I was hoping to create a function that would take the array and find the nearest empty slot with which to place the next object. That was what I was hoping to turn the function into. I figured first that it would have to accept an array.

Use std::vector and push_back() the new entries.

Use std::vector and push_back() the new entries.

std::vector: http://cppreference.com/cppvector/index.html
std::vector.push_back(): http://cppreference.com/cppvector/push_back.html