3. Wieso funktioniert das nicht?

Wieso funktioniert das nicht?

  • V

    Firefighter schrieb:

    Ok die bei der unhantlichkeit schließe ich mich an.Aber was würdest du dann empfehlen?Wenn doch anscheint eh immer alles falsch ist was wir hier vorschlagen?:D

    einfach auf dem teppich bleiben und den anfänger nicht in 21 tagen zum vollprofi machen. ich würde ihm empfehlen es so zu machen, wie ich ihm empfohlen habe, es zu machen.

    0
  • V

    unskilled schrieb:

    volkard schrieb:

    wenn ich mich recht erinnere, sind vectors recht unhandlich, wenns um zweidimenionale geht.

    ähm... nein?
    ich seh da kein prob von wegen unhandlichkeit...

    du hast ja auch den code nicht geschrieben, der diese initialisierung ausführt! machs doch endlich.

    unskilled schrieb:

    außerdem könnte er zur not auch nen wrapper dafür bauen:

    struct 2darr
{
 size_t DIM_x;
 std::vector <int> arr;

 const int& Get(size_t x, size_t y) const {return arr[DIM_X*x+y];}
 int& Get(size_t x, size_t y) {return arr[DIM_X*x+y];}
};

    da fehlt aber der zugriff per arr[3][4].
    DIM_x wird dem konstruktor übergeben? wo wird der speicher angelegt?
    DIM_X*x+y klingt unglaubwprdig. nicht eher DIM_X*y+x?
    also wenn du schon so viele fehler dabei machst, wie solls ein anfänger schaffen?

    unskilled schrieb:

    wenn wir schon mal bei wrapper sind:
    natürlich könnte man hier jz aber auch mit new/delete arbeiten - und wenn man schon mal dabei ist, dann kann man auch gleich boost::scoped_ptr nehmen:

    struct 2darr
{
 size_t DIM_x;
 size_t DIM_y;
 boost::scoped_ptr <int*> arr;

 void resize()
 {
   arr = new int[DIM_x * DIM_y];
 }

 2darr(size_t x, size_t y) : DIM_x (x), DIM_y (y)
 {
   resize();
 }

 const int& Get(size_t x, size_t y) const {return arr[DIM_X*x+y];}
 int& Get(size_t x, size_t y) {return arr[DIM_X*x+y];}
};

    Jz baut man noch nen assert bei Get() ein und schon ist man fertig...
    (na gut - man muss noch getter und setter für x/y bauen, die private machen, so was wie begin() + end() wär noch gut etc)

    und die dicken fetten fehler wegmachen, wie das new[]/delete. du darfst doch kein delete ohne klammern benutzen wo das new[] die klammern hatte. kopierkonstruktor und zuweisungsoperator noch verbieten, op[][] fehlt immernoch, DIM_y braucht eigentlich keiner. DIM_X*x+y ist weiterhin falsch.

    aber vor allem ist es kontraproduktiv und gar keine hilfe. sowas kann ein anfänger unmöglich hinkriegen. die einzigen wirkungen sind, daß er sich seinen stil versaut, weil er komplett im dunkeln tapst und über jede zufallslösung froh ist, und daß er die lust verliert. das wollen wir doch nicht.

    0
  • F

    @volkard, ok ich werd mir dein Rat zu herzen nehmen 😉

    0
  • U

    volkard schrieb:

    du hast ja auch den code nicht geschrieben, der diese initialisierung ausführt! machs doch endlich

    #include <vector>

#include <cstdlib>
using std::size_t;

std::vector < std::vector <int> > arr;
size_t x;
std::cin >> x;
size_t y;
std::cin >> y;

arr.reserve(x);

