www.mikrocontroller.net

Forum: Compiler & IDEs Zuweisung eines arrays


Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hi, ich würde gerne einem array alle werte so in dieser form zuweißen:
field = (true,false,false,false,false,false,false,false,false,
false,false,false,true,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
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];

Wie kann ich das denn machen? ich habe keine lust jedes feld einzeln 
zuzuweißen.

Autor: Naja (Gast)
Datum:

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

Um welche Sprache handelt es sich?

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Markus Foitschik (nidhoegger)
Datum:

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

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Mal anders geantwortet:

Dieses Codefragment
field = (true,false,false,false,false,false,false,false,false,
false,false,false,true,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,false,
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.

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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?

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
glaube auch das es einfach ein missverständniss war. danke auf jedenfall

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
leds = { true,false,false,false,false,false,false,false,false,false,
false,false,true,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,false,
false,false,false,false,false,false,false,false,false,true };

gibt mir:
Compiling C: main.c
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 
In Datei, eingefügt von main.c:21:
/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>."
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

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ach, Mensch. Du meinst wahrscheinlich folgendes.

Das:
a[0][0] = 77;
ist eine einzelne Zuweisung.

Das aber:
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).

Autor: Markus Foitschik (nidhoegger)
Datum:

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

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Naja (Gast)
Datum:

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

Kaum:
for (i = 0; i < 10; i++)
  for (k = 0; k < 10; k++)
    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.

Autor: Naja (Gast)
Datum:

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

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht 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 ;)

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Na, wenn Du es besser weisst, dann frag nicht...

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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...

Autor: Naja (Gast)
Datum:

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

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Naja (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Markus Foitschik (nidhoegger)
Datum:

Bewertung
0 lesenswert
nicht 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...):
/***********************************************************************************
Projektname: Conways Game of Life
Author: Markus Foitschik (Nidhoegger)
Hardware used: ATMega8, 10x10 LED Matrix
Rules for the Game:
A living cell dies with 1 or 0 neighbours, as of loneliness
A living cell survives with 2 or 3 neighbours
A living cell dies with 4 or more neighbours, as of overpopulation
A dead cell gets born with exaclty 3 neighbours
License:
You can edit and change the project, but you may not release my original work on
other places, you will aknowlegde that i do not gibe warranties if something goes
wrong, you will leave my copyright and URL to the original project here. And you
will acknowlegde that my english is under all pig and wont shout at me because of
this.
***********************************************************************************/

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdint.h>
#include <avr/signal.h>
#include <util/delay.h>
#include <stdbool.h>
#include <stdlib.h>

/*
Variablen:
leds: speichert den momentanen zustand der LEDs (logischerweise: true=an, false=aus)
leds_copy: in der timerroutine werden die neuen zustände gepspeichert
leds_check, leds_check2: hier werden die 2 letzten zustände gespeichert um eine endlosschleife oder ein Standbild festzustellen
kill_game: gibt die anweisung das Game of Life neu zu starten
kill_count: wird benötigt um vor dem neustart das aktuelle bild noch etwas anzuzeigen
count: zählt die jeweiligen nachbarn, könnte man auch als lokale var machen, ich habs halt hier rein gemacht, damit nicht immer
       speicher allokiert werden muss (weiß nicht wieviel zeit das auf einem µC braucht)
x1,x2,y1,y2: Hilftvariablen, die die schleife erheblich verlangsamen, sind dazu da um grenzübergreifend zu agieren
counter: zählt, wie oft ein overflow stattfand. ggf. erhöhen, wenn ein höheres Quarz eingesetzt wird, momentan ist es auf ein
         8MhZ quarz abgestimmt.

*/
volatile bool leds[10][10];
volatile bool leds_copy[10][10];
volatile bool leds_check[10][10];
volatile bool leds_check2[10][10];
volatile bool kill_game;
volatile int kill_count;
volatile short count, x1, x2, y1, y2;
volatile int counter;

