3. 2.dim Array mit Zeigern auf Arrays

2.dim Array mit Zeigern auf Arrays

  • ?

    Hallo,
    bin zwar kein c++ neuling, aber mit zeigern tu ich mich immer noch etwas schwer.

    ich brauche ein 2.dimensionales Array feld[N][N] bei dem jedes Element
    einen eigen Zeiger auf ein eigenes Array mit nochmals 4 Elementen hat.
    feld[][] soll dynamisch groß sein (d.h. dennoch kleiner als [N][N]).

    aus ker/richie weiß ich noch:
    int *px[4] // Array mit 4 Zeigern auf int
    int (*z)[N][N] //Zeiger auf int-Feld der Größe [N][N]

    jetzt weiß ich nur nicht mehr weiter. wie kombiniere ich das ? und wie bekomm ich zugriff auf die element der 4er arrays im feld[][] ? muss ich da nicht noch irgendwie speicher allocieren ?

    annahme N=10;
    ich will jetzt ein feld[3][3] von mir aus.

    mfg - rockjoe01

    0
  • ?

    ich brauche ein 2.dimensionales Array feld[N][N] bei dem jedes Element
    einen eigen Zeiger auf ein eigenes Array mit nochmals 4 Elementen hat.

    also im endeffekt ein dreidimensionales array?

    const int n = 10;
int array [ n ] [ n ] [ 4 ];

  // oder dynamisch

int*** array;

array = new int** [ n ];

for ( int i = 0; i < n; ++i )
  array [ i ] = new int* [ n ]; 

for ( int i = 0; i < n; ++ i )
  for ( int j = 0; j < n; ++j )
    array [ i ] [ j ] = new int [ 4 ];

    aus ker/richie weiß ich noch

    versteh ich nicht. aus der kirche, oder was?

    was auch immer

    0
  • F

    was auch immer schrieb:

    versteh ich nicht. aus der kirche, oder was?

    Er meint das Buch, das Kernighan und Ritchie geschrieben haben. (Mit dem Titel "Programmieren in C".)Die beiden Herren haben übrigens die Programmiersprache C und das Betriebssystem UNIX erfunden.

    gruss, flyingCoder.

    0
  • R

    in der Regel kürzt man die mit k&r ab 🙄

    in C++ benutzt man übrigens lieber std::vector oder boost::array für so was 🙂

    0
  • ?

    Er meint das Buch, das Kernighan und Ritchie geschrieben haben. (Mit dem Titel "Programmieren in C".)Die beiden Herren haben übrigens die Programmiersprache C und das Betriebssystem UNIX erfunden.

    achso, die zwei kannte ich bisher garnicht... naja, man lernt halt nie aus.

    in C++ benutzt man übrigens lieber std::vector oder boost::array für so was

    diese bequemlichkeit bringt aber auch ihre kosten mit. ausserdem finde ich dynamische arrays jetzt nicht so verzwickt, dass man gleich so schweres geschuetz auffahren muss; ist aber ansichtssache.

    was auch immer

    0
  • R

    diese bequemlichkeit bringt aber auch ihre kosten mit. ausserdem finde ich dynamische arrays jetzt nicht so verzwickt, dass man gleich so schweres geschuetz auffahren muss; ist aber ansichtssache.

    Beweise das bitte, bei meinem kleinen Test in dein Code viel langsamer als meine boost::array Lösung und auch noch viel schneller geschrieben

    #include <boost/cstdint.hpp>
#include <boost/array.hpp>
#include <iostream>
#include <cstdlib>
#include <ctime>

inline ::boost::uint64_t rdtsc() {
  ::boost::uint32_t eax, edx;
  __asm__ __volatile__ ("rdtsc; mov %%eax, %0; mov %%edx, %1" : "=r" (eax)
			, "=r"(edx) : : "%eax", "%edx");
  return (::boost::uint64_t(edx) << 32) | ::boost::uint64_t(eax);
}

inline void function_c_array() {
  const ::std::size_t n=100;
  int ***array;
  array = new int**[n];

  for(::std::size_t i=0; i<n; ++i)
    array[i] = new int*[n];

  for(::std::size_t i=0; i<n; ++i)
    for(::std::size_t j=0; j<n; ++j)
      array[i][j] = new int[4];

  for(::std::size_t i=0;i<n;++i)
    for(::std::size_t j=0; j<n; ++j)
      for(::std::size_t k=0; k<4; ++k)
	array[i][j][k] = ::std::rand();

  for(::std::size_t i=1;i<n;++i)
    for(::std::size_t j=0; j<n; ++j)
      for(::std::size_t k=0; k<4; ++k)
	array[i][j][k]+=array[i-1][j][k];

  for(::std::size_t i=1;i<n;++i)
    for(::std::size_t j=0; j<n; ++j)
      delete[] array[i][j];

  for(::std::size_t i=0; i<n; ++i)
    delete[] array[i];

  delete[] array;
}

inline void function_boost_array() {
  const ::std::size_t n=100;
  ::boost::array< ::boost::array< ::boost::array<int,4>,n>,n> array;

  for(::std::size_t i=0;i<n;++i)
    for(::std::size_t j=0; j<n; ++j)
      for(::std::size_t k=0; k<4; ++k)
	array[i][j][k] = ::std::rand();

  for(::std::size_t i=1;i<n;++i)
    for(::std::size_t j=0; j<n; ++j)
      for(::std::size_t k=0; k<4; ++k)
	array[i][j][k]+=array[i-1][j][k];
}

const ::std::size_t test_n=100;

int main() {
  ::std::srand(::std::time(NULL));
  {
    ::boost::uint64_t start=rdtsc();
    for(::std::size_t n=0;n<test_n;++n)
      function_boost_array();
    ::std::cout << "Boost Array: " << rdtsc()-start << '\n';
  }
  {
    ::boost::uint64_t start=rdtsc();
    for(::std::size_t n=0;n<test_n;++n)
      function_c_array();
    ::std::cout << "C     Array: " << rdtsc()-start << '\n';
  }
}

    Bitte nicht immer dieses dumme "C ist schneller als C++ geplapper"

    (hier mal meine Werte, getestet mit dem gcc 3.3.4 (Debian 1:3.3.4-3)

    C     Array: 1150260675
Boost Array: 793089121

    wobei die Werte je nach Aufruf variieren)

    0
  • ?

    @kingruedi: ok, hast mich ueberzeugt 🙄
    ich sag sowas nie wieder; war nur halt, dass ich mich mit boost nicht so sehr auskenne. werde wohl in zukunft dann auf boost::array ueberspringen

    was auch immer

    0
  • R

    btw. der faule Trick an der Benchmark ist, dass boost::array nämlich den Stack benutzt 🙂

    Wenn man das Stack C Array nimmt, sind beide Ergebnisse natürlich gleich

    0
  • K

    Wirklich gut das Ergebnis gefälscht und damit jemanden überzeugt - gefällt mir 🙂

    0
Anmelden zum Antworten