C++ make function return array cross file - c++

Question

I'm looking to make a function return an array of set size, and assign the value of that array to another array. The function is located in one file and the array I will be assigning it's return value to is located in another.
I'm attempting to do this in an SFML project. Whenever I call the array function, my program freezes and stops responding.
generate_maze.cpp:
#include <SFML/Graphics.hpp>
#include "generate_maze.h"
char* generate_maze() {
char test_maze[169] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,
0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
return test_maze;
}
extract of main.cpp:
#include <stdlib.h>
#include <stdio.h>
#include <time.h>
#include <SFML/Graphics.hpp>
#include "controls.h"
#include "generate_maze.h"
...
char* maze = generate_maze();
std::cout << (int) maze[0] << std::endl;
generate_maze.h:
char* generate_maze();
Thanks in advance for the help.

Answer 1

The code does not work because generate_maze() returns a pointer to a local variable, which is destroyed on exiting the function. To make it work one could design generate_maze() to allocate an array of char via new, then the allocated array survives after generate_maze() is finished. But that would also require to explicitly free the memory, after char *maze is no longer used.
A much better c++-like solution is the following.
If the size of the array is fixed, you should better use std::array to store the result of generate_maze(), as:
#include <array>
std::array<char, 169> generate_maze() {
return { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,
0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
}
If the size of the array returned by generate_maze() is not fixed, the correct way is to use std::vector and declare generate_maze() as
#include <vector>
std::vector<char> generate_maze();

Answer 2

generate_maze returns the address of test_maze[0], which is a local variable. You should never ever return addresses of (or references to) local variables from a function.
Allocate the maze on the heap instead and return that:
char* generate_maze() {
char local[] = {
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0,
0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0,
0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0,
0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0,
0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
char* ret = new char[sizeof local];
memcpy(ret, local, sizeof local);
return ret;
}
Alternatively, just return a std::vector which does its own memory management.
std::vector<char> generate_maze() {
return {0, 0, 0, ...};
}

Answer 3

generate_maze() returns pointer to local array, which is destroyed when function exits.
To solve this problem, you can define test_maze static: static char test_maze[].
This will create one permanent array for all generaze_maze() function calls. If you going to implement generate_maze() to return different maze arrays, better use std::vector or std::array.