Int Array Wert zuweisen

[Peter K. (peterka2000)]

Ich will einen vorher Definierten Array einen Wert zuweisen:

...
int myArray[3][3];

int main(void){
  ledE1 = {{0,1,0}, //Das ist Zeile 12
          {0,1,0},
          {0,1,0}};
...

Der Compiler spuckt mir aber das hier aus:

main.c:12:11: error: expected expression before ‘{’ token

[Peter II (Gast)]

zuweisungen geht in C nicht.

Nur initalisierung:


int myArray[3][3] =  {{0,1,0}, //Das ist Zeile 12
          {0,1,0},
          {0,1,0}};

[Karl H. (kbuchegg)]

Peter K. schrieb:
> Ich will einen vorher Definierten Array einen Wert zuweisen:

Merke:

Man kann Arrays nicht als ganzes zuweisen.
Nur intialisieren.


Wenn du also einem Array etwas zuweisen willst, dann musst du das über 
Zuweisungen an die Einzelkomponenten machen.

[Peter K. (peterka2000)]

Was muss ich dann aber machen, wenn ich dem Array in (z.B.) Zeile 72 
einen anderen Wert zuweisen will?

[Karl H. (kbuchegg)]

Peter K. schrieb:
> Was muss ich dann aber machen, wenn ich dem Array in (z.B.) Zeile 72
> einen anderen Wert zuweisen will?

zb.

  myArray[0][0] = 0;
  myArray[0][1] = 1;
  myArray[0][2] = 0;

  myArray[1][0] = 0;
  myArray[1][1] = 1;
  myArray[1][2] = 0;

  myArray[2][0] = 0;
  myArray[2][1] = 1;
  myArray[2][2] = 0;


oder, da bei dir alle 3 Zeilen gleich sind

  for( i = 0; i < 2; ++i )
  {
    myArray[1][0] = 0;
    myArray[1][1] = 1;
    myArray[1][2] = 0;
  }


oder du richtest dir ein Array mit Initialwerten her, welches du bei 
Bedarf mittels memcpy über das Zielarray drüber kopierst. Oder .....

Denk dir was aus, was du mit den Sprachmitteln erreichen kannst. Aber so 
gehts nicht. Die von dir benutzte Syntax geht nur bei Initialisierungen. 
Und eine Zuweisung ist nun mal keine Initialisierung.

[Peter K. (peterka2000)]

OK, trotzdem Danke

[Rolf Magnus (Gast)]

Peter II schrieb:
> zuweisungen geht in C nicht.

Doch, geht schon. Man muß es nur richtig machen:
http://gcc.gnu.org/onlinedocs/gcc/Compound-Literals.html

[Peter II (Gast)]

Rolf Magnus schrieb:
> Doch, geht schon. Man muß es nur richtig machen:
> http://gcc.gnu.org/onlinedocs/gcc/Compound-Literals.html

wo wird es denn dort gemacht?

[g457 (Gast)]

> wo wird es denn dort gemacht?

Im verlinkten Text. Einfach draufklicken und lesen ;-)

Ich bin mal so frei:

$ cat main.c
#include <stdio.h>

int main()
{
        int i;
        int* pArray;
        pArray = (int[]) {1, 2, 3};

        printf("dump 1:\n");
        for (i = 0; i < 3; i++)
                printf("  %d: %d\n", i, pArray[i]);

        pArray = (int[]) {4, 5, 6, 7, 8, 9};

        printf("dump 2:\n");
        for (i = 0; i < 6; i++)
                printf("  %d: %d\n", i, pArray[i]);


        return 0;
}
$ gcc -Wall -Wextra -pedantic -o main main.c 
main.c: In function ‘main’:
main.c:7:19: warning: ISO C90 forbids compound literals [-pedantic]
main.c:13:19: warning: ISO C90 forbids compound literals [-pedantic]
$ ./main 
dump 1:
  0: 1
  1: 2
  2: 3
dump 2:
  0: 4
  1: 5
  2: 6
  3: 7
  4: 8
  5: 9
$ gcc -Wall -Wextra -pedantic -std=c99 -o main main.c
$ ./main 
dump 1:
  0: 1
  1: 2
  2: 3
dump 2:
  0: 4
  1: 5
  2: 6
  3: 7
  4: 8
  5: 9

HF

[Peter II (Gast)]

g457 schrieb:
> Im verlinkten Text. Einfach draufklicken und lesen ;-)

