c ++是否可以有一个进程（在main之外） returns 一个大小由输入决定的数组，而不使用指针或宏？

Question

Bellow 是一个运行良好的简单程序。它包含一个能够 return 任意大小的字符串的函数。其大小由函数输入决定。

#include <iostream>                                                                                                                                                                                                                           
                                                                                                                                                                                                                                              
using namespace std;                                                                                                                                                                                                                          
                                                                                                                                                                                                                                              
string strFunc(int a){                                                                                                                                                                                                                        
                                                                                                                                                                                                                                              
  string toBeReturned;                                                                                                                                                                                                                        
                                                                                                                                                                                                                                              
  for(int i=0; i < a; i++){                                                                                                                                                                                                                   
    toBeReturned += '!';                                                                                                                                                                                                                      
  }                                                                                                                                                                                                                                           
  return toBeReturned;                                                                                                                                                                                                                        
}                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                              
int main(){                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                              
  int x = 5;                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                              
  cout << strFunc(x) << endl;                                                                                                                                                                                                                 
                                                                                                                                                                                                                                              
  return 0;                                                                                                                                                                                                                                   
}

如果相反，我想要一个函数（或在 main 中调用的单个进程）到 return 一维数组 (int toBeReturned[size to be determined])，我必须使用一个函数 return 是一个指针，然后将该函数包含在构造数组的宏中。

在 C++ 中有更简单的方法吗？

如果不能，谁能解释一下为什么这只适用于字符串类型？我认为字符串只是 'char'.

类型的一维数组

谢谢，

丹尼尔

Answer 1

您可以使用您需要的任何类型的向量，并通过引用将其传递到您的函数中。

#include <vector>
#include <chrono>
#include <iostream>
using namespace std;



void by_reference(vector<size_t>& v, size_t s)
{
    v.clear();
    v.resize(s, 0);

    for (size_t i = 0; i < s; i++)
        v[i] = i;
}

vector<size_t> by_return(size_t s)
{
    vector<size_t> v(s, 0);

    for (size_t i = 0; i < s; i++)
        v[i] = i;

    return v;
}



// Where s is large, by_reference is faster
// Where s is small, by_return is faster
// Use whichever works best for you and your situation



int main(void)
{
    std::chrono::high_resolution_clock::time_point start_time, end_time;
    std::chrono::duration<float, std::milli> elapsed;

    start_time = std::chrono::high_resolution_clock::now();

    for (size_t i = 0; i < 1000; i++)
    {
        vector<size_t> v;

        const size_t s = 10000000;

        by_reference(v, s);

        for (size_t i = 0; i < s; i++)
            v[i] = i;
    }

    end_time = std::chrono::high_resolution_clock::now();

    elapsed = end_time - start_time;

    cout << "Duration: " << elapsed.count() / 1000.0f << " seconds" << endl;



    start_time = std::chrono::high_resolution_clock::now();

    for (size_t i = 0; i < 1000; i++)
    {
        const size_t s = 10000000;

        vector<size_t> v = by_return(s);

        for (size_t i = 0; i < s; i++)
            v[i] = i;
    }

    end_time = std::chrono::high_resolution_clock::now();

    elapsed = end_time - start_time;

    cout << "Duration: " << elapsed.count() / 1000.0f << " seconds" << endl;

    return 0;
}

Answer 2

函数可以 return 任何 POD 或 class 按值键入。

C++ 风格的 std::array 是一个包装在 class 类型中的固定大小的数组，因此可以按值 return 编辑。但是，C 风格的固定大小的数组不能按值 returned（但它可以存储为 class 类型的成员，然后可以按值 returned ，就像 std::array 那样）。

C 样式数组不能动态调整大小（不使用 non-standard compiler extension），这就是为什么您必须 new[] 它，return 通过指针，然后 delete[] 当你用完它。

因为你想让你的函数return一个动态大小的数组，你应该使用std::vector而不是new[]ed指针，例如：

#include <iostream>                                                                                                                                                                                                                           
#include <vector>                                                                                                                                                                                                                                        
using namespace std;                                                                                                                                                                                                                          

vector<int> strFunc(int a){                                                                                                                                                                                                                        

  vector<int> toBeReturned(a); 

  for(size_t i = 0; i < a; ++i){
    toBeReturned[i] = ...;                                                                                                                                                                                                                      
  }

  return toBeReturned;
}                                                                                                                                                                                                                                             
                                                                                                                                                                                                                                              
int main(){                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                              
  int x = 5;
                                                                                                                                                                                                                                              
  vector<int> returned = strFunc(x);
  for(size_t i = 0; i < x; ++i){
    cout << returned[i] << ' ' << endl;
  }
                                                                                                                                                                                                                                              
  return 0;                                                                                                                                                                                                                                   
}

c ++是否可以有一个进程（在main之外） returns 一个大小由输入决定的数组，而不使用指针或宏？

c++ Is it possible to have a process (outside of main) that returns an array whose size is determined by the input, without using pointers or macros?

c++

arrays

function

pointers

macros