C++ return array from function

Question

I need to read in an array to my function, extract the data, and then return an array from the function.

The array will only ever hold 2 values.

This is what I want to do in concept:

int myfunction(int my_array[1])
{
    int f_array[1];
    f_array[0] = my_array[0];
    f_array[1] = my_array[1];

    // modify f_array some more

    return f_array;
}

I've read up about pointers etc but have got very confused and would appreciate a really basic example of how best to approach this!

Thanks!

Solution 1

You can't return n builtin array in c++.

If you are new to c++ and get confused about pointers you really don't want to use arrays (at least not builtin arrays). Use std::vector<int> instead, or if you only ever have a certain number of elements and want to express that (and really need the better performance) use boost::array<int, N>.(or even std::array<int, N>, if you program in C++11 (if you don't know whether or not you program in C++11 chances are that you don't). For example:

std::vector<int> myfunction(const std::vector<int>& my_array) {
  std::vector<int> f_array;
  for(int i = 0; i < my_array.size(); ++i)
    f_array.push_back(my_array[i]);
  return f_array;
}

boost::array<int, 2> myfunction(const boost::array<int, 2>& my_array) {
  boost::array<int, 2> f_array;
  f_array[0] = my_array[0];
  f_array[1] = my_array[1];
  return f_array;
}

You can then make your copying code simpler (look up the constructors and memberfunctions of whatever class you decide to use, as well as STL algorithms). Example:

std::vector<int> myfunction(const std::vector<int>& my_array) {
  std::vector<int> f_array(m_array);
  ...
  return f_array;
}

As another point your code has a bug in it: you define my_array as int my_array[1], meaning its an array with one element, but you access two elements (my_array[0] and my_array[1]), the access to my_array[1] is out of bounds (int foo[N] has place for N items, starting at index 0 and going to index N-1). I assume you really mean int my_array[2].

Solution 2

std::array<int,2> myfunction(int * my_array)
{
    std::array<int,2> f_array;
    f_array[0] = my_array[0];
    f_array[1] = my_array[1];

    // modify f_array some more

    return f_array;
}

Note that as a parameter, int my_array[1] is exactly identical to int my_array[1000], int my_array[] or int * my_array. It's just a pointer, and the size value is meaningless. This doesn't apply to regular array declarations, just parameters.

To ensure that you're only being passed arrays of size 2, you can take the array by reference:

std::array<int,2> myfunction(int (&my_array)[2])

Solution 3

You can't return an array from a function, but you can add a second argument for the "out" array:

void foo(int array_in[], int array_out[], int array_size)
{
    for (int i = 0; i < array_size; i++)
        array_out[i] = array_in[i];
}

Solution 4

If you will have strictly 2 elements in array I suggest std::pair

typedef std::pair<int,int> int_pair;

int_pair myfunction(int_pair ip)
{
  ip.first *= 0.12;
  ip.second -= 355; 
  return ip;
}

Solution 5

If you ever only need two values I would have a look at std::pair, after all, that's what it's there for. It also have the proper copy (move in c++11) semantics to make this work correctly.

View more solutions

Comments

[Mike Seymour]

@fefe: because you might want to avoid an unnecessary memory allocation. std::array, or a struct containing an array, would be more efficient if the size is known at compile time.

[UncleBens]

This particular array has room for only one item. An array stores as many items as it says, not one more than asked for.

[Mike Webb]

Whatever way you choose to do this make sure you still learn pointers because they are a very important concept.

[Matthieu M.]

To emphasize this UncleBens' point, when you are declaring an array, you declare the numbers of items it contains: in int a[N], a is an array containing N elements. When then use indexes to refer to elements, you index from 0 to N-1. The address a + N exists, but it refers to one past the end of the array and no element lives there. It should not be accessed with a[N], or daemons will fly out of your nose.

[filmor]

And if you have access to a current C++ compiler that implements the move-semantics from C++11, familiarise yourself with it as it will kill almost completely any performance overhead that comes with easy solutions like this.

[Grizzly]

@filmor: actually it might not make a difference, since (at least in such an easy example) the compiler can probably do Named Return Value Optimization and completely omit the copy (or move in C++11) anyways

[Niklas B.]

You could also take a value argument here, and you'd get the copy for free :)

[ali_bahoo]

@NiklasBaumstark: Yeah, I like that, but OP cannot pass const pairs as he needs to modify it.

[Niklas B.]

I meant more like myfunction(int_pair ip).

[ali_bahoo]

@NiklasBaumstark: OK and I meant that const int_pair ip(std::make_pair(0,0)); myfunction(ip); will not compile.

[Niklas B.]

Well in that case you should get a standards-compliant compiler.

[ali_bahoo]

@NiklasBaumstark: ok ok I get it now. It will be copied, regardless of the const. Modifying the answer.