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.

*Q* 1

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?

Nexus

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.

*Rewind*

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

krümelkacker

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