如何返回数组C++？

Question

我想生成一些乐透号码，并返回包含这些数字的数组，但我不能再进一步;请帮助

void getLotto(int rad[7]) { 
    int numbers[7]; 

    for (int i = 0; i < 7; i++) { 
     numbers[i] = rand() % 35 + 1; 
    } 

    for (int j = 0; j < 7; j++) { 
     int n = rand() % 35 + 1; 
     if (n == numbers[j]) { 
      numbers[j] = rand() % 35 + 1; 

      return; 
     } 
    } 
} 

Answer 1

数组不能由函数返回。一个常见的事情是动态分配数组并返回指向其第一个元素的指针。这将适用于您的情况，但会产生呼叫者管理内存的要求（delete[]new[]'ed内存）。这就是C++为我们提供标准数组类的原因：使用并返回std::vector。如果您有C++ 11支持，请返回std::array。

Answer 2

之后可能会有帮助，使用Fisher–Yates_shuffle：

// Fisher–Yates_shuffle 
// http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle 
std::vector<int> FisherYatesShuffle(std::size_t size, std::size_t max_size, std::mt19937& gen) 
{ 
    assert(size < max_size); 
    std::vector<int> res(size); 

    for(std::size_t i = 0; i != max_size; ++i) { 
     std::uniform_int_distribution<> dis(0, i); 
     std::size_t j = dis(gen); 
     if (j < res.size()) { 
      if (i != j) { 
       res[i] = res[j]; 
      } 
      res[j] = 1 + i; 
     } 
    } 
    return res; 
} 

Live example

Answer 3

std::vector和std::array比普通数组更好，但如果你想使用常规的数组，你可以按如下修改功能：

// Arguments: renamed the array, added N (# of array elements) 
void getLotto(int numbers[], size_t N) { 
    //int numbers[7]; // commented out local variable 

    for (int i = 0; i < N; i++) { 
     numbers[i] = rand() % 35 + 1; 
    } 

    for (int j = 0; j < N; j++) { 
     int n = rand() % 35 + 1; 
     if (n == numbers[j]) { 
      numbers[j] = rand() % 35 + 1; 

      return; 
     } 
    } 
} 

int numbers[]的括号表示参数是一个数组，实际传递的是指向数组的第一个元素的指针。 getLotto()修改numbers修改传递给函数的数组。

第二个参数的类型为size_t，因为它是系统用来表示对象大小（如数组）的无符号整型的平台相关别名。

这不是该函数必须相信numbers实际上有N元素作为安全的，但你这是怎么有一个功能修改规则的阵列，而不是像std::vector的容器。

你会调用该函数是这样的：

size_t N; 
int numbers[N]; 
getLotto(numbers, N); 

Answer 4

C++不允许返回整个数组作为参数传递给函数。但是，您可以通过指定数组的名称而不使用索引来返回指向数组的指针。

如果你想从一个函数返回一个一维数组，你就必须声明函数返回一个指针，如下面的例子：

int * myFunction() 
{ 
    . 
    . 
    . 
} 

第二点要记住的是，C++不主张将局部变量的地址返回到函数的外部，这样您就必须将局部变量定义为静态变量。

现在，考虑下面的函数，这将产生10张随机数和使用阵列返回它们和调用此函数如下：

#include <iostream> 
#include <ctime> 

using namespace std; 

// function to generate and retrun random numbers. 
int * getRandom() 
{ 
    static int r[10]; 

// set the seed 
srand((unsigned)time(NULL)); 
    for (int i = 0; i < 10; ++i) 
{ 
r[i] = rand(); 
cout << r[i] << endl; 
} 

    return r; 
    } 

// main function to call above defined function. 
int main() 
{ 
    // a pointer to an int. 
    int *p; 

    p = getRandom(); 
    for (int i = 0; i < 10; i++) 
    { 
    cout << "*(p + " << i << ") : "; 
    cout << *(p + i) << endl; 
    } 

return 0; 
    } 

当上述代码被编译在一起，并执行时，它产生的结果东西如下

624723190 
1468735695 
807113585 
976495677 
613357504 
1377296355 
1530315259 
1778906708 
1820354158 
667126415 
*(p + 0) : 624723190 
*(p + 1) : 1468735695 
*(p + 2) : 807113585 
*(p + 3) : 976495677 
*(p + 4) : 613357504 
*(p + 5) : 1377296355 
*(p + 6) : 1530315259 
*(p + 7) : 1778906708 
*(p + 8) : 1820354158 
*(p + 9) : 667126415 

Answer 5

有两种主要的方法来完成这一点。

注意：我不确定你的第二个for循环在做什么。我猜想的目的是确保数字都是独一无二的？你可能想看看它，因为它不是它在做什么。 为了这个问题的目的，我把它简化为只生成随机数来填充数组。

第一是把你的代码，并修复它把生成的数字放入数组中传递：

#include <iostream> 

void getLotto(int numbers[7]) { 

    for (int i = 0; i < 7; i++) 
     {numbers[i] = rand() % 35 + 1;} 

    return; 
} 

int main() 
{ 
    srand(time(0)); 
    int lotto_numbers[7]; 
    getLotto(lotto_numbers); 
    for (int i = 0; i < 7; i++) 
     {std::cout<<lotto_numbers[i]<<std::endl;} 
} 

numbers实际上不传递作为int[]而是作为一个int*指点到阵列。这意味着您对该功能所做的任何更改都会在原始数据中发生更改。
记住，你需要保持跟踪你的数组越界的现象，因为阵列可以被定义为

int lotto_numbers[6] 

这意味着

numbers[7] 

将出界。第二种方法是在堆上创建数组。这意味着你不需要传入一个数组，但是你可以在函数中实例化它

我实际上不打算在这里提供代码。主要是因为这样简单的事情，内存管理比它的价值更麻烦。 （你需要记住在堆上创建的所有东西都需要调用delete[]）。

相反，让使用内存管理的东西建于：

#include <iostream> 
#include <vector> 

std::vector<int> getLotto() { 
    std::vector<int> numbers; 
    numbers.reserve(7); 
    for (int i = 0; i < 7; i++) { 
     //numbers[i] = rand() % 35 + 1; 
     //would work, but is unsafe as you could potentially reference somthing out of range 
     //this is safer: 
     numbers.push_back(rand() % 35 + 1); 
    } 

    return numbers; 
} 

int main() 
{ 
    srand(time(0)); 
    std::vector<int> lotto_numbers = getLotto(); 
    for (auto i = lotto_numbers.begin(); i != lotto_numbers.end(); i++) 
    { 
     std::cout<<*i<<std::endl; 
    } 
} 

矢量处理内存管理你。向量可以被返回，并且返回的向量将仍然指向我们刚才填充的堆上的已分配内存。我们不需要释放它，因为这将在向量超出范围时自动完成。