how define a function that return an array

[javadvjj]

hello .
how can i define a that it return an array;

type fname(){
type array[10]={0};
...
...
...
return array;

}
please guide me with a good code

[Athar]

You can't return local C arrays from a function.

However, you can do this if your array size is fixed:

#include <array>
array<int,10> getArray()
{
  array<int,10> array={0};
  return array;
}

Or this if it isn't:

#include <vector>
vector<int> getArray2()
{
  vector<int> vec(10);
  return vec;
}

The first example requires your compiler to support C++0x or TR1, so the second one might be preferable either way.

[Duthomhas]

The problem with an array is that you must also know the size of the array. Hence, an STL container like the std::vector is nice, since it does all the bookkeepping for you.

If you must, however, you can also just use one of the following C methods:

    Fill an existing array

void myfn( int* a, unsigned alen )
  {
  // Fill the array a[ alen ] here.
  // In this case, the array a already exists with alen elements.
  // This function only fills it.
  }

int xs[ 10 ];
myfn( xs, 10 );

    Use references (C style)

void myfn( int** a, unsigned* alen )
  {
  *alen = size_of_the_array_to_create;
  *a = new int[ *alen ];
  ...
  }

int* xs;
unsigned xlen;
myfn( &xs, &xlen );
...
delete [] xs;

    Use references (C++ style)

void myfn( int*& a, unsigned& alen )
  {
  alen = size_of_the_array_to_create;
  a = new int[ alen ];
  ...
  }

int* xs;
unsigned xlen;
myfn( xs, xlen );
...
delete [] xs;

    Return array of a specific size

int* myfn( unsigned len )
  {
  int* a = new int[ len ];
  ...
  return a;
  }

int* xs;
xs = myfn( 10 );
...
delete [] xs;

    Variations on a theme

unsigned myfn( int*& a )
  {
  a = new int[ 10 ];
  ...
  return 10;
  }

int* xs;
unsigned xlen;
xlen = myfn( xs );
...
delete [] xs;

    Use a struct (C method)

struct myarray
  {
  int* a;
  unsigned length;
  };
myarray myfn()
  {
  myarray a;
  a.a = new int[ 10 ];
  a.length = 10;
  a.a[ 0 ] = 41;
  ...
  return a;
  }

myarray xs = myfn();
for (unsigned n = 0; n < xs.length; n++)
  cout << xs.a[ n ] << endl;
delete [] xs.a;

    Use a struct or class (C++ method)

struct myarray
  {
  int* a;
  unsigned length;
  // Useful C++ stuff follows
  myarray( unsigned len ):
    a( len ? (new int[ len ]) : NULL ),
    length( len )
    { }
  ~myarray()
    {
    if (a) delete [] a;
    }
  int& operator [] ( unsigned n )
    {
    return a[ n ];
    }
  const int& operator [] ( unsigned n ) const
    {
    return a[ n ];
    }
  };
myarray myfn()
  {
  myarray a( 10 );
  a[ 0 ] = 42;
  ...
  return a;
  }

myarray xs = myfn();
for (unsigned n = 0; n < xs.length; n++)
  cout << xs[ n ] << endl;
// no need to delete anything here... the destructor does it for you... 

Hope this helps.