C Array auf Inhalt prüfen?

Dussel schrieb:
> Der Andere schrieb:
>> Gar nicht
> Doch klar.
>
>

1

if(Array[0]==0&&Array[1]==0&&Array[2]==0&& … &&Array[n]==0)

2

> {

3

> …

4

> }

5

>

Genialer Programmierer schrieb:
> Atamer schrieb:
>> Also ohne eine Schleife zu durchlaufen.
>
> So:
>
>

1

> 

2

> if (elemnt[0] != 0)  err++;

3

> if (elemnt[1] != 0)  err++;

4

> if (elemnt[2] != 0)  err++;

5

> if (elemnt[3] != 0)  err++;

6

> if (elemnt[4] != 0)  err++;

7

> if (elemnt[5] != 0)  err++;

8

> if (elemnt[6] != 0)  err++;

9

> 

10

> // usw.

11

> 

12

>

>
> Braucht kaum Speicherplatz und geht ganz ohne Schleife.

Der 1. April war doch schon. ;-)

Was wenn das Array z.B. 256 Elemente hat? 256 Zeilen Code hinschreiben 
oder wie? Das macht doch kein normaler Mensch.

Atamer schrieb:
> Hallo,
>
> wie kann ich ein Array in C prüfen ob alle Werte darin 0 sind? Also ohne
> eine Schleife zu durchlaufen.

Warum sollte es ein sinnvoller Ansatz sein, keine Schleife zu verwenden? 
Das ist genau die Standardlösung, die immer und ohne Probleme 
funktioniert. Da braucht man schon einen guten Grund um davon 
abzuweichen.

Mark B. schrieb:
> Warum sollte es ein sinnvoller Ansatz sein, keine Schleife zu verwenden?

Damit man was fertiges benutzen kann.

Selber schreiben oder denken geht heute nicht mehr.
"Ist ja umständlich. In Programmiersprache XY geht das ganz einfach"

Ohne (eigene) Schleife:

Neues Array anlegen und mit 0 initialisieren oder mit memset auf 0 
setzen.
oder ausreichend Speicher mit calloc besorgen.

Dann mit memcmp vergleichen.

Vielleicht sowas in die richtung?

1

struct int_array {

2

  size_t set_count;

3

  int* data;

4

};

5

6

int array_data[10]={0};

7

struct int_array array={0,array_data};

8

9

void int_array_setValue( struct int_array* a, size_t i, int x ){

10

  int y = a->data[i];

11

  if( x && !y ) a->set_count++;

12

  if( y && !x ) a->set_count--;

13

  a->data[i] = x;

14

}

15

16

bool int_array_isNoneSet( struct int_array* a ){

17

  return !a->set_count;

18

}

Oder mit Rekursion:

1

bool allZero(const int* data, size_t count)

2

{

3

    if(count == 0)

4

        return true;

5

    else

6

        return data[0] == 0 && allZero(data+1, count-1);

7

}

Man könnte das ganze auch rekursiv lösen, z.B. indem man das Problem für 
ein Array der Größe N auf das der Größe N-1 zurückführt oder z.B. einen 
Binärbaum aufbaut. Im ersten Fall skaliert der Speicherverbrauch auf dem 
Stack linear mit der Größe des Arrays und im zweiten logarithmisch.

Im konkreten Fall mag solch ein Vorgehen unglaublich ineffizient sein, 
aber bei manchen andere Fragestellungen durchaus sinnlos und effizient.

Nachtrag:
Mist, zu spät... ;-)

tictactoe schrieb:

1

 if (std::all_of(begin(a), end(a), [](auto x) { return x == 0; }))

Das ist kein C, sondern C++.

Vielleicht war hier tatsächlich eine rekursive Lösung gesucht anstatt 
einer iterativen. Dann klingt das Ganze ziemlich nach Hausaufgaben 
machen.