Zuweisung eines arrays

Markus F. OP #1474556
Lesenswert?
• ▲
▼ 
Hi, ich würde gerne einem array alle werte so in dieser form zuweißen:

1
field = (true,false,false,false,false,false,false,false,false,

2
false,false,false,true,false,false,false,false,false,false,false,

3
false,false,false,false,false,false,false,false,false,false,false,

4
false,false,false,false,false,false,false,false,false,false,false,

5
false,false,false,false,false,false,false,false,false,false,false,

6
false,false,false,false,false,false,false,false,false,false,false,

7
false,false,false,false,false,false,false,false,false,false,false,

8
false,false,false,false,false,false,false,false,false,false,false,

9
false,false,false,false,false,false,false,false,false,false,false,

10
false,false,true);


es handelt sich um diesen typ:
volatile bool field[10][10];

Wie kann ich das denn machen? ich habe keine lust jedes feld einzeln 
zuzuweißen.
Antwort Zitieren Bearbeiten Thread verschieben Thread sperren Anmeldepflicht aktivieren Anpinnen Thread löschen Thread mit anderem zusammenführen Beitrag melden
Naja Gast #1474567
Lesenswert?
• ▲
▼ 
Mal anders geantwortet:

Dieses Codefragment
1
field = (true,false,false,false,false,false,false,false,false,

2
false,false,false,true,false,false,false,false,false,false,false,

3
false,false,false,false,false,false,false,false,false,false,false,

4
false,false,false,false,false,false,false,false,false,false,false,

5
false,false,false,false,false,false,false,false,false,false,false,

6
false,false,false,false,false,false,false,false,false,false,false,

7
false,false,false,false,false,false,false,false,false,false,false,

8
false,false,false,false,false,false,false,false,false,false,false,

9
false,false,false,false,false,false,false,false,false,false,false,

10
false,false,true);


ist eigentlich schon fast genau das, was Du nicht tun willst.
Ist ein wenig verwirrend. Warum machst Du es denn nicht so, wenn Du es 
dann doch so machst und sei es auch nur um zu zeigen was Du nicht 
machen willst.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Naja Gast #1474569
Lesenswert?
• ▲
▼ 
Oder noch anders:
Wenn Du die runden Klammern in dem obigen Fragment durch geschweifte 
Klammern ersetzt, dann hast Du genau eine Zuweisung an jedes einzelne 
Element. Das muss man so nicht machen, aber was stört daran wenn Du es 
doch schon fast fertig hast?
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Naja Gast #1474571
Lesenswert?
• ▲
▼ 
>ich hab keine lust jedes feld einzeln per field[0][0] = true; anzusprechen.

Das ist sicherlich ein Missverständnis.

Du brauchst das ja nicht so zu machen. Mach es doch einfach so wie in 
Deinem ersten Posting geschrieben.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Markus F. OP #1474574
Lesenswert?
• ▲
▼ 
1
leds = { true,false,false,false,false,false,false,false,false,false,

2
false,false,true,false,false,false,false,false,false,false,

3
false,false,false,false,false,false,false,false,false,false,

4
false,false,false,false,false,false,false,false,false,false,

5
false,false,false,false,false,false,false,false,false,false,

6
false,false,false,false,false,false,false,false,false,false,

7
false,false,false,false,false,false,false,false,false,false,

8
false,false,false,false,false,false,false,false,false,false,

9
false,false,false,false,false,false,false,false,false,false,

10
false,false,false,false,false,false,false,false,false,true };


gibt mir:
1
Compiling C: main.c

2
avr-gcc -c -mmcu=atmega8 -I. -gdwarf-2 -DF_CPU=8000000UL -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-adhlns=./main.lst  -std=gnu99 -MMD -MP -MF .dep/main.o.d main.c -o main.o 

3
In Datei, eingefügt von main.c:21:

4
/usr/lib/gcc/avr/4.4.2/../../../../avr/include/avr/signal.h:36:2: Warnung: #warning "This header file is obsolete.  Use <avr/interrupt.h>."

5
main.c:46: Warnung: Eingebaute Funktion »y1« als Nicht-Funktion deklariert

6
main.c: In Funktion »main«:

