How to access a local variable from a different function using pointers?

You can't access a local variable once it goes out of scope. This is what it means to be a local variable.

When you are accessing the array in the replaceNumberAndPrint function the result is undefined. The fact it appears to work first time is just a fortunate coincidence. Probably the memory location you are pointing to is unallocated on the stack and is still correctly set for the first call, but the call to printf then overwrites this by pushing values onto the stack during its operation which is why the second call to printf displays something different.

You need to store the array data on the heap and pass a pointer, or in a variable that remains in scope (e.g. a global or something scoped within the main function).

Try something like that. The way you do it "kills" myArray cause if it locally defined.

#include <stdio.h> #include <stdlib.h> void replaceNumberAndPrint(int * array) { printf("%i\n", array[0]); printf("%i\n", array[1]); printf("%i\n" , array[2]); free(array); } int * getArray() { int * myArray = malloc(sizeof(int) * 3); myArray[0] = 4; myArray[1] = 64; myArray[2] = 23; //{4, 65, 23}; return myArray; } int main() { replaceNumberAndPrint(getArray()); } 

More : http://www.cplusplus.com/reference/clibrary/cstdlib/malloc/

Edit: As Comments correctly pointed out: A better way to do it would be that :

#include <stdio.h> #include <stdlib.h> void replaceNumberAndPrint(int * array) { if(!array) return; printf("%i\n", array[0]); printf("%i\n", array[1]); printf("%i\n" , array[2]); } int * createArray() { int * myArray = malloc(sizeof(int) * 3); if(!myArray) return 0; myArray[0] = 4; myArray[1] = 64; myArray[2] = 23; return myArray; } int main() { int * array = createArray(); if(array) { replaceNumberAndPrint(array); free(array); } return 0; } 

myArray goes out of scope as soon as you leave getArray. You need to allocate space for it on the heap instead.

Your code invokes Undefined Behaviour because myArray goes out of scope as soon as getArray() returns and any attempt to use (dereference) the dangling pointer is UB.

Local variables go out of scope upon return, so you can't return a pointer to a local variable.

You need to allocate it dynamically (on the heap), using malloc or new. Example:

int *create_array(void) { int *array = malloc(3 * sizeof(int)); assert(array != NULL); array[0] = 4; array[1] = 65; array[2] = 23; return array; } void destroy_array(int *array) { free(array); } int main(int argc, char **argv) { int *array = create_array(); for (size_t i = 0; i < 3; ++i) printf("%d\n", array[i]); destroy_array(array); return 0; } 

Alternatively, you can declare the array as static, keeping in mind the semantics are different. Example:

int *get_array(void) { static int array[] = { 4, 65, 23 }; return array; } int main(int argc, char **argv) { int *array = get_array(); for (size_t i = 0; i < 3; ++i) printf("%d\n", array[i]); return 0; } 

If you don't know what static means, read this question & answer.

Right way to do this is as follows:

struct Arr { int array[3]; }; Arr get_array() { Arr a; a.array[0] = 4; a.array[1] = 65; a.array[2] = 23; return a; } int main(int argc, char **argv) { Arr a = get_array(); for(size_t i=0; i<3; i++) printf("%d\n", a.array[i]); return 0; } 

To understand why you need to do this, you need to know how sizeof(array) works. C (and thus c++) tries hard to avoid copying the array, and you need the struct to go past that. Why copying is needed is because of scopes -- the get_array() function's scope disappears and every value still needed from that scope will need to be copied to calling scope.

C++ solution:

"May I have any access to a local variable in a different function? If so, how?"

The answer is no, not after the function has ended. Local variables are destroyed at that point.

In C++ the way to deal with returning arrays is to manage them in a container like a std::array (fixed size) or a std::vector (dynamic size).

Eg:

void replaceNumberAndPrint(const std::array<int, 3>& array) { printf("%i\n", array[0]); printf("%i\n", array[1]); printf("%i\n", array[2]); } std::array<int, 3> getArray() { std::array<int, 3> myArray = {4, 65, 23}; return myArray; } 

In the second function the returned value is optimized by the compiler so you don't pay the price of actually copying the array.

In this code you have used pointer to local objects but when a function returns all local variables goes out of scope. If you will allocate memory (using malloc() function for allocation) then no data will be lost or overwrite.

int* getArray(int size) { int *myArray = (int*)malloc(size*sizeof(int)); myArray[0] = 4; myArray[1] = 65; myArray[2] = 23; return myArray; } int main() { int i; int *vector = getArray(3); for(i=0;i<3;i++) { printf("%i\n",vector[i]); } getch(); return 0; } 

This code will print all the array elements and no overwritten will be happened.

Static ..or.. Global within your .c will do the trick ;)

However the entire time the program will occupy those 3 bytes BUT you avoid doing malloc on simple things like this (malloc recommended for big arrays)

On the other hand if the outside function modify the pointer, then the internal 'myArray' will be modified cause it points to it, that's it

int myArray[3]; int * getArray() { myArray[0] = 4; myArray[1] = 65; myArray[2] = 23; return myArray; }