我能够完成我的一个功能，并返回数组，如下所示：

string * animal_name_grab() 

您没有返回数组。您正在返回一个指针。指针指向数组的元素。

  

如何从c ++中的函数返回数组

实际上不可能直接从C ++中的函数返回数组。但是，可以返回类的实例，并且类可以具有数组成员，因此，如果将数组包装在类中，则可以返回该包装对象。这种数组包装器类有一个标准模板。名称为std::array。示例：

std::array<std::string,SIZE> animal_name_grab()
{
    std::array<std::string,SIZE> animal_name;
    ...
    return animal_name;
}

请注意，复制大数组可能会很慢，并且您将依赖编译器优化来避免复制返回值。使用输出迭代器而不是返回数组有时会更高效，并且通常更灵活。

您要求提供建议，所以您可以找到： 如果要使代码更像C ++和现代，请考虑使用std::array或std::vector而不是原始数组。 这使您可以使用STL_functions，例如：

std::for_each(vector.begin(),vector.end(),[&] (int n) {
sum_of_elems += n;
});

获取元素的总和。 您可以返回向量，但我建议您先创建向量，然后通过引用将其传递。

std::vector<std::string> input;
input.reserve(approxSpace); // Not necessary
getInput(&input); // Fill vector in external function

在这种情况下，也请避免使用10之类的“魔术数字”。如果您的项目越来越大，那么在不破坏代码的情况下很难进行更改。

如果您不想使用std库中的任何内容，则始终可以在堆上声明数组，以便在返回时不会破坏数组。

例如：

double * func(){
   double * someArray = new double[3]; //declaring 'someArray' on the heap

   for(int i = 0; i < 3; i++)   //Filling the array with data
      someArray[i] = i;         //filling the array with data

   return someArray;            //since 'someArray' is on the heap it wont be destructed when you return
}

尽管不要忘记在完成操作后删除该数组。

希望这会有所帮助。

您可以对其进行分解，并为animal和animal_collection定义自己的类型，并添加一些函数来随意使用它们。您显然想从流中读取animal，因此让我们为其创建一个函数。您还希望阅读animal的整个集合，因此我们为此添加一个函数。

演练：

#include <iostream>
#include <vector>  // std::vector - a dynamically growing container
                   //               that you can store objects in
#include <sstream> // std::istringstream for demo purposes

// A type to store the characteristics of an animal in. Let's start with a name.
struct animal {
    std::string name;
};

// A function to read one "animal" from std::cin or some other istream.
//
// It's functions like these that makes "cin >> variable;" work in your everyday program.
std::istream& operator>>(std::istream& is,animal& a) {
    std::getline(is,a.name);
    return is;
}

// A function to write one "animal" to std::cout or some other ostream.
std::ostream& operator<<(std::ostream& os,const animal& a) {
    return os << a.name;
}

// A collection of animals.
struct animal_collection {
    // std::vector - This std::vector stores objects of the type "animal".
    //               It has a lot of good features and is often prefered as a container
    //               when the exact number of elements to store is unknown.
    std::vector<animal> creatures;

    // return the number of "animal" objects there are in this "animal_collection"
    size_t size() const { return creatures.size(); }

    // iterator support functions so that you can loop over an animal_collection.
    // In this case,they are mearly proxy functions for the functions in std::vector
    // that we need exposed.

    // const iterators
    auto cbegin() const { return creatures.cbegin(); }
    auto cend() const { return creatures.cend(); }

    auto begin() const { return cbegin(); }
    auto end() const { return cend(); }

    // non-const iterators
    auto begin() { return creatures.begin(); }
    auto end() { return creatures.end(); }
};

// A function to read one "animal_collection" from std::cin or some other istream,// like a file / ifstream.
std::istream& operator>>(std::istream& is,animal_collection& ac) {
    animal tmp;
    while(is >> tmp) { // use operator>> for "animal"
        // push_back() is a function in std::vector. Since this vector stores "animal"
        // objects and "tmp" is an "animal" object,this works:
        ac.creatures.push_back(tmp);
    }
    return is;
}

// A function to write one "animal_collection" to std::cout or some other ostream,// like a file / ifstream.
std::ostream& operator<<(std::ostream& os,const animal_collection& ac) {
    // use the iterator support functions added to the "animal_collection" type
    // and loop over all the animal objects inside
    for(const animal& a : ac) {
        os << a << '\n'; // use operator<< that was added for "animal"
    }
    return os;
}

// using the two types created above
int main() {
    std::istringstream cin(
        "Tiger\n"
        "Lion\n"
        "Zebra\n"
        "Dalek\n");

    animal_collection ac;

    // read all "animal" objects into the "animal_collection"
    //
    // emulating reading animals from cin - replace with any istream,// like an open file

    cin >> ac; // use operator>> defined for "animal_collection"

    // use the size() function in the "animal_collection":
    std::cout << "there are " << ac.size() << " animal(s):\n";

    // output the whole "animal_collection"
    std::cout << ac;
}

当您需要向animal添加特征时，只需更改与该类型相关的内容。 animal_collection不需要更改。 std::vector<animal>内的animal_collection具有a lot of other nice functions，您也可以通过代理功能公开size()和begin() / end()函数家族。