Hallo.

> >     string elements[40][2]; // 2d string zum Speichern der Daten

Stack arrays sind eher ein Überbleibsel aus C. Am Ende ist das ein Pointertyp, 
wenn du den zurückgibst, e.g.:
```
auto f(...)
{
  string elements[40][2];
  //...
  return elements;
}
```
Dann gibt du einen Pointer auf eine lokale Variable zurück. Also einenen 
Pointer auf Speicher der nach dem Ende dieser Funktionier wieder freigegeben 
ist. (Der Compiler wird da auch warnen.)

Wenn due Größe zur Compilierzeit bekannt ist, nimm std::array. In diesem Fall 
wäre das
```
std::array<std::array<std::string, 2>, 40>
```

Wenn du eine Datei einließt, ist es aber eher unwahrscheinlich, dass du die 
Größe vorher kennst. In dem Fall nimmst du std::vector, also:

```
std::vector<std::vector<std::string>> rowCol;

rwoCol.resize(40);
for(auto & row: rowCol)
   row.resize(2);
```

Eine andere Möglichkeit wäre, einen flachen vector zu nehmen und selbst 2d zu 
adressieren:
```
std::vector<std::string> arr;
const int nRows = 40, nCols = 2;
arr.resize(nRows * nCols);

int row = 3, col = 1;
arr[nCols*row + col] = "Hello"; // das wäre row-major
```

Als Rückgabetyp schreibst du in jedem Fall jeweils den Typ hin als den du die 
zurückzugebende Varaible deklariert hast

Es gibt leider noch keine matizen in der STL.

Viele Grüße

Jeffrey


> > 
> > ----------
> > 
> > Ich möchte nun die Variable "elements" zurückgeben.
> 
> > Ein "return elements" wirft mir nat. nur den Fehler:
> Bist Du Dir sicher, dass Du das in C++ programmieren willst?
> Ich denke Python oder Perl, oder wegen mir Javascript oder PHP
> wären deutlich besser geeignet.
> 
> Und ja, der C++ Compiler mag das nicht, wenn man den Return Typ als "void"
> declariert und dann std::string[40][20] returned. Wobei das auch kein
> "gute Idee" (TM) ist. Wenn es unbedingt C++ sein muss, nimm std::vector.
> 
> Aber siehe oben... nimm ne andere Programmiersprache.
> 
> Grüsse
> Andreas


Attachment: signature.asc
Description: This is a digitally signed message part.

Antwort per Email an