Prüfen: Wert existiert in Array

[Gnu (Gast)]

Guten Abend,

wie prüft man, ob ein Wert in einem Array ist?

irgendwie so?

bool inarray(liste,wert)
{
while(zeigeraufliste)

if(zeigeraufliste==wert)
  return true;

zeigeraufliste++;
}

liste[3+1] = {128,12,19,0};
wert = 19

if(inarray(liste,wert))
  beep();


-> BEEP!

Blöd ist aber, dass wert auch 0 sein kann!

[Falk B. (falk)]

@ Gnu (Gast)

>wie prüft man, ob ein Wert in einem Array ist?

Das geht im Prinzip schon so.

>Blöd ist aber, dass wert auch 0 sein kann!

Das geht prinzipiell nicht. Du musst einen Wert als "Leer" definieren, 
das kann jeder X-beliebige sein. GGf. grössere Variablen nehmen, 16 
statt 8 Bit.

MFG
Falk

[Gnu (Gast)]

Ah sehr gut - du hast nicht zufällig einen passenden Code-Ausschnitt 
(evtl. hier im Forum) parat?
Zeiger bringen mich immer komplett durcheinander..da brauche ich 
Stunden.

[Andreas S. (andreas) (Admin)]

C uebergibt nur einen Zeiger auf das erste Element des Arrays an die 
Funktion, die Funktion hat keine Moeglichkeit festzustellen wie lange 
das Array ist in dem du suchen willst. Du musst also die Laenge als 
Parameter mit uebergeben:

inarray(liste, wert, sizeof liste);

Den Rest duerftest du alleine hinbekommen.

[Gnu (Gast)]

Mhh, ich peil Zeiger einfach nicht.

#include <stdbool.h>

const uint8_t codearray[16] = {0,1,2,3,4,5,6,7,8,9,12,13,16,17,32,33};

bool inarray(uint8_t *array, uint8_t value, uint8_t size_of_array)
{

  uint8_t i = 0;

  for(i=0;i<=size_of_array;i++)
  {
    if(value == *array + i)
      return true;
  }
  return false;
}


uint8_t code = 13;

if(inarray(codearray,code,sizeof codearray))


> warning: passing argument 1 of 'inarray' discards qualifiers from pointer target 
type

[Gnu (Gast)]

darf anscheinend keine const sein.. ?

[Gnu (Gast)]

besser ist auch

if(value == array[i])

sonst kommt er nur bis zum wert 16

keine ahnung wieso :-(

[Chris (Gast)]

*array + i wird vom Compiler als (*array) + i interpretiert, das dürfte 
der Grund sein.

[yalu (Gast)]

*array + i    ist   array[0] + i
*(array + i)  ist   array[i]

Du möchtest letzteres. Von den beiden Alternativen ist array[i] die
lesbarere und weniger fehlerträchtige Schreibweise.

> warning: passing argument 1 of 'inarray' discards qualifiers from
> pointer target type

Du übergibst eine const-Variable (blöder Begriff, ich weiß) als
nicht-const-Argument. Da du gar nicht vor hast, in inarray() die
Arrayelemente zu überschreiben, deklarierst du die Funktion besser so:

bool inarray(const uint8_t *array, uint8_t value, uint8_t size_of_array)

[Gnu (Gast)]

Danke für die Erklärung! Ist ja eigentlich ganz einfach, man muss nur 
dran denken. Hoffentlich vergesse ich das nicht so schnell wieder ;-)

[Gnu (Gast)]

Kann man aus dem Stegreif eigentlich sagen, was schneller/kleiner ist?

if(inarray(codearray,code,sizeof codearray))
   beep();
else
   error();

oder

switch(code)
{

case 0: case 1: case 2: case 3: case 4:
case 5: case 6: case 7: case 8: case 9:
case 12: case 13: case 16: case 17: case 32: case 33:

  beep();

break;

default:
  error();
break;

}

Lohnt sich die Funktion schon bei 2 verschiedenen Aufrufen? Andererseits 
muss dann ein weiteres codearray deklariert werden..
Ich schätze fast, dass die switch-anweisung kompakter ist. ?

[Rufus Τ. F. (rufus)]

 for(i=0;i<=size_of_array;i++)

Das gibt einen Bufferoverflow. Ändere das zu

 for(i=0;i<size_of_array;i++)

[Gnu (Gast)]

Danke, hab ich gemacht.