Taking integer as parameter and returning an array

I want to create a function that takes an integer as it's parameter and returns an array in C++. This is the pseudo-code I had in mind:

function returnarray(integer i)
{
    integer intarr[i];

    for (integer j = 0; j < i; j++) { intarr[j] = j; }

    return intarr;
}

I tried the common way of declaring returnarray as function* returning a pointer, but then I can't take an integer as my parameter. I also can't assign j to intarr[j]. I'd really like to avoid making a pointer to an int just so I could use the parameter.

Is there any way of doing this and being able to assign开发者_StackOverflow j to intarr[j] without making a pointer for it?

EDIT:

forgot to write that I want to avoid vectors. I use them only if I really have to! (my reasons are mine).

Thanks :D

You can't return a stack-allocated array- it's going to go out of scope and the memory deallocated. In addition, C++ does not allow stack-allocated variable-length arrays. You should use a std::vector.

std::vector<int> returnarray(int i) {
    std::vector<int> ret(i);
    for(int j = 0; j < i; j++) ret[j] = j;
    return ret;
}

your code isn't even near valid c++ so i assume you're total beginner

use std::vector

#include <vector>

std::vector<int> yourFunction( int n )
{
    std::vector<int>  result;
    for( int i = 0;  i < n;  ++i )
    {
        result.push_back( i );
    }
    return result;
}

Disclaimer: code untouched by compilers' hands.

Cheers & hth.,

Two remarks, before using the excellent @DeadMG 's solution:

1) You never want to avoid vectors. If v is a vector, and you really want a pointer, you can always have a pointer to the first element by writing &v[0].

2) You can't return an array. You will return a pointer to a fresh memory zone that you'll have to delete once finished with it. Vectors are only arrays with an automatic deletion facility, so you won't leak memory.

You need to use dynamic memory. Something like this

int* returnArray(int size) {
    int* array = new int[size];
    for(int i = 0; i < size; ++i)
        array[i] = i;
    return array;
}

Not that I'd particularly recommend this approach in general, but you can use templates to do this without resorting to dynamic memory allocation. Unfortunately you can't return arrays from functions, so you'd need to return a struct with the array inside.

template <int N>
struct int_array_type {
    int ints[N];
};

template <int N>
int_array_type<N> returnarray() {
    int_array_type<N> a;
    for (int i = 0; i < N; ++i)
        a.ints[i] = i;
    return a;
}

...

int_array_type<10> u = returnarray<10>();
std::copy(u.ints, u.ints+sizeof(u.ints)/sizeof(u.ints[0]),
    std::ostream_iterator<int>(std::cout, "\n"));