Funktion, die 'nen Array returnt?

[Gnunha]

int do_Something(void) {
 int a = 123;
 return a;
}

gibt einen Integer zurück. Schön und gut, aber wie muss eine Funktion aussehen, die einen Array zurückliefert (int[100][100])?

[AndreasW]

Hi, das geht nicht so einfach.

Am besten ist, wenn du dir ne Matrix selbst definierst in form einer Klasse.

Zum Beispiel so in der Art:

#include <vector>
#include<functional>
 #include <string>
  #include <fstream>
#include <iterator>
#include <iostream>

//---------------------------------------------------------------------------
template<class T>class Slice_iter
{
private:
   std::vector<T>* v;
   std::slice s;
   size_t akt;
   T& ref(size_t i)const {return (*v)[s.start()+i*s.stride()];}
public:
   Slice_iter(std::vector<T>* vv,std::slice ss):v(vv),s(ss),akt(0){}
   Slice_iter end() const
      {
         VSlize_iter t=*this;
         t.akt=s.size();
         return t;
      }
   Slice_iter& operator++(){akt++; return *this;}
   Slice_iter operator++(int){Slice_iter t=*this; akt++;return t;}
   //T operator+(size_ti, T t){return *ref(i)*t; }

   T& operator[](size_t i){return ref(i);}
   T& operator()(size_t i){return ref(i);}
   T& operator*(){return ref(akt);}                   // aktuelles Element

   friend bool operator ==<>(const Slice_iter& p,const Slice_iter& q)
      {
         return p.akt==q.akt && p.s.stride()== q.s.stride() && p.s.start()== q.s.start();
      }
   friend bool operator !=<>(const Slice_iter& p,const Slice_iter& q)
      {
         return !(P==q);
      }
   friend bool operator < <>(const Slice_iter& p,const Slice_iter& q)
      {
         return p.akt<q.akt && p.s.stride()== q.s.stride() && p.s.start()== q.s.start();
      }
};

//---------------------------------------------------------------------------

//---------------------------------------------------------------------------
template <class T> class TMLMatrix
{
private:
   std::vector<T>* v;
   std::size_t FColCount,FRowCount;
public:
   typedef T value_type;
   typedef Slice_iter<value_type> SLICE;
   typedef const SLICE CONST_SLICE;
   typedef std::vector<value_type> MatrixSource;
   typedef MatrixSource::const_iterator Const_MatrixIter;
   typedef MatrixSource::iterator MatrixIter;

   TMLMatrix(std::size_t maxcols=1, std::size_t maxrows=1)
      {
         FColCount=maxcols;FRowCount=maxrows;
         v=new MatrixSource(maxcols*maxrows);
      };
   TMLMatrix(const TMLMatrix& AMatrix)
      {
         FColCount= AMatrix.ColCount();
         FRowCount= AMatrix.RowCount();
         v=new MatrixSource(AMatrix.array());
      };
   TMLMatrix(const MatrixSource& AVector, size_t AColCount, size_t ARowCount)
      {
         FColCount= AColCount;
         FRowCount= ARowCount;
         v=new MatrixSource(AVector);
      };
   TMLMatrix& operator=(const TMLMatrix& AMatrix)
      {
         clear();
         FColCount= AMatrix.ColCount();
         RowCount()= AMatrix.RowCount();
         delete v;
         v=new MatrixSource(AMatrix.Source());
      };

   ~TMLMatrix()
      {
         clear();
         delete v;
      };
   void clear()
         {
         v->clear();
         }
          size_t      size()      const                      {return ColCount()*RowCount();}
   inline size_t      ColCount()  const                      {return FColCount;}
   inline size_t      RowCount()  const                      {return FRowCount;}

   void        SetSize(size_t AColCount,size_t ARowCount)         {FColCount=AColCount;FRowCount=ARowCount;}
   void        SetColCount(size_t Cols)               {FColCount=Cols;}
   void        SetRowCount(size_t Rows)               {FRowCount=Rows;}
   void        add(const value_type& Value)           {v->push_back(Value);}
   void        resize(size_t newsize)                 {v->resize(newsize);};
   void        resize(size_t newsize,value_type Default) {v->resize(newsize,Default);};
   void        erase(Const_MatrixIter Pos)               {v-> erase(Pos)}
   SLICE       zeile(size_t i)                           {return Slice_iter<value_type>(v,std::slice(i,ColCount(),RowCount()));  }
   SLICE       zeile(size_t i) const                     {return Slice_iter<value_type>(v,std::slice(i,dim1(),RowCount()));  }
   SLICE       spalte(size_t i)                          {return Slice_iter<value_type>(v,std::slice(i*RowCount(),RowCount(),1));  }
   SLICE       spalte(size_t i) const                    {return Slice_iter<value_type>(v,std::slice(i*RowCount(),RowCount(),1));  }
   value_type& operator()(size_t col, size_t row)        {return spalte(col)[row];};
   value_type& operator()(size_t col, size_t row) const  {return spalte(col)[row];};
   value_type& Cells(size_t col, size_t row)             {return spalte(col)[row];};
   CONST_SLICE operator()(size_t col)                    {return spalte(col);}
   CONST_SLICE operator()(size_t col)const               {return spalte(col);}
   CONST_SLICE operator[](size_t col)                    {return spalte(col);}
   CONST_SLICE operator[](size_t col)const               {return spalte(col);}
   MatrixSource* Source(){return v;}
};
//---------------------------------------------------------------------------

ist zwar nicht perfekt, aber schon ok. Und übrigens sauschnell.

[Gnunha]

Danke aber das ist mir zu kompliziert. Ich hab die Funktion etwas umgeschrieben:

int create_Array(int x, int y) {
 // Prozedur zur erzeugung des Arrays
 int arr[100][100];
 .
 .
 .

 // gibt verlangten Wert zurück
 return arr[x][y];
}

Das ist wohl die langsamste Möglichkeit wenn man mehr als einen Wert aus dem Array braucht.
Falls das bei mir je der Fall sein sollte, werd' ich auf deine Version zurückgreifen.