Updated: Memory Location being outputted instead of desired string - c++

Question

->Please see my edited question below the horizontal divider:
I was trying to return a string array from a function to another function. The code compiled successfully; however, it failed upon execution. I have included my code below:
string Occupant::LoadDataFunction()
{
string array[5] = {"hello", "you", "are", "a", "human"};
return array[5];
}
void Occupant::LoadData()
{
string loc_array[5];
loc_array[5] = Occupant::LoadDataFunction();
string park_array[5];
park_array[5] = Occupant::LoadDataFunction();
string lease_array[5];
lease_array[5] = Occupant::LoadDataFunction();
}
When I debugged the code, I found out that the problem was in the return statement of the function:
return array[5]
The debugger had the following output:
Signal = SIGSEGV (Segmentation Fault)
this = { Occupant * const | 0x61ff2f} 0x61ff2f
array = {std::_cxx11::basic_string< char, std::char_traits, std::allocator> [5]}
Can someone tell me what is wrong with my return statement, why it is causing a segmentation error? Thanks
** I know there are many other similar questions on the web, but none of them involved a segmentation fault in the return statement Therefore, I would appreciate it if this question is not marked as a duplicate. If you need any more information, just inform me in the comments box. Thanks for your help!
EDIT Thanks everyone, I didn't notice that glitch I just fixed it. I actually wanted to return the entire array, I did it with pointers this time. Here's my code:
string* Occupant::LoadDataFunction()
{
string* array = new string[5];
array[0] = "hello";
array[1] = "hello";
array[2] = "hello";
array[3] = "hello";
array[4] = "hello";
return array;
}
void Occupant::LoadData()
{
string **loc_array = new string*[5];
loc_array[5] = Occupant::LoadDataFunction();
string **park_array = new string*[5];
park_array[5] = Occupant::LoadDataFunction();
string **lease_array = new string*[5];
lease_array[5] = Occupant::LoadDataFunction();
for (int i = 0; i < 5; i++)
{
cout << &loc_array[i] << " : location" << endl;
cout << &park_array[i] << " : parking" << endl;
cout << &lease_array[i] << " : leased" << endl;
}
}
The problem now is that when I run the code, rather than printing hello fifteen times in total, it prints the memory address. Here's what I got:
0xf56d50 : location
0xf56df8 : parking
0xf56ea0 : leased
0xf56d54 : location
0xf56dfc : parking
0xf56ea4 : leased
0xf56d58 : location
0xf56e00 : parking
0xf56ea8 : leased
0xf56d5c : location
0xf56e04 : parking
0xf56eac : leased
0xf56d60 : location
0xf56e08 : parking
0xf56eb0 : leased
I expected a "Hello" word outputted wherever a memory address is outputted. Can anyone explain this now? Thanks for all your answers!

Answer 1

To return an array, use std::array, as a std::array is copyable and assignable, unlike a vanilla array.
#include <array>
#include <algorithm>
typedef std::array<std::string, 5> Array5Strings;
Array5Strings LoadDataFunction()
{
Array5Strings ret;
std::fill(ret.begin(), ret.end(), "hello");
return ret;
}
Also, I used std::fill to quickly set the items to "hello".
Live Example
If for some weird reason you can't use std::array, then the other alternative is to create a struct that contains an array of 5 strings, and return the struct. A struct is copyable, thus can be returned directly from a function.
#include <algorithm>
#include <string>
#include <algorithm>
#include <iostream>
struct Array5Strings
{
std::string sArray[5];
};
Array5Strings LoadDataFunction()
{
Array5Strings ret;
std::fill(std::begin(ret.sArray), std::end(ret.sArray), "hello");
return ret;
}
int main()
{
Array5Strings val = LoadDataFunction();
std::cout << val.sArray[0]; // prints the first value
}
Live Example
Regardless of which you choose, note that there are no pointers involved.

Answer 2

You are accessing the arrays using out of bounds index.
When you have an array declared as:
string loc_array[5];
the valid indices are 0 - 4.
Use of
loc_array[5] = Occupant::LoadDataFunction();
is cause for undefined behavior. I suspect you meant to use:
loc_array[4] = Occupant::LoadDataFunction();
Similarly, you need to use:
park_array[4] = Occupant::LoadDataFunction();
and
lease_array[4] = Occupant::LoadDataFunction();
You also need to change Occupant::LoadDataFunction.
string Occupant::LoadDataFunction()
{
string array[5] = {"hello", "you", "are", "a", "human"};
return array[4];
}
Update
The updated implementation of of Occupant::LoadDataFunction is better but there are still problems.
Each time the function gets called, you are allocating an array of strings. It's not clear whether that's the intention. If that's the intention, then the calling code has to take responsibility for deallocating that memory.
The calling code still suffers from out our bounds memory access. The line
string **loc_array = new string*[5];
allocates memory for 5 string*. The valid indices for loc_array is still 0 - 4. Hence,
loc_array[5] = Occupant::LoadDataFunction();
suffers from out of bounds memory access problem. It's not clear how you wish to use the return value of Occupant::LoadDataFunction. Hence, I am not able to suggest a way to solve the problem.
The lines
park_array[5] = Occupant::LoadDataFunction();
lease_array[5] = Occupant::LoadDataFunction();
suffer from the same problem.

Answer 3

Try returning array[4]. There is no array[5], since arrays start at index 0.

Answer 4

The range of an array of size N is from 0 to N-1. So the 5 is out of the range. And you may want to return an array as a result, but the array is constructed in the function LoadData, after the function is executed, the array is invalid. You may use dynamic allocation for your purpose or use a global variable.
When you use the dynamic allocation array, you can just use string* instead of string**, and you should release the allocated memory.