Wie gebe ich ein Array von einer Funktion zurück?

Wie kann ich ein array aus einer Methode, und wie muss ich es erklären?

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

InformationsquelleAutor der Frage ewggwegw | 2010-11-24

arrays c++method-signature

54

int* test();

aber es wäre "mehr C++" zu verwenden Vektoren:

std::vector< int > test();

BEARBEITEN

Ich werde klären, irgendwann. Da Sie erwähnten C++, ich gehe mit new[] und delete[] Betreiber, aber es ist das gleiche mit malloc/free.

Im ersten Fall, wirst du etwas schreiben wie:
```
int* test() {
    return new int[size_needed];
}
```
aber es ist nicht eine gute Idee, denn Ihre Funktion ist client nicht wirklich wissen, die Größe des Arrays zurückgegeben werden, obwohl der client kann sicher freigeben es mit einem Aufruf delete[].
```
int* theArray = test();
for (size_t i; i < ???; ++i) { //I don't know what is the array size!
    //...
}
delete[] theArray; //ok.
```
Einer besseren Signatur wäre diese:
```
int* test(size_t& arraySize) {
    array_size = 10;
    return new int[array_size];
}
```
Client-code wäre jetzt:
```
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.
```
Da dies in C++, `std::vector< T > ist eine weit verbreitete Lösung:
```
std::vector<int> test() {
    std::vector<int> vector(10);
    return vector;
}
```
Jetzt müssen Sie nicht haben, um Anruf delete[] da es behandelt werden, indem Sie das Objekt, und Sie können sicher Durchlaufen Sie mit:
```
std::vector<int> v = test();
std::vector<int>::iterator it = v.begin();
for (; it != v.end(); ++it) {
   //do your things
}
```
was ist einfacher und sicherer.

InformationsquelleAutor der Antwort Simone
17

wie kann ich wieder ein array in einer c++ - Methode und wie muss ich es erklären? int[] test(void); ??

Das klingt wie eine einfache Frage, aber in C++ haben Sie ganz ein paar Optionen. Erstens, sollten Sie lieber...
- std::vector<>die wächst dynamisch, jedoch viele Elemente, die Sie stoßen bei der Laufzeit, oder
- std::array<> (eingeführt mit C++11), die speichert immer eine Anzahl von Elementen, die zur Kompilierzeit angegeben,
...wie Sie verwalten den Speicher für Sie, die richtige Verhalten, und die Vereinfachung der Dinge wesentlich:
```
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();
}
```
Die Praxis der Erstellung eines const Verweis auf die zurückgegebenen Daten können manchmal vermeiden eine Kopie, aber normalerweise können Sie nur verlassen sich auf den Return-Wert-Optimierung, oder - für vector aber nicht array - move-Semantik (eingeführt mit C++11).

Wenn Sie wirklich wollen, verwenden Sie ein eingebaute array (anders als der Standard-Bibliothek-Klasse genannt array oben erwähnt) ist eine Möglichkeit für den Anrufer, um Plätze zu reservieren und weisen Sie die Funktion zu verwenden:
```
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);
}
```
Andere Möglichkeit ist, wickeln Sie das array in eine Struktur, die - im Gegensatz zu roh-arrays - legal zu zurück durch einen Wert aus einer Funktion:
```
struct X
{
    int x[10];
};

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

void caller()
{
    X x = fn();
}
```
Beginnend mit den oben genannten, wenn Sie stecken mit C++03 möchten Sie vielleicht zu verallgemeinern, Sie in etwas näher an die 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];
};
```
Weitere option ist, um die genannte Funktion reserviert Speicher auf dem heap:
```
int* fn()
{
    int* p = new int[2];
    p[0] = 0;
    p[1] = 1;
    return p;
}

void caller()
{
    int* p = fn();
    //use p...
    delete[] p;
}
```
Helfen, vereinfachen Sie die Verwaltung von heap-Objekten, viele C++ - Programmierer verwenden Sie "smart pointers", die dafür sorgen, Löschung, wenn Sie den Zeiger(N) auf das Objekt verlassen Ihre Bereiche. Mit C++11:
```
std::shared_ptr<int> p(new int[2], [](int* p) { delete[] p; } );
std::unique_ptr<int[]> p(new int[3]);
```
Wenn Sie stecken auf C++03 ist die beste option, um zu sehen, ob die boost-library ist auf Ihrem Rechner verfügbar ist: es bietet boost::shared_array.

Doch eine andere option ist es, einige statische Speicher reserviert fn()aber dies ist NICHT THREAD-SICHER, und bedeutet, dass jeder Aufruf fn() überschreibt die Daten für jedermann sichtbar halten, Zeiger aus früheren Anrufe. Das heißt, es kann bequem (und schnell) für einfache single-threaded-code.
```
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...
}
```
InformationsquelleAutor der Antwort Tony Delroy
9

Ist es nicht möglich, ein array zurückgeben, von einer C++ - Funktion. 8.3.5[dcl.fct]/6:

Funktionen wird nicht als Rückgabetyp vom Typ array oder eine Funktion[...]

Meistgewählten alternativen sind, um eine Wert-Klasse geben, wo diese Klasse enthält ein array, z.B.
```
struct ArrayHolder
{
    int array[10];
};

ArrayHolder test();
```
Oder zurück einen Zeiger auf das erste element eines statisch oder dynamisch reservierten Arrays, die Dokumentation muss dem Benutzer anzeigen, ob er muss (und wenn ja, wie er sollte) deallocate-array, dass der zurückgegebene Zeiger zeigt.

E. g.
```
int* test2()
{
    return new int[10];
}

int* test3()
{
    static int array[10];
    return array;
}
```
Während es möglich ist die Rückgabe einer Referenz oder einem Zeiger auf ein array sind, ist es äußerst selten, wie es ist, eine komplexe syntax mit keinen praktischen Vorteil gegenüber einem der oben genannten Methoden.
```
int (&test4())[10]
{
        static int array[10];
        return array;
}

int (*test5())[10]
{
        static int array[10];
        return &array;
}
```
InformationsquelleAutor der Antwort CB Bailey
2

Gut, wenn Sie wollen, um Ihr array von einer Funktion müssen Sie sicherstellen, dass die Werte werden nicht auf dem stack gespeichert werden, da Sie verschwunden sein wird, wenn Sie die Funktion verlassen.

Also entweder dein array statisch oder den Speicher (oder pass es doch Ihr Erster Versuch wird mit einer void-parameter). Für deine Methode würde ich definieren es wie folgt:
```
int *gnabber(){
  static int foo[] = {1,2,3}
  return foo;
}
```
InformationsquelleAutor der Antwort Mark

-1

"wie kann ich wieder ein array in einer c++ - Methode und wie muss ich es erklären?
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;
    }
};

nur für 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;
    }
};

Beispiel

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

delete [] n_data;

Beispiel für int

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

delete [] n_data;

InformationsquelleAutor der Antwort ksdarkonix

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.