// Timer overflow
ISR(TIMER0_OVF_vect)
{
    // Nur bei jedem 10. overflow ausführen
    counter++;
    if (counter >= 10)
    {
        counter = 0;
        // Nachbarn berechnen
        for (int x = 0; x<=9; x++)
        {
            for (int y = 0; y<=9; y++)
            {
                count = 0;
                x1 = x-1;
                x2 = x+1;
                y1 = y-1;
                y2 = y+1;
                if (x1 < 0)
                {
                    x1 = 9;
                }
                if (x2 > 9)
                {
                    x1 = 0;
                }
                if (y1 < 0)
                {
                    y1 = 9;
                }
                if (y2 > 9)
                {
                    y2 = 0;
                }

                if (leds[x1][y1])
                {
                    count++;
                }
                if (leds[x1][y])
                {
                    count++;
                }
                if (leds[x1][y2])
                {
                    count++;
                }

                if (leds[x][y1])
                {
                    count++;
                }
                if (leds[x][y2])
                {
                    count++;
                }

                if (leds[x2][y1])
                {
                    count++;
                }
                if (leds[x2][y])
                {
                    count++;
                }
                if (leds[x2][y2])
                {
                    count++;
                }
                // neuen zustand in leds_copy speichern
                if (leds[x][y])
                {
                    if (count <= 1)
                    {
                        leds_copy[x][y] = false;
                    }
                    else if ((count == 2) || (count == 3))
                    {
                        leds_copy[x][y] = true;
                    }
                    else if (count > 3)
                    {
                        leds_copy[x][y] = false;
                    }
                }
                else
                {
                    if (count == 3)
                    {
                        leds_copy[x][y] = true;
                    }
                }




            }
        }
        // leds_copy nach leds schreiben und gleichzeitig letzte 2 zustände mit dem jetzigen vergleichen, wenn beide sich unterscheiden
        // kill auf false setzen (kill wird später kill_game zugewiesen
        bool kill;
        kill = true;

        for (int i = 0; i <= 9; i++)
        {
            for (int j = 0; j <= 9; j++)
            {
                if ((leds_copy[i][j] != leds_check[i][j]) && (leds_copy[i][j] != leds_check2[i][j]))
                {
                    kill = false;
                }
                leds[i][j] = leds_copy[i][j];
                leds_check2[i][j] = leds_check[i][j];
                leds_check[i][j] = leds[i][j];
            }
        }
        counter=0;
        kill_game = kill;
    }
}


// Timer einstellungen
void timer (void)
{
    TCCR0 |= (1<<CS00)|(1<<CS02);
    TIMSK   = (1<<TOIE0);
    sei();                 // Vorteiler ist 1024
}