nur das hier etwas anders gemacht wird.

es wird ein zeiger zugewiesen keine werte! Und das ganze geht auch nur 
bei eindimensionalen arrays.

[Rufus Τ. F. (rufus)]

Karl Heinz Buchegger schrieb:
> oder, da bei dir alle 3 Zeilen gleich sind
>
>   for( i = 0; i < 2; ++i )
>   {
>     myArray[1][0] = 0;
>     myArray[1][1] = 1;
>     myArray[1][2] = 0;
>   }

Tippfehler.

Statt myArray[1] soll da myArray[i] stehen, sonst ist die Schleife 
irgendwie sinnlos.

[g457 (Gast)]

> es wird ein zeiger zugewiesen keine werte!

nichts leichter als das (wenngleich es nur abhängig vom Kontext einen 
Unterschied macht): memcpy regelt, das Compound als Parameter setzen:

[..]
  size_t szBufferSize = 5 *sizeof(int);
  pArray = malloc(szBufferSize);
  memcpy(pArray, (int[]) {10, 11, 12, 13, 14}, szBufferSize);
  
  printf("dump 3:\n");
  for (i = 0; i < 5; i++)
    printf("  %d: %d\n", i, pArray[i]);

  free(pArray);
[..]
dump 3:
  0: 10
  1: 11
  2: 12
  3: 13
  4: 14

> Und das ganze geht auch nur bei eindimensionalen arrays.

Langt auch. Biegt man halt die Typen adäquat hin.

[Rufus Τ. F. (rufus)]

g457 schrieb:
> size_t szBufferSize = 5 *sizeof(int);
>   pArray = malloc(szBufferSize);
>   memcpy(pArray, (int[]) {10, 11, 12, 13, 14}, szBufferSize);

Warum das unschön ist, ist klar: Hier muss an zwei Stellen darauf 
geachtet werden, daß die Arraygröße korrekt ist - bei szBufferSize und 
bei der Initialisierung des Arrays.
Das ist eine potentielle Quelle für sehr lustige Fehler.

[g457 (Gast)]

> Das ist eine potentielle Quelle für sehr lustige Fehler.

Klar, schön ist das nicht. Aber es ∗geht∗ :-)

Mehr mehr Sicherheit will sollte auf C++ und std::vector umsteigen, da 
gehen auch ∗echte∗ Zuweisungen von ganzen Arrays (sic!) ohne Klimmzüge.

[Peter II (Gast)]

g457 schrieb:
> da
> gehen auch ∗echte∗ Zuweisungen von ganzen Arrays (sic!) ohne Klimmzüge.

dann zeig doch mal wie das mit std::vector gehen soll.

int myArray[3][3] =  {{0,1,0}, //Das ist Zeile 12
          {0,1,0},
          {0,1,0}};

[Steffen (Gast)]

Zuweisen von arrays geht nicht. Zuweisen von struct schon.

Damit könnte man das problem folgendermaßen lösen:

#include <stdio.h>

struct Foo {
  int bar[3][3] ;
} myArray ;

int main() 
{
  myArray = (struct Foo) { 
    {
      { 1,2,3 },
      { 4,5,6 },
      { 7,8,9 }
    }
  } ;

  for (int x=0 ; x<sizeof(Foo::bar)/sizeof(Foo::bar[0]) ; ++x) {
    for (int y=0 ; y<sizeof(Foo::bar[0])/sizeof(int) ; ++y) {
      printf("%d ",myArray.bar[x][y]) ;
    }
    printf("\n") ;
  }

  return 0 ;
}

