array auf nullen überprüfen

[Johannes (Gast)]

nabend,
ich habe einen Array, der von verschiedenen Sensoren beschrieben wird. 
Die Sensoren werden angefragt, ob die noch da sind und wenn ja, 
antworten diese und beschreiben  einen definierten platz des arrays mit 
einer 1.
Jetzt möchte ich überprüfen, ob alle Sensoren geantwortet haben. Muss 
ich dazu mit einer for-Schleife jeden platz des arrays durchgehen und 
auf 1, bzw. auf 0 überprüfen? Oder gibt es da noch einen anderen weg?
Oder wäre es besser, einen integer zu nehmen und jeden Sensor durch 
Bitmanipulation ein einzelnes Bit beschreiben zu lassen? Dann wäre die 
Überprüfung ja
if((variable & 0xFF) == 0xFF)
wenn ja, haben alle geantwortet, wenn nein, müsste ich ebenfalls jedes 
Bit durchgehen, ob dieses 1 oder 0 ist.

Johannes

[Klaus R. (klara)]

Wie viele Sensoren sind es denn?
Welche Programmiersprache?
Musst Du Speicherplatz sparen?
Soll es schnell sein?

[Tom K. (ez81)]

Johannes schrieb:
> Muss
> ich dazu mit einer for-Schleife jeden platz des arrays durchgehen und
> auf 1, bzw. auf 0 überprüfen?

Das ist der einfachste Weg und deshalb erstmal der richtige. Wenn Du auf 
Speicher- oder Laufzeitprobleme (echte, nicht eingebildete) triffst, 
kannst Du über anderes nachdenken, aber als Anfänger (und Nichtanfänger) 
auf Verdacht irgendwelche wilden Bitschubs-Konstrukte zu bauen, um 
sinnlos ein paar Takte oder Byte zu sparen, macht den Code nicht besser.

[Kernelhacker (Gast)]

Johannes schrieb:
> Muss
> ich dazu mit einer for-Schleife jeden platz des arrays durchgehen und
> auf 1, bzw. auf 0 überprüfen?

if ((a[0] & a[1] & a[2] & a[3] & a[4] & a[5] & a[6] & a[7] & 1) == 1)
...

[sowirdsgemacht (Gast)]

int testforzero(int *arr)
{
  memset(arr, 0, 8);
  return(1);
}

[Sebastian S. (amateur)]

Du wirst unter jeder Adresse nachfragen müssen, ob jemand zuhause ist. 
Auch wenn Du dazu später eine fertige Array-Funktion nimmst.

Es gibt allerdings ein paar Tricks, wie man das ganze beschleunigen 
kann.

Benutzt Du z.B. ein gepacktes Array, welches ein Vielfaches von 4 an 
Einträgen hat, kannst Du möglicherweise eine Doppelwortabfrage (4 Bytes 
auf einmal haben den Wert 0x01010101 bzw. 16843009) anwenden.

Eine weitere Möglichkeit ist, ein Flag zu nutzen. Sinnvoll, wenn Du das 
ganze Zyklisch bearbeitest. Du fragst jedes Mal ab, ob der einzelne 
Sensor geantwortet hat und setzt das vor dem Start gesetzte Flag auf 0 
wenn Dich jemand nicht mag. Am Ende der Abfrage kannst Du, nur durch die 
Abfrage dieses Flags feststellen, ob sich die Suche nach einer Null 
überhaupt lohnt.

[Jakob (Gast)]

Ob alle Sensoren geantwortet haben...

Was du beschreibst, funtioniert doch nur, wenn du zu einem
Startzeitpunkt erst mal das ganze Antwort-Array (oder die
Antwort-Variable) auf NULL gesetzt hast und nach Abfrage
aller Sensoren den Vergleich startest.

Wenn du N Sensoren eine Speicher-Adresse zugeordnet hast,
kannst du ihnen auch eine Zahl 2^n (n = 0...N-1) zuordnen.

Wenn N <= 8, oder <= 16 ist, geht das bequem mit einer
8-Bit, oder 16-Bit-Variablen.

Der zeiliche Vorteil ist minimal, bringt eher was bei
knappem Speicher.

Ablauf:
- Antwort-Variable = 0
- Bei erfolgreicher Abfrage des jeweiligen Sensors addierst
  du den zugeordneten Wert zur Antwort-Variablen.
- Wenn alle abgefragt wurden, vergleichst du den Wert der
  Antwort-Variablen mit dem Wert 2^N - 1. Bei Gleichheit
  sind alle Sensoren bereit.

Im laufenden Betrieb solltest du aber auch das Array, oder die
Variable nutzen. - Sensoren verabschieden sich auch mal
zwischendrin - da sollte man nicht ewig mit dem letzten
gelieferten Wert weiterarbeiten!

[Sebastian S. (amateur)]

>Was du beschreibst, funtioniert doch nur, wenn du zu einem
>Startzeitpunkt erst mal das ganze Antwort-Array (oder die
>Antwort-Variable) auf NULL gesetzt hast und nach Abfrage
>aller Sensoren den Vergleich startest.

Nicht unbedingt!
Wird das gesamte Array zyklisch von Ah bis Zett abgearbeitet, wird ja 
auf jeden Fall immer der richtige und aktuelle Wert vorliegen. Das 
erspart dann automatisch einen Reset bzw. ein memset().
Wie gesagt, nur wenn systematisch vorgegangen wird.

[Dr. Sommer (Gast)]

Wenns C++ sein darf:

int array [] = { 1, 1, 1, 1 };

bool allAreOne = std::all_of (std::begin (array), std::end (array), [](auto x) { return x == 1; });

http://ideone.com/LUmRbw

[Joe F. (easylife)]

Johannes schrieb:
> ch habe einen Array, der von verschiedenen Sensoren beschrieben wird.

die Sensoren können ja nicht selbstständig ein Array beschreiben. Es 
wird in deinem Programm irgendwo eine Stelle geben, an der Sensor für 
Sensor abhefragt wird, und wenn der Sensor antwortet wird die 1 ins 
Array geschrieben.
Und genau hier kannst du auch einfach ein Flag setzen, wenn ein Sensor 
nicht antwortet, und dir das Array ganz sparen.

[fop (Gast)]

Hallo,
wenn sich die Sensoren asynchron an- und abmelden, kann man das Array 
nicht einsparen. Aber man könnte, wenn sich ein Sensor meldet, beim 
Eintragen in's Array mitzählen, wie viele Sensoren am Leben (oder 
stattdessen wie viele tot) sind. Dann brauchst Du nur Deinen Zähler 
befragen. Das Array benötigst, Du um das Zählen zu unterdrücken, wenn 
sich ein defekter Sensor nochmals defekt meldet bzw. ein 
funktionierender nochmals als intakt gemeldet wird.