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

I have made an array of objects. I've started by defining a class and making an array containing pointers to that class type. Then I initialized each pointer to NULL.

What I would like to do from here is pass the array to a function that will tell me how many classes are stored in the array. How would I go about doing this? Is it possible to pass an array to a function? Thanks.

Here is my code:

Code:

#include <iostream>
#include <cstring>
using namespace std;

class customer{
      public:
            customer( string );
      private:
              string name;
};

customer::customer( string x ){
                    name = x;
}



int main(){
    customer * array[50]; //create array of pointers to customer objects
    customer fry ( "fry" );
    customer bender ( "bender" );
    
    for( int c = 0; c < 50; c++ ){ //initialize to NULL
         array[c] = NULL;
    }
    
    array[23] = &fry;
    
    return 0;
}

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 Passing an array into a function

In C++ you would normally use a vector which keeps track of its own size. Also, with a vector you can just push_back the customers that exist. If you need the customer to be at a certain index (like 23), then a map might also be appropriate.

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.

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.

>> Actually, I will eventually need to make a dynamic array of objects.
Then you really should use vector. A dynamic array should always be passed by pointer, and you have to pass the size explicitly along with it.

BTW, you #include <cstring> but you use the C++ string class. The correct header should be <string>.

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