Return an array from a C++ function

Question

My question is similar to this one, but not the same. That one is input array then return array. Mine is input integers, and return array.

I have an array that gets a few numbers, and makes it an array.

int makearr(int a, int b, int c){
    arr[2]={a,b,c};
    return?//how can I return it
}

int main(){
    //and use it?
}

All I want is to make the array, and display it.

Note: Sorry, my software doesn't support tuples.

Answer 1

A vector?

template <typename T>
std::vector<T> makearr (T a, T b, T c)
{
    T d[] = { a, b, c };
    return std::vector<T>(d, d + 3);
}

std::vector<int> x = makearr(1, 2, 3);
// access x[i]

If all manner of standard containers are verboten, then:

template <typename T> struct three { T d[3]; };

template <typename T>
three<T> makearr (T a, T b, T c)
{
    three<T> d = { { a, b, c } };
    return d;
}

three<int> x = makearr(1, 2, 3);
// access x.d[i]

Borrowing from here and here, I cobbled together this C++11 solution that doesn't use standard containers:

template <typename T, unsigned N>
struct argh {
    argh (std::initializer_list<T> i) {
        std::copy_n(i.begin(), std::min(i.size(), N), v_);
    }
    T & operator [] (int i) { return v_[i]; }
    const T & operator [] (int i) const { return v_[i]; }
private:
    T v_[N];
};

template <typename T, typename... Type>
auto makearr (T&& val, Type&&... vals) -> argh<T, 1 + sizeof...(Type)>
{
    argh<T, 1 + sizeof...(Type)> arr = { val, vals... };
    return arr;
}

auto x = makearr(1, 2, 3);
// access x[i]

Answer 2

here nothing complex is required, you just need to return an address of your first array element to a pointer,which will ultimately display the array entries. Array must be declared globally so that it is known to ptr in main(). the code is wrriten below:

int arr[3];   //Declare it globally
int main()
{
int *ptr;
ptr=makearr(2,4,5);
for(int i=0;i<3;i++)
{
cout<<*ptr<<endl;
ptr++;
}
return 0;
}

int* makearr(int a,int b,int c)
{
arr[0]=a;arr[1]=b;arr[2]=c;
return(&arr[0])
}

Answer 3

A pointer? You can store the integers in either an integer array or in an integer pointer. A function cannot return an array, however it can return a pointer.

int* makearr(int a, int b, int c){
int *array = new int[3];
array = &a;
array+1 = &b;
array+2 = &c;
return array;
}

int main(){
int* arr = makearr(1,2,3);
// Do something with the array. Access the elements by dereferencing the pointer variable
std::cout<<*arr<<" "<<*(arr+1);
delete arr;
return 0;
}

This code however has a potential memory leak if you do not delete the array pointer in your main(or wherever you invoke the makearr method from)