int main (void)
{
    // Ein- und Ausgänge setzen
    DDRB  = 0b00111111;
    DDRC  = 0b00111111;
    DDRD  = 0b11111111;
    // ALLE LEDS AN!
    PORTB = 0b00111111;
    PORTC = 0b00001111;
    PORTD = 0b00000000;

    // Alle LEDs in der Matrix ausschalten:
    for (int i = 0; i <= 9; i++)
    {
        for (int j = 0; j <= 9; j++)
        {
            leds[i][j] = false;
        }
    }
    // Da erster anlauf, muss feld initialisiert werden
    kill_game = true;
    kill_count = 999;
    // timer aktivieren
    timer();
    while (1)
    {
        // Damit man die letzte position eines spiels noch etwas betrachten kann, erst nach 1000 increments von kill_count das spiel neu
        // initialisieren
        if (kill_game)
        {
            kill_count++;
        }
        if ((kill_game) && (kill_count >= 1000))
        {
            // alle felder zufällig auffüllen
            kill_game = false;
            for (int i = 0; i <= 9; i++)
            {
                for (int j = 0; j <= 9; j++)
                {
                    if (rand() / (RAND_MAX / 2 + 1) == 1)
                    {
                        leds_copy[i][j] = true;
                        leds_check[i][j] = false;
                    }
                    else
                    {
                        leds_copy[i][j] = false;
                        leds_check[i][j] = true;
                    }
                }
            }
            kill_count = 0;
        }
        // Hier kommt die ausgabe der anzeigen
        // hier habe ich ein seltsames phänomen mitbekommen, das ich relativ drastisch gelöst habe
        // wenn man nur eine anzeigen macht mit der hiesigen schleife, ergibt sich ein helligkeitsverlauf von links nach rechts,
        // wobei die LEDs rechts auf der anzeige dunkler waren, also habe ich einfach durchläufe von allein seiten gemacht, je mit
        // inkrements und dekrements. Kann man sicherlich optimieren, bin ich auch grade dran.
        PORTC = 0b00110000;
        PORTB = 0b00000000;
        PORTD = 0b11111111;
        for (int x = 0; x<=9; x++)
        {
            PORTC = 0b00110000;
            PORTB = 0b00000000;
            PORTD = 0b11111111;
            for (int y = 0; y<= 9; y++)
            {
                if (leds[x][y])
                {
                    if (x <= 5)
                    {
                        PORTB |= (1 << x);
                    }
                    else
                    {
                        PORTC |= (1 << (x - 6));
                    }
                    if (y <= 7)
                    {
                        PORTD &= ~(1 << y);
                    }
                    else
                    {
                        PORTC &= ~(1 << (y-4));
                    }
                }
            }
        }
        for (int y = 0; y<=9; y++)
        {
            PORTC = 0b00110000;
            PORTB = 0b00000000;
            PORTD = 0b11111111;
            for (int x = 0; x<= 9; x++)
            {
                if (leds[x][y])
                {
                    if (x <= 5)
                    {
                        PORTB |= (1 << x);
                    }
                    else
                    {
                        PORTC |= (1 << (x - 6));
                    }
                    if (y <= 7)
                    {
                        PORTD &= ~(1 << y);
                    }
                    else
                    {
                        PORTC &= ~(1 << (y-4));
                    }
                }
            }
        }

        for (int x = 9; x>=0; x--)
        {
            PORTC = 0b00110000;
            PORTB = 0b00000000;
            PORTD = 0b11111111;
            for (int y = 9; y>=0; y--)
            {
                if (leds[x][y])
                {
                    if (x <= 5)
                    {
                        PORTB |= (1 << x);
                    }
                    else
                    {
                        PORTC |= (1 << (x - 6));
                    }
                    if (y <= 7)
                    {
                        PORTD &= ~(1 << y);
                    }
                    else
                    {
                        PORTC &= ~(1 << (y-4));
                    }
                }
            }
        }

        for (int y = 9; y>=0; y--)
        {
            PORTC = 0b00110000;
            PORTB = 0b00000000;
            PORTD = 0b11111111;
            for (int x = 9; x>=0; x--)
            {
                if (leds[x][y])
                {
                    if (x <= 5)
                    {
                        PORTB |= (1 << x);
                    }
                    else
                    {
                        PORTC |= (1 << (x - 6));
                    }
                    if (y <= 7)
                    {
                        PORTD &= ~(1 << y);
                    }
                    else
                    {
                        PORTC &= ~(1 << (y-4));
                    }
                }
            }
        }
    }
    return 0;
}


Der Teil mit dem Konstanten array ist noch nicht implementiert, daher 
fehlt dieser Teil, auf den sich meine Frage bezieht hier sowieso 
gänzlich.

Autor: HP (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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

Autor: Rufus Τ. Firefly (rufus) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht 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:
volatile bool field[10][10] = {
  { true, false, false, false, false, false, false, false, false, false },
  { false, false, false, false, false, false, false, false, false, false },
// etc.
  { false, false, false, false, false, false, false, false, false, true }
};

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:
volatile bool field[10][10];

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

field[0][0] = true;
field[9][9] = true;

Ansonsten gilt der übliche Literaturhinweis:

Brian Kernighan & Dennis Ritchie, "Programmieren in C", zweite Auflage, 
Hanser-Verlag.

Autor: MWS (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Rufus Τ. Firefly schrieb:
> und nur zwei davon abweichen

Nicht ganz, schau' genauer hin...
bool field [10] [10] = {{true, [1 ... 9] = false},
                        {[0 ... 1] false, true, [3 ... 9] false},
                        {[0 ... 9] false},
                        {[0 ... 9] false},
                        {[0 ... 9] false},
                        {[0 ... 9] false},
                        {[0 ... 9] false},
                        {[0 ... 9] false},
                        {[0 ... 9] false},
                        {[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

Autor: Klaus Wachtler (mfgkw)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
MWS schrieb:
> Nicht ganz, schau' genauer hin...

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

Autor: MWS (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: Jörg Wunsch (dl8dtl) (Moderator) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
MWS schrieb:

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

Dann geht's so:
bool field [10] [10] = {{true},
                        {false, false, true},
                        {false},
                        {false},
                        {false},
                        {false},
                        {false},
                        {false},
                        {false},
                        {false, false, false, false, false,
                         false, false, false, false, true}};

Autor: MWS (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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
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}};

Autor: Klaus Wachtler (mfgkw)
Datum:

Bewertung
0 lesenswert
nicht 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.

Autor: MWS (Gast)
Datum:

Bewertung
0 lesenswert
nicht 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 :-)

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.