3. Problem: 2-Dimensionales Klassenfeld (polimorph) als Parameter übergeben (mit cast)

Problem: 2-Dimensionales Klassenfeld (polimorph) als Parameter übergeben (mit cast)

  • 3

    Da SeppJ ja schon das wichtigste genannt hat: Es heißt int main(), NICHT void main().

    0
  • ?

    Hallo SeppJ

    Zunächst vielen Dank für die schnelle Antwort, ich werd mir std::vector auf jedenfall mal angucken.

    Allerdings muss ich jetzt vieleicht das Problem doch noch etwas genauer spezifizieren.
    Undzwar ist performance kein unwesentlicher Aspekt. Ich vergleiche ein C-Programm mit einem Objektorientierten C++ Programm und bewerte, ob die übersichtlichere Programmierung den OO-Overhead rechtfertigt.

    Das Programm wird dabei auch parallelisiert, und jetzt ist die Frage ob ich vor so ein Vector einfach ein "#pragma omp parallel for" schreiben kann besonders wenn std::vector die Felder wie "Kraut und Rüben" verteilt. 😃
    Da ist std:array bestimmt besser, oder? (Größe soll zwar dynamich ermittelt werden, verändert sich aber danach nicht mehr)

    Du sagst auch dass ich das 2D array falsch gemacht hab, ich kenn das so nur aus C mit malloc und primitiven datentüpen etc., (C++ ist neu für mich) und dass

    C* c = new C;

    eine Klasse ist und

    C ** c = new C* [x];
for(int i=0; i<x ; i++)
  c[i] = new C[y];

    ein 2D array, kam mir gleich komich vor 🙂
    Währe schön wenn mir das einer zeigen könnte.

    musst dich aber nicht angesprochen fühlen, wenn dir das zu trivial oder aufwändig ist musst du nicht antworten 😉

    Gruß Fabian

    0
  • Mod

    Du hast nicht verstanden, was ein vector ist. Vector hat keinen Overhead gegenüber new. Vector ist praktisch eine Kapselung von new. Daher kannste auch genauso OpenMP benutzen. Und wenn du einen Overhead von Objektorientiert gegen nicht Objektorientiert feststellst, der nicht auf die andere Lokalität bei Objekten zurückzuführen ist, dann machst du etwas gravierendes falsch.

    Deine 2D-Arrays waren doch richtig, auf den ersten Blick sah es nach dem typischen Anfängerfehler aus, 2D-Arrays als Zeiger auf Zeiger anzusehen. Aber du hast tatsächlich Zeiger auf Zeiger und schreibst bloß, dass du ein 2D-Array hättest, dabei hast du gar keines.

    0
  • ?

    Danke für die schnelle Antwort.
    Ok, jetzt hab ich selber gesehen wie vectoren funktionieren, als ich zuerst variable Länge und beliebiges einfügen gelesen habe, hatte ich erstmal an sowas wie verkettete Listen etc gedacht, dass war natürlich quatsch.

    Aber deinen letzten abschnitt verstehe ich nicht. Ich glaube ich mache nämlich den typichen Anfängerfehler 😃 ich will nämlich in der tat 2D- arrays haben, und wie ich schon sagte, dass 1-* Referenz auf Objekt ist und 2-* Referenz auf 2D-array kam mir gleich komich vor 🙂

    Gruß Fabian

    0
  • Mod

    Der Unterschied ist:
    2D-Array-Speicherlayout-Beispiel Wert[2][3].

    | Wert 0 0 | Wert 0 1 | Wert 0 2 | Wert 1 0 | Wert 1 1 | Wert 1 2 |

    Und wenn man das an eine Funktion übergibt, dann nimmt die einen Zeiger auf ein Wert[3] entgegen.

    Zeiger auf Zeiger:

    | Zeiger auf Zeiger |
ganz woanders: wodrauf der Zeiger auf Zeiger zeigt:
| Zeiger 1 | Zeiger 2 | Zeiger 3 | ...  | Zeiger N |
ganz woanders: wodrauf Zeiger 1 zeigt:
| Wert 0 0 | Wert 0 1 | Wert 0 2 | ... | Wert 0 N1 |
ganz woanders: wodrauf Zeiger 2 zeigt:
| Wert 1 0 | Wert 1 1 | Wert 1 2 | ... | Wert 1 N2 |
...
ganz woanders: wodrauf Zeiger N zeigt:
| Wert N 0 | Wert N 1 | Wert N 2 | ... | Wert N NN |

    Dabei können alle N verschieden sein.

    Der Unterschied entspricht dem Unterschied zwischen vector<vector<Wert> > (=Zeiger auf Zeiger) und vector<array<Wert> > (=Zeiger auf Array). Was man braucht, hängt natürlich davon ab, ob die Größe der zweiten Dimension fest ist oder flexibel sein soll. Jedenfalls wird die Zeiger auf Zeiger auf ... auf Zeiger auf Wert-Variante mit zunehmender Zahl der Dimensionen sehr schnell sehr langsam.

    Aber mach's nicht von Hand. Abstrahiere. Abstraktion kostet exakt 0 Laufzeit. Und hier kostet es noch nicht einmal Mühe, da die Standardbibliothek schon die Arrays mit std::vector und std::array abstrahiert hat. Google dazu auch mal "Three star programmer"

    0
  • ?

    Alles klar
    Vielen Dank!!!

    Gruß Fabian

    0

  • Langsam könnte man zum Thema 2D Arrays echt einen sticky Thread aufmachen...

    #include <vector>