Sieht nicht schön aus.
Vielleicht doch ein pointer auf das array?

#include <stdio.h>

int (*myArray)[3][3] ;

int main() 
{
  static int tmp[3][3] = { 
    { 1,2,3 },
    { 4,5,6 },
    { 7,8,9 }
  } ;
  myArray = &tmp ;

  for (int x=0 ; x<sizeof(*myArray)/sizeof(*myArray[0]) ; ++x) {
    for (int y=0 ; y<sizeof(*myArray[0])/sizeof(int) ; ++y) {
      printf("%d ",(*myArray)[x][y]) ;
    }
    printf("\n") ;
  }

  return 0 ;
}

Mit std::vector ist alles gleich viel schöner. Wenn es denn eine 
einfache initialisierung geben würde. Eindimensional ist zumindest noch 
übersichtlich:

#include <stdio.h>
#include <vector>

std::vector<int> myArray ;

int main() 
{
  static int tmp[9] = { 
    1,2,3,
    4,5,6,
    7,8,9
  } ;
  myArray = std::vector<int>(tmp,tmp+sizeof(tmp)/sizeof(tmp[0])) ;

  for (int i=0 ; i<myArray.size() ; ++i) {
    printf("%d ",myArray[i]) ;
  }
  printf("\n") ;

  return 0 ;
}

Aber wir wollten ja leider 2-dimensional.

[g++ version 4.4.5 (Debian 4.4.5-8)]

Grüße, Steffen

[Rolf M. (rmagnus)]

Peter II schrieb:
> g457 schrieb:
>> da
>> gehen auch ∗echte∗ Zuweisungen von ganzen Arrays (sic!) ohne Klimmzüge.
>
> dann zeig doch mal wie das mit std::vector gehen soll.

Das geht so:

#include <vector>

int main()
{
    std::vector<int> vec1;
    std::vector<int> vec2;
    vec1 = { 1, 2, 3, 4, 5 }; // seit C++11
    vec2 = vec1;              // schon immer
}

[Peter II (Gast)]

Rolf Magnus schrieb:
>> dann zeig doch mal wie das mit std::vector gehen soll.
> Das geht so:
> #include <vector>
> int main()
> {
>     std::vector<int> vec1;
>     std::vector<int> vec2;
>     vec1 = { 1, 2, 3, 4, 5 }; // seit C++11
>     vec2 = vec1;              // schon immer
> }

es ging um 2 dimensonal.

[Rolf M. (rmagnus)]

Peter II schrieb:
> Rolf Magnus schrieb:
>>> dann zeig doch mal wie das mit std::vector gehen soll.
>> Das geht so:
>> #include <vector>
>> int main()
>> {
>>     std::vector<int> vec1;
>>     std::vector<int> vec2;
>>     vec1 = { 1, 2, 3, 4, 5 }; // seit C++11
>>     vec2 = vec1;              // schon immer
>> }
>
> es ging um 2 dimensonal.

#include <vector>
int main()
{
    std::vector<std::vector<int> > vec1;
    std::vector<std::vector<int> > vec2;
    vec1 = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
    vec2 = vec1;
}

[Steffen (Gast)]

Schönes Feature aus C++11. :-) Das kannte ich noch nicht.

[Peter K. (peterka2000)]

BITTE, BITTE keine Mega-Thread draus machen. Ich mache es jetzt so:
Karl Heinz Buchegger schrieb:
>   myArray[0][0] = 0;
>   myArray[0][1] = 1;
>   myArray[0][2] = 0;
>
>   myArray[1][0] = 0;
>   myArray[1][1] = 1;
>   myArray[1][2] = 0;
>
>   myArray[2][0] = 0;
>   myArray[2][1] = 1;
>   myArray[2][2] = 0;

Trotzdem danke, für alle die, die sich mit meinen Problem beschäftigt 
haben.