neat

You are in this chat too? That's sick!

I'm pretty much everywhere lol

Hi everyone!

New here

how to return an array by value from a function?

how to return an array by value from a function?

literally return *value*;

can you explain it with a code?

oh, an array

what kind of array?

yes

int

you can always make a vector and return it

int arr[] = {1,2,3};

it is the C++ way,

how to return it by value

if you are in C, then you must malloc the memory for it

yes by cpp way

no no

cpp way

just cpp

yeag

yeah

std::vector<int> arr = {1,2,3}; return arr;

you must copy the value from the function, because after return the array/value would otherwise go out of scope and get trashed

not vector

an array

why must it be an array and not vector??? You said you are using C++

you cant, is allocated on the stack and will die when the function return

the vector gets copied...

you cant, is allocated on the stack and will die when the function return

well you can if you use new

We can have int arr[] = {1,2,3}; as an example

you have to use a vector, or allocate it using malloc or new

I know how to do it with vector but not with array

We can have int arr[] = {1,2,3}; as an example

you get the excact same thing if you do std::vector<int> arr = {1,2,3}; int* pointer_to_int_array = &arr[0]; ...

return_type fun(){ int arr[] = {1,2,3}; }

return_type fun(){ int arr[] = {1,2,3}; return ? }

return_type fun(){ int arr[] = {1,2,3}; }

well you can not. The arr will get deleted when it goes out of scope

and technically if you put it on the heap you are not returning the array by value but you are return the address of the first element

that is just invalid code right there

well you can not. The arr will get deleted when it goes out of scope

so how does int fun(){ int x=6; return x; }

how does above not get destroyed

and technically if you put it on the heap you are not returning the array by value but you are return the address of the first element

exactly. vector is also stored in heap, and when you return the vector, you actually return a reference/pointer to it

and with array it gets destroyed?

so how does int fun(){ int x=6; return x; }

here int is one integer, which will be passed through stack, and the integer fits into one CPU register

here int is one integer, which will be passed through stack, and the integer fits into one CPU register

Kindly elaborate. How is that working !!

and with array it gets destroyed?

if you return array, you actually return POINTER to the array. The array itself gets destroyed

return_type fun(){ int arr[] = {1,2,3}; return ? }

return std::array(arr);

the pointer is still pointing to the memory location where the array was locally stored, when it was in scope

if you return array, you actually return POINTER to the array. The array itself gets destroyed

OK then what about the case with return x;

return std::array(arr);

he wanted to use raw C-type arrays

he wanted to use raw C-type arrays

He said the c++ way

OK then what about the case with return x;

it returns the value

He said the c++ way

yeah but he didn't accept the C++ way answer that I posted

wait wait

OK then what about the case with return x;

in 64-bit machines, both pointers and integers are 64 bits long. So it makes sense?

in case of array we return the pointer to first element and since the array is in stack, it gets destroyed. What does "destroyed" mean?

it gets overwritten by other values that program will write to the stack

imagine this

int* fun() { int a = 1; return &a; } will it work? no. why?

because a is in stack and gets destroyed

return_type fun(){ int arr[] = {1,2,3}; return ? }

it's the same thing with this example you posted

so the address that is returned has some arbitrary value

is that so?

It could have any value

yes

ya ya arbitrary

Is this fine?

int* fun(int arr[]){ return arr; }

sometimes I've seen someone do return (int*) arr;

What the hell does that mean?

yes it is, because it gets the pointer from the caller

and the caller has most likely allocated the array

but returning the pointer is pointless (lol), because the caller already has the address of the array it has passed to the function

ya that really is pointless

of course, if the function realloc s or moves the array, then it has to tell where it moved it to the calling function

but suppose I've a function that has an array passed as parameter then I want to remove continuous duplicate values such as 1,1,3,3,3,3,5,6 to 1,3,5,6 and want to do that inplace and return the array So how should I also return the size of the array in which the duplicated values are not present?

I mean If i do return arr;

how would the caller know the size of the array without duplicate elements?

if you use C++, you can do this again with a std::vector and remove the elements. Then the caller may call std::vector::size to get its new size

if you want to do it with C-style array, then you must for example reserve space for the size of the array (for example, the first array value could be the size of the array)