7
main.c:203: Fehler: expected expression before »{« token

8
make: *** [main.o] Fehler 1
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Naja Gast #1474575
Lesenswert?
• ▲
▼ 
Ach, Mensch. Du meinst wahrscheinlich folgendes.

Das:
1
a[0][0] = 77;

ist eine einzelne Zuweisung.

Das aber:
1
a[10][10] = { 0, 1, 2, <...> 99};


ist durchaus auch eine Reihe von einzelnen Zuweisungen an jedes einzelne 
Element.
Eine generische Zuweisung an mehrere Elemente gleichzeitg gibt es in C 
nicht. (Und ist mir sonst auch nicht untergekommen).
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Naja Gast #1474580
Lesenswert?
• ▲
▼ 
Die Fehlermeldungen

>main.c:46: Warnung: Eingebaute Funktion »y1« als Nicht-Funktion deklariert
>main.c: In Funktion »main«:
>main.c:203: Fehler: expected expression before »{« token
>make: *** [main.o] Fehler 1

haben primär nichts mit Deiner Zuweisung zu tun. Im übrigen geht das, 
wie oben von Dir beschrieben nur als Initialisierung. Dann fehlt aber 
der Typ.

Wenn Du das mittendrin mehrfach brauchst nimm eine Schleife oder ein 
konstantes Array das Du dann umkopierst.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Naja Gast #1474582
Lesenswert?
• ▲
▼ 
>okay danke! damit ist meine frage geklärt, werd ich das wohl mit viel
>schreibarbeit machen müssen ^^

Kaum:
1
for (i = 0; i < 10; i++)

2
  for (k = 0; k < 10; k++)

3
    a [i][k] = TRUE;


>gibt es eien funktion um einen array in einen anderen
>array (mit gleichen bounds) direkt zu kopieren, ohne eine schleife? also
>ne funktion oder prozedur.

Ja, memcpy.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Markus F. OP #1474592
Lesenswert?
• ▲
▼ 
1. das mit y1 ist nur eine WARNUNG
2. Ist das y1 eine ganze weile weiter oben
3. Hat y1 absolut NICHTS mit der zuweisung zu tun. Der code funktioniert 
trotz der warnung einwandfrei

Wenn du meinst das du der einzige hier bist mit ein wenig ahnung vom 
programmieren dann viel spaß mit der einstellung. Du bist nicht der 
einzige mit programmiererfahrung, nur weil grade erst mit C anfange ist 
das kein grund so einen ton anzuschlagen. Ich finds einfach nur (sorry) 
assozial sätze wie "Mannoman, keine Ahnung, aber noch die Antwortenden 
korrigieren..." rauszuhauen, das kann man auch anders formulieren oder 
sich ganz einfach sparen (schweigen ist gold). Fang du erstmal an 
fragestellungen richtig zu lesen und zu verstehen bevor du andere 
runtermachst weil sie nicht so ein semi-genie sind wie du.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Naja Gast #1474599
Lesenswert?
• ▲
▼ 
Sorry, wegen meines Tones.

Aber dann poste halt Code ohne Warnings.

Das Problem ist oft, das die Fehler nach dem ersten (auch wenn es 
Warnings sind) Folgefehler sind, die nur daraus folgen, das der Compiler 
aus dem was er danach liest noch was zu machen versucht.
Das schien mir in diesem Fall, zu dem Fehlerbild zu passen, wenn y1 als 
Funktion ausgefasst wurde, aber bei der Initialisierung ein Typ fehlt.
Bei so einer simplen Frage, bin ich davon ausgegangen, das Du keinerlei 
Ahnung von C hast. Daher war das noch wahrscheinlicher und Deine 
"Besserwisserei" schien mir unabgebracht.

Also einfach kompilierbaren Code posten. Und Warnings werden nicht 
einfach ignoriert.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Markus F. OP #1474601
Lesenswert?
• ▲
▼ 
Mir ist sehr wohl bewusst, dass warnings nicht ignoriert werden sollten 
(auch wenn man es kann wenn der code stattdessen funktioniert).

Nur ist y1 einfach ein short, der auch nur in if's und zuweisungen 
verwendet wird und ich keine ahnung habe woher die warning kommt, und 
mir die warning auch nur unter linux angezeigt wird (windows zeigt sie 
nicht an). wüsste ich woher die warning kommt würde ich sie nicht 
ignorieren, ich bin mit meinem code oft sehr penibel was warnings angeht 
(in allen sprachen in denen ich schreibe)

Hier der kompilierbare code (auch wenn das für meine frage ohne belang 
ist...):
1
/***********************************************************************************

2
Projektname: Conways Game of Life

3
Author: Markus Foitschik (Nidhoegger)

4
Hardware used: ATMega8, 10x10 LED Matrix

5
Rules for the Game:

6
A living cell dies with 1 or 0 neighbours, as of loneliness

7
A living cell survives with 2 or 3 neighbours

8
A living cell dies with 4 or more neighbours, as of overpopulation

9
A dead cell gets born with exaclty 3 neighbours

10
License:

11
You can edit and change the project, but you may not release my original work on

12
other places, you will aknowlegde that i do not gibe warranties if something goes

13
wrong, you will leave my copyright and URL to the original project here. And you

14
will acknowlegde that my english is under all pig and wont shout at me because of

15
this.

16
***********************************************************************************/

17


18
#include <avr/io.h>

19
#include <avr/interrupt.h>

20
#include <stdint.h>

21
#include <avr/signal.h>

22
#include <util/delay.h>

23
#include <stdbool.h>

24
#include <stdlib.h>

25


26
/*

27
Variablen:

28
leds: speichert den momentanen zustand der LEDs (logischerweise: true=an, false=aus)

29
leds_copy: in der timerroutine werden die neuen zustände gepspeichert

30
leds_check, leds_check2: hier werden die 2 letzten zustände gespeichert um eine endlosschleife oder ein Standbild festzustellen

31
kill_game: gibt die anweisung das Game of Life neu zu starten

32
kill_count: wird benötigt um vor dem neustart das aktuelle bild noch etwas anzuzeigen

33
count: zählt die jeweiligen nachbarn, könnte man auch als lokale var machen, ich habs halt hier rein gemacht, damit nicht immer

34
       speicher allokiert werden muss (weiß nicht wieviel zeit das auf einem µC braucht)

35
x1,x2,y1,y2: Hilftvariablen, die die schleife erheblich verlangsamen, sind dazu da um grenzübergreifend zu agieren

36
counter: zählt, wie oft ein overflow stattfand. ggf. erhöhen, wenn ein höheres Quarz eingesetzt wird, momentan ist es auf ein

37
         8MhZ quarz abgestimmt.

38


39
*/

40
volatile bool leds[10][10];

41
volatile bool leds_copy[10][10];

42
volatile bool leds_check[10][10];

43
volatile bool leds_check2[10][10];

44
volatile bool kill_game;

45
volatile int kill_count;

46
volatile short count, x1, x2, y1, y2;

47
volatile int counter;

48


49
// Timer overflow

50
ISR(TIMER0_OVF_vect)

51
{

52
    // Nur bei jedem 10. overflow ausführen

53
    counter++;

54
    if (counter >= 10)

55
    {

56
        counter = 0;

57
        // Nachbarn berechnen

58
        for (int x = 0; x<=9; x++)

59
        {

60
            for (int y = 0; y<=9; y++)

61
            {

62
                count = 0;

63
                x1 = x-1;

64
                x2 = x+1;

65
                y1 = y-1;

66
                y2 = y+1;

67
                if (x1 < 0)

68
                {

69
                    x1 = 9;

70
                }

71
                if (x2 > 9)

72
                {

73
                    x1 = 0;

74
                }

75
                if (y1 < 0)

76
                {

77
                    y1 = 9;

78
                }

79
                if (y2 > 9)

80
                {

81
                    y2 = 0;

82
                }

83


84
                if (leds[x1][y1])

85
                {

86
                    count++;

87
                }

88
                if (leds[x1][y])

89
                {

90
                    count++;

91
                }

92
                if (leds[x1][y2])

93
                {

94
                    count++;

95
                }

96


97
                if (leds[x][y1])

98
                {

99
                    count++;

100
                }

101
                if (leds[x][y2])

102
                {

103
                    count++;

104
                }

105


106
                if (leds[x2][y1])

107
                {

108
                    count++;

109
                }

110
                if (leds[x2][y])

111
                {

112
                    count++;

113
                }

114
                if (leds[x2][y2])

115
                {

116
                    count++;

117
                }

118
                // neuen zustand in leds_copy speichern

119
                if (leds[x][y])

120
                {

121
                    if (count <= 1)

122
                    {

123
                        leds_copy[x][y] = false;

124
                    }

125
                    else if ((count == 2) || (count == 3))

126
                    {

127
                        leds_copy[x][y] = true;

128
                    }

129
                    else if (count > 3)

130
                    {

131
                        leds_copy[x][y] = false;

132
                    }

133
                }

134
                else

135
                {

136
                    if (count == 3)

137
                    {

138
                        leds_copy[x][y] = true;

139
                    }

140
                }

141


142


143


144


145
            }

146
        }

147
        // leds_copy nach leds schreiben und gleichzeitig letzte 2 zustände mit dem jetzigen vergleichen, wenn beide sich unterscheiden

148
        // kill auf false setzen (kill wird später kill_game zugewiesen

149
        bool kill;

150
        kill = true;

151


152
        for (int i = 0; i <= 9; i++)

153
        {

154
            for (int j = 0; j <= 9; j++)

155
            {

156
                if ((leds_copy[i][j] != leds_check[i][j]) && (leds_copy[i][j] != leds_check2[i][j]))

157
                {

158
                    kill = false;

159
                }

160
                leds[i][j] = leds_copy[i][j];

161
                leds_check2[i][j] = leds_check[i][j];

162
                leds_check[i][j] = leds[i][j];

163
            }

164
        }

165
        counter=0;

166
        kill_game = kill;

167
    }

168
}

169


170


171
// Timer einstellungen

172
void timer (void)

173
{

174
    TCCR0 |= (1<<CS00)|(1<<CS02);

175
    TIMSK   = (1<<TOIE0);

176
    sei();                 // Vorteiler ist 1024

177
}

178


179
int main (void)

180
{

181
    // Ein- und Ausgänge setzen

182
    DDRB  = 0b00111111;

183
    DDRC  = 0b00111111;

184
    DDRD  = 0b11111111;

185
    // ALLE LEDS AN!

186
    PORTB = 0b00111111;

187
    PORTC = 0b00001111;

188
    PORTD = 0b00000000;

189


190
    // Alle LEDs in der Matrix ausschalten:

191
    for (int i = 0; i <= 9; i++)

192
    {

193
        for (int j = 0; j <= 9; j++)

194
        {

195
            leds[i][j] = false;

196
        }

197
    }

198
    // Da erster anlauf, muss feld initialisiert werden

199
    kill_game = true;

200
    kill_count = 999;

201
    // timer aktivieren

202
    timer();

203
    while (1)

204
    {

205
        // Damit man die letzte position eines spiels noch etwas betrachten kann, erst nach 1000 increments von kill_count das spiel neu

206
        // initialisieren

207
        if (kill_game)

208
        {

209
            kill_count++;

210
        }

211
        if ((kill_game) && (kill_count >= 1000))

212
        {

213
            // alle felder zufällig auffüllen

214
            kill_game = false;

215
            for (int i = 0; i <= 9; i++)

216
            {

217
                for (int j = 0; j <= 9; j++)

218
                {

219
                    if (rand() / (RAND_MAX / 2 + 1) == 1)

220
                    {

221
                        leds_copy[i][j] = true;

222
                        leds_check[i][j] = false;

223
                    }

224
                    else

225
                    {

226
                        leds_copy[i][j] = false;

227
                        leds_check[i][j] = true;

228
                    }

229
                }

230
            }

231
            kill_count = 0;

232
        }

233
        // Hier kommt die ausgabe der anzeigen

234
        // hier habe ich ein seltsames phänomen mitbekommen, das ich relativ drastisch gelöst habe

235
        // wenn man nur eine anzeigen macht mit der hiesigen schleife, ergibt sich ein helligkeitsverlauf von links nach rechts,

236
        // wobei die LEDs rechts auf der anzeige dunkler waren, also habe ich einfach durchläufe von allein seiten gemacht, je mit

237
        // inkrements und dekrements. Kann man sicherlich optimieren, bin ich auch grade dran.

238
        PORTC = 0b00110000;

239
        PORTB = 0b00000000;

240
        PORTD = 0b11111111;

241
        for (int x = 0; x<=9; x++)

242
        {

243
            PORTC = 0b00110000;

244
            PORTB = 0b00000000;

245
            PORTD = 0b11111111;

246
            for (int y = 0; y<= 9; y++)

247
            {

248
                if (leds[x][y])

249
                {

250
                    if (x <= 5)

251
                    {

252
                        PORTB |= (1 << x);

253
                    }

254
                    else

255
                    {

256
                        PORTC |= (1 << (x - 6));

257
                    }

258
                    if (y <= 7)

259
                    {

260
                        PORTD &= ~(1 << y);

261
                    }

262
                    else

263
                    {

264
                        PORTC &= ~(1 << (y-4));

265
                    }

266
                }

267
            }

268
        }

269
        for (int y = 0; y<=9; y++)

270
        {

271
            PORTC = 0b00110000;

272
            PORTB = 0b00000000;

273
            PORTD = 0b11111111;

274
            for (int x = 0; x<= 9; x++)

275
            {

276
                if (leds[x][y])

277
                {

278
                    if (x <= 5)

279
                    {

280
                        PORTB |= (1 << x);

281
                    }

282
                    else

283
                    {

284
                        PORTC |= (1 << (x - 6));

285
                    }

286
                    if (y <= 7)

287
                    {

288
                        PORTD &= ~(1 << y);

289
                    }

290
                    else

291
                    {

292
                        PORTC &= ~(1 << (y-4));

293
                    }

294
                }

295
            }

296
        }

297


298
        for (int x = 9; x>=0; x--)

299
        {

300
            PORTC = 0b00110000;

301
            PORTB = 0b00000000;

302
            PORTD = 0b11111111;

303
            for (int y = 9; y>=0; y--)

304
            {

305
                if (leds[x][y])

306
                {

307
                    if (x <= 5)

308
                    {

309
                        PORTB |= (1 << x);

310
                    }

311
                    else

312
                    {

313
                        PORTC |= (1 << (x - 6));

314
                    }

315
                    if (y <= 7)

316
                    {

317
                        PORTD &= ~(1 << y);

318
                    }

319
                    else

320
                    {

321
                        PORTC &= ~(1 << (y-4));

322
                    }

323
                }

324
            }

325
        }

326


327
        for (int y = 9; y>=0; y--)

328
        {

329
            PORTC = 0b00110000;

330
            PORTB = 0b00000000;

331
            PORTD = 0b11111111;

332
            for (int x = 9; x>=0; x--)

333
            {

334
                if (leds[x][y])

335
                {

336
                    if (x <= 5)

337
                    {

338
                        PORTB |= (1 << x);

339
                    }

340
                    else

341
                    {

342
                        PORTC |= (1 << (x - 6));

343
                    }

344
                    if (y <= 7)

345
                    {

346
                        PORTD &= ~(1 << y);

347
                    }

348
                    else

349
                    {

350
                        PORTC &= ~(1 << (y-4));

351
                    }

352
                }

353
            }

354
        }

355
    }

356
    return 0;

357
}


Der Teil mit dem Konstanten array ist noch nicht implementiert, daher 
fehlt dieser Teil, auf den sich meine Frage bezieht hier sowieso 
gänzlich.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Rufus Τ. F. Persönliche Seite #2332968
Lesenswert?
• ▲
▼ 
Markus Foitschik schrieb:
> field = (true,false,false,false,false,false,false,false,false,
> false,false,false,true,false,false,false,false,false,false,false,
> (etc.)
> false,false,false,false,false,false,false,false,false,false,false,
> false,false,true);
>
> es handelt sich um diesen typ:
> volatile bool field[10][10];

Es gibt zwei Möglichkeiten:

Bei der Definition der Variablen 'field' kann diese initialisisert 
werden:

1
volatile bool field[10][10] = {

2
  { true, false, false, false, false, false, false, false, false, false },

3
  { false, false, false, false, false, false, false, false, false, false },

4
// etc.

5
  { false, false, false, false, false, false, false, false, false, true }

6
};


Es handelt sich hier um ein zweidimensionales Array, deswegen muss jede 
Zeile einzeln initialisiert werden.

Auf dem Wege der nachträglichen Zuweisung (mit weichem 's', daher 
nie mit 'ß' zu schreiben) geht das so aber nicht. In C können Arrays 
nicht zugewiesen werden.

Macht hier aber nichts, da praktisch alle Elemente des Arrays identisch 
(nämlich mit false) besetzt werden sollen, und nur zwei davon 
abweichen, ist folgende Vorgehensweise möglich:

1
volatile bool field[10][10];

2


3
memset(field, false, sizeof (field));

4


5
field[0][0] = true;

6
field[9][9] = true;


Ansonsten gilt der übliche Literaturhinweis:

Brian Kernighan & Dennis Ritchie, "Programmieren in C", zweite Auflage, 
Hanser-Verlag.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
MWS Gast #2333436
Lesenswert?
• ▲
▼ 
Rufus Τ. Firefly schrieb:
> und nur zwei davon abweichen

Nicht ganz, schau' genauer hin...
1
bool field [10] [10] = {{true, [1 ... 9] = false},

2
                        {[0 ... 1] false, true, [3 ... 9] false},

3
                        {[0 ... 9] false},

4
                        {[0 ... 9] false},

5
                        {[0 ... 9] false},

6
                        {[0 ... 9] false},

7
                        {[0 ... 9] false},

8
                        {[0 ... 9] false},

9
                        {[0 ... 9] false},

10
                        {[0 ... 8] false, true}};


> Ansonsten gilt der übliche Literaturhinweis:
>
> Brian Kernighan & Dennis Ritchie, "Programmieren in C", zweite Auflage,
> Hanser-Verlag.

Allein das hier würde 90% der Standardfragen beantworten:
www.gnu.org/s/gnu-c-manual/gnu-c-manual.pdf
Antwort Zitieren Bearbeiten Löschen Beitrag melden
MWS Gast #2333468
Lesenswert?
• ▲
▼ 
Klaus Wachtler schrieb:
> MWS schrieb:
>> Nicht ganz, schau' genauer hin...
>
> Ist zwar Standard (C99), aber geht meines Wissens nicht bei VC++.

Da wir uns gerade im GCC Forumsbereich aufhalten, ist es u.U. möglich, 
daß der TS seine Anfrage nicht aus Versehen hier reingeschrieben hat. :D

Mein Hinweis bezog sich aber darauf, daß nicht nur das erste und letzte 
Element, sondern auch das 13te (siehe oben) "true" zu sein hat.
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Jörg W. Moderator Persönliche Seite #2333624
Lesenswert?
• ▲
▼ 
MWS schrieb:

> Nicht ganz, schau' genauer hin...
1
bool field [10] [10] = {{true, [1 ... 9] = false},

2
                        {[0 ... 1] false, true, [3 ... 9] false},

3
                        {[0 ... 9] false},

4
                        {[0 ... 9] false},

5
                        {[0 ... 9] false},

6
                        {[0 ... 9] false},

7
                        {[0 ... 9] false},

8
                        {[0 ... 9] false},

9
                        {[0 ... 9] false},

10
                        {[0 ... 8] false, true}};


Dann geht's so:

1
bool field [10] [10] = {{true},

2
                        {false, false, true},

3
                        {false},

4
                        {false},

5
                        {false},

6
                        {false},

7
                        {false},

8
                        {false},

9
                        {false},

10
                        {false, false, false, false, false,

11
                         false, false, false, false, true}};
Antwort Zitieren Bearbeiten Löschen Beitrag melden
Thread beobachten

Antwort schreiben

Bitte melde dich an, um einen Beitrag zu schreiben.

Bestehender Account

oder

Mit Google-Account einloggen

Noch kein Account?

Die Registrierung ist kostenlos und dauert nur eine Minute.

Jetzt registrieren