Ich soll eine Funktion bool alleven(int feld[],int anzahl) schreiben die für ein übergebenes (feld) in dem anzahl Elemente gespeichert sind, bestimmt, ob alle Elemente gerade sind. Falls sich keine Elemente darin befinden so ist das Ergebnis true.

bool alleven(int feld[],int anzahl)
{
    bool ergebnis
	if (anzahl==0)
	{
	return true;
	}
	else
	{
		ergebnis= alleven(feld, anzahl-1);
		if (ergebnis==true)
		{
			if (feld[anzahl-1]%2==0)
			{
				return true;
			}
		      else 
			{
				return false;
			}
		}
		return false;
	}
}

Ist das so korrekt?

edit: Zu langsam.

Das sieht korrekt aus, aber extrem umständlich. Wie wäre es mit einer kleinen Schleife? Dann wird das zu einem Dreizeiler.

Ist das ein Ein- oder ein Vierzeiler?

bool alleven(int feld[], int anzahl)
{
  return anzahl == 0 || feld[0] % 2 == 0 && alleven(feld + 1, anzahl - 1);
}

bool alleven(int feld[], int anzahl)
{
  return anzahl == 0 || feld[0] % 2 == 0 && alleven(feld + 1, anzahl - 1);
}

Etwas Offtopic, aber das frage ich mich schon länger.

Wo steht im C++ Standard, dass der linke Ausdruck "anzahl == 0" als erstes Abgearbeitet wird? Und bei true die rechte Seite nicht weiter verarbeitet wird?

Das es so ist, dass kann man ja ausprobieren. Aber ist das Standard-Konform?

@314159265358979:
Ja, ist natürlich immer gut, Spezialfälle nicht zu berücksichtigen, von denen man meint sie wären sowieso verboten.

Stell dir vor, meine Funktion funktioniert trotzdem.

Wo steht im C++ Standard, dass der linke Ausdruck "anzahl == 0" als erstes Abgearbeitet wird? Und bei true die rechte Seite nicht weiter verarbeitet wird?

Da, wo der || Operator beschrieben wird (5.15§1).

Hallo Leute!

Ich soll eine Funktion bool alleven(int feld[],int anzahl) schreiben die für ein übergebenes (feld) in dem anzahl Elemente gespeichert sind, bestimmt, ob alle Elemente gerade sind. Falls sich keine Elemente darin befinden so ist das Ergebnis true.

bool alleven(int feld[],int anzahl)
{
    bool ergebnis
	if (anzahl==0)
	{
	return true;
	}
	else
	{
		ergebnis= alleven(feld, anzahl-1);
		if (ergebnis==true)
		{
			if (feld[anzahl-1]%2==0)
			{
				return true;
			}
		      else 
			{
				return false;
			}
		}
		return false;
	}
}

Ist das so korrekt?

Ja, sieht guut aus.

Aber Mega-Umständlich.

bool alleven(int feld[],int anzahl)
{
    bool ergebnis;//Nee, erst später definieren, erst, wenn man sie sinnvoll initialisieren kann
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        ergebnis= alleven(feld, anzahl-1);
        if (ergebnis==true)
        {
            if (feld[anzahl-1]%2==0)
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        bool ergebnis= alleven(feld, anzahl-1);//ach, dann kann sie auch weg
        if (ergebnis==true)
        {
            if (feld[anzahl-1]%2==0)
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true)
        {
            if (feld[anzahl-1]%2==0)//Trick 17
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

Trick 17:
if(ausdruck==true) return true; else return false; ist identisch zu und meistens besser zu lesen als return ausdruck;

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true)
        {
            return feld[anzahl-1]%2==0;
        }
        return false;
    }
}

Oh, in eine Optimier-Sackgasse getappt. Zurück.

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true)
        {
            if (feld[anzahl-1]%2==0)//Nee, nicht Trick 17, sondern Trick 18 rückwärts
            {
                return true;
            }
              else
            {
                return false;
            }
        }
        return false;
    }
}

Trick 18: if(A && cmd; ist identisch zu und oft besser zu lesen als if(A) if(B) cmd;

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        if (alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0)//17
        {
            return true;
        }
        else
        {
            return false;
        }
        return false;
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
    return true;
    }
    else
    {
        return alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0);
        return false;//UUps, woher kommt die Leiche denn?
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
    {
        return true;
    }
    else
    {
        return alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0);
    }
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
        return true;
    return alleven(feld, anzahl-1)==true && feld[anzahl-1]%2==0);
}

bool alleven(int feld[],int anzahl)
{
    if (anzahl==0)
        return true;
    return alleven(feld, anzahl-1) && feld[anzahl-1]%2==0;
}

Und dann vielleicht noch

bool isEven(int n)
{
    return n%2==0;
}
bool areAllEven(int feld[],int anzahl)
{
    if (anzahl==0)
        return true;
    return areAllEven(feld, anzahl-1) && isEven(feld[anzahl-1]);
}

Aber ich hätte keine Rekursion genommen, sondern eine Schleife. Die fällt dann auch zusammen, ungefähr zu sowas:

bool areAllEven(int feld[],int anzahl)
{
    for(int i=0;i<anzahl;++i)
       if(!isEven(feld[i])
           return false;
    return true;
}

SeppJ schrieb:

Das sieht korrekt aus, aber extrem umständlich. Wie wäre es mit einer kleinen Schleife? Dann wird das zu einem Dreizeiler.

Ist das ein Ein- oder ein Vierzeiler?

bool alleven(int feld[], int anzahl)
{
  return anzahl == 0 || feld[0] % 2 == 0 && alleven(feld + 1, anzahl - 1);
}

In meiner obigen Zählweise hätte ich das als Einzeiler bezeichnet, weil es ein einziger Ausdruck ist. Aber das ist ja auch wieder die rekursive Variante. Ich hätte (um etwas anfängerfreundlich zu sein als 314159265358979s Version) die letzte Version von volkard genommen:

bool areAllEven(int feld[],int anzahl)
{
    for(int i=0;i<anzahl;++i)
       if(!isEven(feld[i])
           return false;
    return true;
}

Habe mich aber wohl verzählt als ich im Kopf programmiert habe und auf drei Zeilen gekommen bin. Aber man könnte bestimmt irgendwie rechtfertigen, dass man das return false ind die gleiche Zeile wie das if schreibt :p .