Int Array Wert zuweisen

OP #3059436
Ich will einen vorher Definierten Array einen Wert zuweisen:
1
...
2
int myArray[3][3];
3

4
int main(void){
5
  ledE1 = {{0,1,0}, //Das ist Zeile 12
6
          {0,1,0},
7
          {0,1,0}};
8
...
Der Compiler spuckt mir aber das hier aus:
1
main.c:12:11: error: expected expression before ‘{’ token
#3059459
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.
Gast #3059714
> wo wird es denn dort gemacht?

Im verlinkten Text. Einfach draufklicken und lesen ;-)

Ich bin mal so frei:
1
$ cat main.c
2
#include <stdio.h>
3

4
int main()
5
{
6
        int i;
7
        int* pArray;
8
        pArray = (int[]) {1, 2, 3};
9

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

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

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

20

21
        return 0;
22
}
23
$ gcc -Wall -Wextra -pedantic -o main main.c 
24
main.c: In function ‘main’:
25
main.c:7:19: warning: ISO C90 forbids compound literals [-pedantic]
26
main.c:13:19: warning: ISO C90 forbids compound literals [-pedantic]
27
$ ./main 
28
dump 1:
29
  0: 1
30
  1: 2
31
  2: 3
32
dump 2:
33
  0: 4
34
  1: 5
35
  2: 6
36
  3: 7
37
  4: 8
38
  5: 9
39
$ gcc -Wall -Wextra -pedantic -std=c99 -o main main.c
40
$ ./main 
41
dump 1:
42
  0: 1
43
  1: 2
44
  2: 3
45
dump 2:
46
  0: 4
47
  1: 5
48
  2: 6
49
  3: 7
50
  4: 8
51
  5: 9

HF
Gast #3059762
> 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:
1
[..]
2
  size_t szBufferSize = 5 *sizeof(int);
3
  pArray = malloc(szBufferSize);
4
  memcpy(pArray, (int[]) {10, 11, 12, 13, 14}, szBufferSize);
5
  
6
  printf("dump 3:\n");
7
  for (i = 0; i < 5; i++)
8
    printf("  %d: %d\n", i, pArray[i]);
9

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

> Und das ganze geht auch nur bei eindimensionalen arrays.

Langt auch. Biegt man halt die Typen adäquat hin.
Persönliche Seite #3059872
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.
Gast #3060428
> 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.
Gast #3060435
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}};
Gast #3060607
Zuweisen von arrays geht nicht. Zuweisen von struct schon.

Damit könnte man das problem folgendermaßen lösen:
1
#include <stdio.h>
2

3
struct Foo {
4
  int bar[3][3] ;
5
} myArray ;
6

7
int main() 
8
{
9
  myArray = (struct Foo) { 
10
    {
11
      { 1,2,3 },
12
      { 4,5,6 },
13
      { 7,8,9 }
14
    }
15
  } ;
16

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

24
  return 0 ;
25
}
Sieht nicht schön aus.
Vielleicht doch ein pointer auf das array?
1
#include <stdio.h>
2

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

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

14
  for (int x=0 ; x<sizeof(*myArray)/sizeof(*myArray[0]) ; ++x) {
15
    for (int y=0 ; y<sizeof(*myArray[0])/sizeof(int) ; ++y) {
16
      printf("%d ",(*myArray)[x][y]) ;
17
    }
18
    printf("\n") ;
19
  }
20

21
  return 0 ;
22
}

Mit std::vector ist alles gleich viel schöner. Wenn es denn eine 
einfache initialisierung geben würde. Eindimensional ist zumindest noch 
übersichtlich:
1
#include <stdio.h>
2
#include <vector>
3

4
std::vector<int> myArray ;
5

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

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

20
  return 0 ;
21
}
Aber wir wollten ja leider 2-dimensional.

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

Grüße, Steffen
#3060713
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:
1
#include <vector>
2

3
int main()
4
{
5
    std::vector<int> vec1;
6
    std::vector<int> vec2;
7
    vec1 = { 1, 2, 3, 4, 5 }; // seit C++11
8
    vec2 = vec1;              // schon immer
9
}
Gast #3060717
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.
#3060724
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.
1
#include <vector>
2
int main()
3
{
4
    std::vector<std::vector<int> > vec1;
5
    std::vector<std::vector<int> > vec2;
6
    vec1 = { { 1, 2 }, { 3, 4 }, { 5, 6 } };
7
    vec2 = vec1;
8
}

Antwort schreiben

Eine eigene Frage? Dieser Thread ist über 13 Jahre alt. Stell sie in einem eigenen Thread – dort lesen mehr Leute mit, und sie wird öfter und schneller beantwortet.

Neuen Thread starten

Eine Lösung, Ergänzung oder Rückmeldung zu diesem Thread? Dann antworte hier.

Formatierung
  • [c]C-Code[/c]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] – Link zu einem Artikel
  • Verweis auf einen anderen Beitrag: Rechtsklick auf dessen Beitrags-ID (#8078628), „Adresse kopieren“, in den Text einfügen

Mehr zur Formatierung

Längeren Sourcecode als Anhang, nicht in den Text. JPG nur für Fotos und Scans; Zeichnungen und Screenshots als PNG oder GIF. Siehe Bildformate.

Schon registriert? Anmelden

Wird nicht angezeigt. Wir schicken dir einen Link; sobald du damit bestätigst, erscheint dein Beitrag.

Mit dem Abschicken legst du einen kostenlosen Account an und erkennst die Nutzungsbedingungen und die Datenschutzerklärung an.