Forum: Compiler & IDEs Zuweisung eines arrays


von Markus F. (nidhoegger)


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.

von Naja (Gast)


Lesenswert?

"Weissen" oder "weißen" tut man Wände.
Das heisst "zuweisen"!

Um welche Sprache handelt es sich?

von Naja (Gast)


Lesenswert?

>Um welche Sprache handelt es sich?

Das war die ernstgemeinte Frage nach der Programmiersprache.
"volatile" deutet auf C hin, aber die Initialisierung passt nicht.
Deswegen die Nachfrage.

von Markus F. (nidhoegger)


Lesenswert?

Sorry, hatte ich wohl vergessen, es handelt sich um C ;).
und sorry für den tippfehler

von Naja (Gast)


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.

von Markus F. (nidhoegger)


Lesenswert?

Das ist ganz einfach warum ich das machen will: es sind die initialwerte 
die alle 100 schritte in den zweidimensionalen array geladen werden 
sollen. und ich hab keine lust jedes feld einzeln per field[0][0] = 
true; anzusprechen.

von Naja (Gast)


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?

von Naja (Gast)


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.

von Markus F. (nidhoegger)


Lesenswert?

ich WILL es so machen wie es oben dasteht. mit einzeln zuweisen rede ich 
von:

field[0][0] := true;
field[0][1] := false;
etc.pp.

von Markus F. (nidhoegger)


Lesenswert?

glaube auch das es einfach ein missverständniss war. danke auf jedenfall

von Markus F. (nidhoegger)


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

von Naja (Gast)


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).

von Markus F. (nidhoegger)


Lesenswert?

okay danke! damit ist meine frage geklärt, werd ich das wohl mit viel 
schreibarbeit machen müssen ^^

von Markus F. (nidhoegger)


Lesenswert?

andere frage: 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.

von Naja (Gast)


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.

von Naja (Gast)


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.

von Naja (Gast)


Lesenswert?

Allerdings wird memcpy intern auch mit einer Schleife arbeiten.
Was hast Du denn gegen Schleifen?

von Markus F. (nidhoegger)


Lesenswert?

warum kompliziert, wenns auch einfach ginge, in dem fall geht es eben 
nicht und ich muss auf schleifen zurückgreifen ;)

und die der fehler hat was mit der zuweisung zu tun, weil er sich genau 
darauf bezieht ;)

von Naja (Gast)


Lesenswert?

Na, wenn Du es besser weisst, dann frag nicht...

von Markus F. (nidhoegger)


Lesenswert?

entschuldigung aber wenn der fehler genau die zeile ankreidelt, in der 
die zuweisung ist (main.c:203: Fehler: expected expression before »{« 
token) dann hat das wohl sehr wohl damit was zu tun, und zwar das er die 
{} hinter dem = nicht mag.

von Naja (Gast)


Lesenswert?

Wahrscheinlich redet der Compiler nur von "y1" weil er auch mal was 
unsinniges sagen möchte...

Mannoman, keine Ahnung, aber noch die Antwortenden korrigieren...

von Naja (Gast)


Lesenswert?

Na schön. Warum antworte ich hier überhaupt und dann noch auf 
unvollständigen Code? Selber schuld.

von Markus F. (nidhoegger)


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.

von Naja (Gast)


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.

von Markus F. (nidhoegger)


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.

von HP (Gast)


Lesenswert?

der gcc-Compiler kennt y1 als builtin function (Bessel-Funktion), 
deshalb warnt er hier, dass y1 umdefiniert wird als short. Die 
Umdefinition wird aber akzeptiert und deswegen funktioniert der Code.

s. http://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html

Microsoft Compiler kennen die Bessel-Funktion vermutlich nicht als 
builtin function, deswegen geht's dort ohne Warning.

HP

von Rufus Τ. F. (rufus) Benutzerseite


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.

von MWS (Gast)


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

von Klaus W. (mfgkw)


Lesenswert?

MWS schrieb:
> Nicht ganz, schau' genauer hin...

Ist zwar Standard (C99), aber geht meines Wissens nicht bei VC++.

von MWS (Gast)


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.

von Jörg W. (dl8dtl) (Moderator) Benutzerseite


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}};

von MWS (Gast)


Lesenswert?

Jörg Wunsch schrieb:
> Dann geht's so:
...
Ja, so auch, wobei ich meine Version ein klein wenig übersichtlicher 
finde. Wenn's ein bisserl kryptischer sein darf, dann ginge das als 
Abwandlung ja auch noch :D
1
bool field [10] [10] = {{1},{0,0,1},{0},{0},{0},{0},{0},{0},{0},{0,0,0,0,0,0,0,0,0,1}};

von Klaus W. (mfgkw)


Lesenswert?

MWS schrieb:
> Wenn's ein bisserl kryptischer sein darf

ach, dann kannst du auch noch die 0en durch !1 ersetzen und die 1en 
durch !0.

von MWS (Gast)


Lesenswert?

Klaus Wachtler schrieb:
> ach, dann kannst du auch noch die 0en durch !1 ersetzen und die 1en
> durch !0.

Mist, da kam ich jetzt nicht drauf :-)

Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.