2Darray.



  • Hallo an alle.
    Seit Tagen versuche ich eine 2D Array zu initialisieren in einer funktion.
    z.B: das geht. iArray ist globale variable.

    char iArray[2][2] = {{'s','s'},{'a','a'}};
    

    Wenn ich die bei deklaration gleich defeniere.
    Aber wenn ich die nur deklarire und in eine funktion defenieren will bekomme ich
    fehler.
    Fehlerhafter code:

    char iArray[2][2];
    .............
    .............
    void iFunk()
    {
        iArray[2][2] = {{'s','s'},{'a','a'}};
    }
    

    Compiler Fehler: error: expected primary-expression before '{' token.
    Ich Programmiere mit Code::blocks unter Windows.

    Danke.



  • Schreib mal nen typ vor das array in der funktion.
    Also sollte dann so aussehen:

    char iArray[2][2]; 
     ............. 
     ............. 
    void iFunk() 
     { 
         char iArray[2][2] = {{'s','s'},{'a','a'}}; 
     }
    

    aber das wird so auch nicht funktionieren, weil du das array global deklariert hast und dann lokal definieren willst.
    Warum willst du das so machen?



  • Du kannst die Array-Initialisierungsliste nur während der Initialisierung benutzen, nachträglich musst du die Elemente einzeln zuweisen (oder von einem bestehenden Array kopieren).



  • Ich will eine consolen Spiel programmieren und das Array ist ein Spielfeld
    die eigentlich iArray[20][30] ist. Ich überlege mir ob ich vileicht stat array ein oder mehrere string's verwenden, oder eine andere lösung mal schauen, aber Danke an all.



  • Wirf mal einen Blick in die STL-Container. Wenn ich mich richtig erinnere, gab es sogar im Forum ein Artikel dazu.



  • runix81 schrieb:

    ...und das Array ist ein Spielfeld...

    Dann kannst Du dir doch auch gleich schonmal angewöhnen, ohne globale Variablen auszukommen und den Zustand gleich als Klasse zu verpacken

    zustand.hpp

    #ifndef ZUSTAND_HPP_INCLUDED
    #define ZUSTAND_HPP_INCLUDED
    
    #include <cassert>
    
    namespace meinspiel {
    
    const int feld_hoehe = 30;
    const int feld_breite = 20;
    
    struct zustand
    {
      typedef char zeilentyp[feld_breite];
    
      zeilentyp feld[feld_hoehe];
    
      zustand();
    
      zeilentyp const& operator[](int idx) const
      { assert(0<=idx && idx<feld_hoehe); return feld[idx]; }
    
      zeilentyp      & operator[](int idx)
      { assert(0<=idx && idx<feld_hoehe); return feld[idx]; }
    };
    
    } // namespace meinspiel
    
    #endif
    

    zustand.cpp

    #include <algorithm>
    #include "zustand.hpp"
    
    namespace meinspiel {
    
    zustand::zustand()
    {
      for (int y=0; y<feld_hoehe; ++y)
        std::fill(feld[y]+0,feld[y]+feld_breite,' ');
    }
    
    } // namespace meinspiel
    

    main.cpp

    #include <iostream>
    #include "zustand.hpp"
    
    int main()
    {
      meinspiel::zustand z;
      ...usw...
      return 0;
    }
    

    ...oder so ähnlich...

    Falls Dein Compiler std::array unterstützt (aus dem <array> Header), solltest Du das nehmen

    struct zustand
    {
      typedef std::array<char,feld_breite> zeilentyp;
    
      std::array<zeilentyp,feld_hoehe> feld;
    

    Vorteil: Der "Debug-Modus" der Klasse könnte eine Bereichsüberprüfung anbieten, womit Du Indizierungsfehler früher erkennen würdest.

    Falls die Spielfeldgröße sehr groß wird oder erst zur Laufzeit festgelegt wird, kannst Du statt "rohen Feldern" einfach std::vector verwenden.

    kk


Log in to reply