如何从函数返回数组？

时间：2010-11-24 07:16:26

标签： c++ arrays method-signature

如何从方法返回一个数组，我该如何声明它？

int[] test(void); // ??

5 个答案:

答案 0 :(得分：57)

int* test();

但使用矢量将是“更多C ++”：

std::vector< int > test();

修改
我会澄清一点。既然你提到了C ++，我会选择new[]和delete[]运算符，但它与malloc / free相同。

在第一种情况下，你会写一些类似的东西：

int* test() {
    return new int[size_needed];
}

但这并不是一个好主意，因为你的函数的客户端并不真正知道你要返回的数组的大小，尽管客户端可以通过调用delete[]安全地释放它。

int* theArray = test();
for (size_t i; i < ???; ++i) { // I don't know what is the array size!
    // ...
}
delete[] theArray; // ok.

这个更好的签名是：

int* test(size_t& arraySize) {
    array_size = 10;
    return new int[array_size];
}

您的客户端代码现在是：

size_t theSize = 0;
int* theArray = test(theSize);
for (size_t i; i < theSize; ++i) { // now I can safely iterate the array
    // ...
}
delete[] theArray; // still ok.

由于这是C ++，`std :: vector＆lt; T>是一种广泛使用的解决方案：

std::vector<int> test() {
    std::vector<int> vector(10);
    return vector;
}

现在您不必调用delete[]，因为它将由对象处理，您可以安全地迭代它：

std::vector<int> v = test();
std::vector<int>::iterator it = v.begin();
for (; it != v.end(); ++it) {
   // do your things
}

更容易，更安全。

答案 1 :(得分：17)

  

如何在c ++方法中返回一个数组，我该如何声明呢？ int [] test（void）; ??

这听起来像一个简单的问题，但在C ++中你有很多选择。首先，你应该更喜欢......

  • std::vector<>，它会动态增长到您在运行时遇到的许多元素，或者

  • std::array<>（在C ++ 11中引入），它总是存储在编译时指定的许多元素，

......因为他们为你管理记忆，确保正确行为并大大简化事情：

std::vector<int> fn()
{
    std::vector<int> x;
    x.push_back(10);
    return x;
}

std::array<int, 2> fn2()  // C++11
{
    return {3, 4};
}

void caller()
{
    std::vector<int> a = fn();
    const std::vector<int>& b = fn(); // extend lifetime but read-only
                                      // b valid until scope exit/return

    std::array<int, 2> c = fn2();
    const std::array<int, 2>& d = fn2();
}

创建对返回数据的const引用的做法有时可以避免复制，但通常您可以依赖返回值优化，或者 - vector但不是array - 移动语义（用C ++ 11引入）。

如果你真的想使用内置的数组（与上面提到的标准库类array不同），一种方法是让调用者保留空间并告诉函数使用它：

void fn(int x[], int n)
{
    for (int i = 0; i < n; ++i)
        x[i] = n;
}

void caller()
{
    // local space on the stack - destroyed when caller() returns
    int x[10];
    fn(x, sizeof x / sizeof x[0]);

    // or, use the heap, lives until delete[](p) called...
    int* p = new int[10];
    fn(p, 10);
}

另一种选择是将数组包装在一个结构中，与原始数组不同，该结构从函数返回值是合法的：

struct X
{
    int x[10];
};

X fn()
{
    X x;
    x.x[0] = 10;
    // ...
    return x;
}

void caller()
{
    X x = fn();
}

从上面开始，如果您使用C ++ 03，您可能希望将其概括为更接近C ++ 11 std::array的内容：

template <typename T, size_t N>
struct array
{
    T& operator[](size_t n) { return x[n]; }
    const T& operator[](size_t n) const { return x[n]; }
    size_t size() const { return N; }
    // iterators, constructors etc....
  private:
    T x[N];
};

另一个选择是让被调用的函数在堆上分配内存：

int* fn()
{
    int* p = new int[2];
    p[0] = 0;
    p[1] = 1;
    return p;
}

void caller()
{
    int* p = fn();
    // use p...
    delete[] p;
}

为了帮助简化堆对象的管理，许多C ++程序员使用“智能指针”，确保在对象的指针离开其范围时删除。使用C ++ 11：

std::shared_ptr<int> p(new int[2], [](int* p) { delete[] p; } );
std::unique_ptr<int[]> p(new int[3]);

如果您坚持使用C ++ 03，最好的选择是查看您机器上的升级库是否可用：它提供boost::shared_array。

另一种选择是fn()保留一些静态内存，虽然这不是THREAD SAFE，并且意味着每次调用fn()都会覆盖任何保持指针与之前调用的人看到的数据。也就是说，简单的单线程代码可以方便（快速）。

int* fn(int n)
{
    static int x[2];  // clobbered by each call to fn()
    x[0] = n;
    x[1] = n + 1;
    return x;  // every call to fn() returns a pointer to the same static x memory
}

void caller()
{
    int* p = fn(3);
    // use p, hoping no other thread calls fn() meanwhile and clobbers the values...
    // no clean up necessary...
}

答案 2 :(得分：9)

无法从C ++函数返回数组。 8.3.5 [dcl.fct] / 6：

  

函数不应具有类型数组或函数[...]

的返回类型

最常选择的替代方法是返回类类型的值，其中该类包含数组，例如

struct ArrayHolder
{
    int array[10];
};

ArrayHolder test();

或者要返回指向静态或动态分配的数组的第一个元素的指针，文档必须向用户指明他是否需要（以及如果他应该如何）释放返回指针所指向的数组。 / p>

E.g。

int* test2()
{
    return new int[10];
}

int* test3()
{
    static int array[10];
    return array;
}

虽然可以返回引用或指向数组的指针，但它非常罕见，因为它是一种更复杂的语法，与上述任何方法相比没有实际优势。

int (&test4())[10]
{
        static int array[10];
        return array;
}

int (*test5())[10]
{
        static int array[10];
        return &array;
}

答案 3 :(得分：2)

好吧，如果你想从一个函数返回你的数组，你必须确保这些值没有存储在堆栈中，因为当你离开函数时它们就会消失。

所以要么使你的数组​​静态或分配内存（或传入它，但你的初始尝试是使用void参数）。对于你的方法，我会这样定义：

int *gnabber(){
  static int foo[] = {1,2,3}
  return foo;
}

答案 4 :(得分：-1)

  

“如何在c ++方法中返回一个数组，我该如何声明它？   int [] test（void）; ??“

template <class X>
  class Array
{
  X     *m_data;
  int    m_size;
public:
    // there constructor, destructor, some methods
    int Get(X* &_null_pointer)
    {
        if(!_null_pointer)
        {
            _null_pointer = new X [m_size];
            memcpy(_null_pointer, m_data, m_size * sizeof(X));
            return m_size;
        }
       return 0;
    }
};

仅适用于int 

class IntArray
{
  int   *m_data;
  int    m_size;
public:
    // there constructor, destructor, some methods
    int Get(int* &_null_pointer)
    {
        if(!_null_pointer)
        {
            _null_pointer = new int [m_size];
            memcpy(_null_pointer, m_data, m_size * sizeof(int));
            return m_size;
        }
       return 0;
    }
};

例如

Array<float> array;
float  *n_data = NULL;
int     data_size;
if(data_size = array.Get(n_data))
{     // work with array    }

delete [] n_data;

int

的例子 
IntArray   array;
int       *n_data = NULL;
int        data_size;
if(data_size = array.Get(n_data))
{  // work with array  }

delete [] n_data;
相关问题
最新问题