template<typename T>
class array2D
{
   std::vector<T> Data_;
   std::size_t dim0_;
   std::size_t dim1_;

public:
   array2D( std::size_t d0, std::size_t d1 ) :
      dim0_( d0 ),
      dim1_( d1 ), 
      Data_( d0 * d1 )
   {
   }

   T& operator()( std::size_t d0, std::size_t d1 )
   {
      return Data_[dim0_ * d1 + d0];
   }

   const T& operator()( std::size_t d0, std::size_t d1 ) const
   {
      return Data_[dim0_ * d1 + d0];
   }
};

int main()
{
   array2D<double> arr( 4,3 );

   arr( 1,2 ) = 2.5;
}
    0
  • 3

    Vor etwa ner Woche hab ich aus Langeweile mal das hier programmiert:

    template <std::size_t N>
struct size_t_
{ static constexpr std::size_t value = N; };

template <std::size_t...>
struct multiply;

template <std::size_t A, std::size_t... B>
struct multiply<A, B...> : size_t_<A * multiply<B...>::value>
{};

template <>
struct multiply<> : size_t_<1>
{};

template <std::size_t...>
struct length;

template <std::size_t Head, std::size_t... Tail>
struct length<Head, Tail...> : size_t_<1 + length<Tail...>::value>
{};

template <>
struct length<> : size_t_<0>
{};

template <typename, std::size_t, std::size_t...>
struct multi_array_proxy;

template <typename T, std::size_t D, std::size_t E, std::size_t... F>
class multi_array_proxy<T, D, E, F...>
{
	enum { dimsize_ = multiply<E, F...>::value };
	typedef multi_array_proxy<T, E, F...> proxy;
	T* const data_;

public:
	constexpr multi_array_proxy(T* data)
		: data_(data)
	{}

	          proxy       operator [] (std::size_t index)       { return proxy(data_ + dimsize_ * index); }
	constexpr proxy const operator [] (std::size_t index) const { return proxy(data_ + dimsize_ * index); }

	constexpr std::size_t size() const { return D; }
	constexpr std::size_t dimensions() const { return length<D, E, F...>::value; }
};

template <typename T, std::size_t D>
class multi_array_proxy<T, D>
{
	T* const data_;

public:
	constexpr multi_array_proxy(T* data)
		: data_(data)
	{}

	          T&       operator [] (std::size_t index)       { return data_[index]; }
	constexpr T const& operator [] (std::size_t index) const { return data_[index]; }

	constexpr std::size_t size() const { return D; }
	constexpr std::size_t dimensions() const { return 1; }
};

template <typename T, std::size_t D, std::size_t... E>
class multi_array : private std::array<T, multiply<D, E...>::value>
{
	enum { size_ = multiply<D, E...>::value, };
	typedef multi_array_proxy<T, D, E...> proxy;

public:
	          std::array<T, size_>&       to_array()       { return *this; }
	constexpr std::array<T, size_> const& to_array() const { return *this; }

	          decltype(proxy(0)[0]) operator [] (std::size_t index)       { return proxy(to_array().data())[index]; }
	constexpr decltype(proxy(0)[0]) operator [] (std::size_t index) const { return proxy(to_array().data())[index]; }

	constexpr std::size_t size() const { return D; }
	constexpr std::size_t dimensions() const { return length<D, E...>::value; }
};
    0
  • ?

    Pi bettelt mal wieder um Aufmerksamkeit. 😃

    0
  • 3

    Diese eifersüchtigen unregistrierten sind echt witzig 🤡

    0
  • C
    Mod

    314159265358979 schrieb:

    Vor etwa ner Woche hab ich aus Langeweile mal das hier programmiert:

    ...

    Für size_t_ gibt es integral_constant in <type_traits>, das length-Template kannst du einfach sizeof... ersetzen.

    0
  • 3

    Danke für die Tipps 👍

    0
Anmelden zum Antworten