for (size_t i(0); i != x; ++i)
{
  std::vector <int> tmp (y);
  for (size_t j(0); j != y; ++j)
  {
    std::cout << "(" << i << " , " << j << ")" << std::endl;
    int val;
    std::cin >> val;
    tmp[j] = val;
  }
  arr.push_back (tmp);
}

    volkard schrieb:

    da fehlt aber der zugriff per arr[3][4].

    den ich dir nie versprochen hatte - weil man ihn in 90% der fälle nich braucht...

    volkard schrieb:

    wie das new[]/delete.

    Hmm... ok - dann müssen wir dummerweise wohl new nutzen -.-

    volkard schrieb:

    kopierkonstruktor und zuweisungsoperator noch verbieten

    o rly?

    volkard schrieb:

    op[][] fehlt immernoch

    wo hab ich geschrieben, dass ich ihn bereitstellen werde?

    volkard schrieb:

    , DIM_y braucht eigentlich keiner

    na dann merk dir die dimensionen mal außerhalb iwie 😛

    volkard schrieb:

    . DIM_X*x+y ist weiterhin falsch

    jopp - hatte ganz oben nich drüber nachgedacht, wie rum... Und dann auch nich weiter drüber nachgedacht...

    0
  • V

    vor resize wird eigentlich immer die größe gesetzt. also sollte resize einfach die größe selber als parameter kriegen und selber setzen. setX/setY ist als setXY besser, da der code simpel das gemeinsame unterrechteck kopiert, unterrechtecksgröße mit std::min finden. assert nicht auslagern, weil auslagern die meldungen abschwächt. delete[] auch nicht, weil delete[] hier sprechender ist als cleanup().
    hast übrigens wieder schwere fehler eingebaut. cleanup macht nicht arr = nullptr, was zu absturz führt, wenn einer ein array anlegt, es mit SetX(0) cleant und mit nem anderen füllt. SetX kopiert zu viel, absturz.
    nicht anfängerfreundlich. aber du willst bestimmt nicht sagen, daß ein anfämger sowas versuchen sollte, jetzt wo der wrapper ganz und gar nicht mehr einfach gehalten ist.
    und der andere code macht immer noch nicht, was

    Fieldinfo Spielfeld[ FieldsizeX ][ FieldsizeY ];

    macht. er liest irgendwelche sachen von der standardeingabe und so ein quatsch. und er levt nicht im global scope. ich suche ein replacement für obige anfängergeeignete zeile und nicht ein programm, das was total anderes macht.

    0
  • U

    Jopp - das mit dem nullptr hatte ich ja noch vor deinem Beitrag gemacht, aber iwie hab ich gerade mal versucht, das ganze zu testen und hab noch paar viele Fehler bekommen :-S
    Ich werds mal rauseditieren - wollte eigtl au noch was produktives heute machen... Aber vll bau ichs au iwann mal und stells wieder rein, damit du wieder was zum aufregen hast 😛

    bb

    0
  • V

    viel toller wäre ein möglichst einfacher ersatz für das eingebaute array und das eingebaute 2d-array, der auch nicht mehr kann, außer einem assert drin. aber der op[][] müßte schon sein.
    dann kann der anfänger sein bubblesort und seine einmaleinstabelle bauen und kriegt die so schwer zu findenden arraygrenzenüberschreitungen gemeldet.
    aber verschwende keine zeit mehr an die vector-lösung. die fühlt sich nicht gut an.

    0
  • ?

    was ist an std::vector so schlimm? diese ganzen wrapper sind viel komplexer.

    struct Fieldinfo
{
    char name[30];
    bool besetzt;
};

const int Fieldsize[] = {6, 6};

std::vector< std::vector< Fieldinfo > > Spielfeld(Fieldsize[1], std::vector< Fieldinfo >(Fieldsize[0]));

int main()
{
	Spielfeld[1][1].besetzt = true;
}

    geht ohne probleme.

    auch mit volkards [][] operator 🙂

    und das teil hat nen assert 🙂 🙂

    0
  • V

    ich gebe zu: das ist gut.

    0
  • S

    volkard schrieb:

    viel toller wäre ein möglichst einfacher ersatz für das eingebaute array und das eingebaute 2d-array, der auch nicht mehr kann, außer einem assert drin.

    Das gibt es schon längst. Heißt std::tr1::array bzw. boost::array, falls die C++ Lib älter ist.

    0
Anmelden zum Antworten