Ich bin jetzt seit einer Woche C++ am programmieren und mir selber Aufgaben gemacht und zum Teil aus Büchern und Internet.
Mein Programm die ihr hier unten sieht ist eigentlich nichts besonderes.
ich habe eine untere und eine obere Grenze (Zahlen bereich) wenn die Zahl die man eingibt im oberen oder unteren zahlenbereich ist dann geht es weiter und dann wird noch überprüft ob die Zahl gerade oder ungerade ist. mehr nicht. wie ihr sieht etwas ganz simples abr nicht einfach für einer der erst seit 1 woche programmiert.

zu meiner Frage:

Ich möchte eine Funktion implementieren, die sowohl den negativen als auch den positiven bereich überprüfen kann.

Habe mir vorgenommen das man maximal ein mal "if - else" verwendet kann.
if (...)
{ ...
}
else
{ ...
}

prototyp:
bool isInRange(int zahl, int untereGrenze, int obereGrenze);

ist das überhaupt möglich? bin schon seit einer Zeit am hirnen und im Internet am schauen (bücher sollten kommen habe ich bestellt) aber komme nicht drauf.
Ich sehe es schon vor mir muss sicher nur eine kleine Änderung machen aber schaffe es nicht.

kann mir jemand dabei helfen?

#include <iostream>
#include <cmath>

#define ERR_UNGERADE "Die Zahl ist ungerade"
#define ERR_GRENZE  "Die Zahl ist ausserhalb der Grenze"

#define OBEREGRENZE (100)
#define UNTEREGRENZE (50)

#define TEST 1

#define DEBUG 1
using namespace std;

//Funktionprototypen
//bool insideRange (int zahl,int unten, int oben);
bool isInRange(int zahl, int untereGrenze, int obereGrenze);
bool isEven (int zahl);

int main()
{	//Check bounds.
	if(UNTEREGRENZE>OBEREGRENZE)
	{
		cout<< "Falsche Konfiguration"<< endl;
		return EXIT_FAILURE;
	}
#if TEST==1
	//cout << "Testfunktion: "<<boolalpha <<  insideRange(50, 0, 100)  << endl;
	//cout << "Testfunktion: "<<boolalpha <<  insideRange(5, 90, 100)  << endl;
	cout << "Testfunktion: "<<boolalpha << isEven(80)<< endl;
	cout << "Testfunktion: "<<boolalpha << isEven(85)<< endl;

#endif

	int zahl = 1;
#if DEBUG == 1
	cout << "zahl: "<< zahl << endl;
#endif

	//Zahl eingeben
	cout << "bitte eingeben: " << endl;
	cin >> zahl; // zahl von der konsole einlesen mittels std::cin
	cout << "zahl: "<< zahl << endl;

	// Zahl darf nicht groesser sein als +/- GRENZE
	// Zahl>= -100 und  Zahl<= 100
	// Vergleiche die Zahl mit der Oberegrenze
	// Ausgabe
	// Vergleich mit der Unteregrenze
	// Ausgabe
	// Fehlermeldung

	int error = 0;
	//if ((zahl>= -OBEREGRENZE && zahl <= -UNTEREGRENZE) || (zahl>= UNTEREGRENZE && zahl<= OBEREGRENZE))
	//Überprüfung war erfolgreich wir befinden uns entweder im Oberer oder Unterer Bereich
		if (isInRange(zahl, UNTEREGRENZE, OBEREGRENZE) || isInRange(zahl, -OBEREGRENZE, -UNTEREGRENZE))
		{
			cout << "Oberegrenze: "  << endl;

			cout << "Unteregrenze: "  << endl;

		}
		else
		{   // error==0
			error+=1; //error=error+1; Fall 2: Zahl ausserhalb der Grenze
		}

		// erfolgreich=keine Fehler=true
		if (!error)
		{
			if(isEven(zahl))
			{
				cout << "Zahl ist gerade" << endl;
			}
			else
			{
				error+=1; //Fall 1: Zahl ist ungerade
			}
		}
		switch (error)
		{
		case 0:
			//cout << "Zahl ist gerade" << endl;
			break;
		case 1:
			cout << "Ist ein Fehler aufgetreten" << endl;
			// Fall 1; Fall 2
			break;
		default:
			break;
		}

		return (error>0 ? EXIT_FAILURE : EXIT_SUCCESS);
}

//Funktionsimplementation
/*bool insideRange (int zahl,int unten, int oben)
{
	if (zahl>= unten && zahl<= oben)
	{
		return true;
	}
	else
	{
		return false;
	}
}
*/
bool isInRange(int zahl,int untereGrenze,int obereGrenze)
{
	if (zahl>=untereGrenze && zahl<=obereGrenze ||zahl<=-untereGrenze && zahl>=-obereGrenze)
	{
		return true;
	}
	else
	{
		return false;
	}
}
bool isEven(int zahl)
{	// Resultat invertieren
	if (!(zahl%2))
	{
		return true;
	}
	else
	{
		return false;
	}

}

if ( Bedingung )
 return true;
else
 return false;

Ist ersetzbar mit:

return ( Bedingung )

Die Bedinung ist schlussentlich auch ein boolscher Ausdruck.

...

Ich möchte noch

• Verwende aussagekräftige Titel für deine Threads

hinzufügen.

bool

int

prototyp:
bool isInRange(int zahl, int untereGrenze, int obereGrenze);

inline bool isInRange(int zahl, int untereGrenze, int obereGrenze)
{
  const unsigned u = untereGrenze;
  return (zahl-u) <= (obereGrenze-u);
}

So?

Gruß,
SP

whaaatz schrieb:

prototyp:
bool isInRange(int zahl, int untereGrenze, int obereGrenze);

inline bool isInRange(int zahl, int untereGrenze, int obereGrenze)
{
  const unsigned u = untereGrenze;
  return (zahl-u) <= (obereGrenze-u);
}

So?

Gruß,
SP

Mein Mathe-Verständnis sagt dazu
zahl-u <= oberGrenze-u | auf beiden Seiten +u
zahl <= obergrenze
Das verwirtrt mich.

Mein Mathe-Verständnis sagt dazu

zahl-u  <=  oberGrenze-u  | auf beiden Seiten +u
<=>   zahl    <=  obergrenze

Das verwirtrt mich.

Es ist wegen der Modulo-Arithmetik nicht ganz korrekt. u ist ein unsigned int. => zahl-u und obereGrenze-u sind auch unsigned ints (nie negativ) => Die Äquivalenz (<=>) ist an der Stelle falsch. Es muss heißen

untergrenze <= zahl   <= obergrenze     | überall u abziehen
      ~~~~~~~~~~~    ~~~~      ~~~~~~~~~~
          int        int           int

<=>             0 <= zahl-u <= obergrenze-u
                     ~~~~~~    ~~~~~~~~~~~~
                    unsigned     unsigned

...und da 0<=zahl-u immer gilt (ist ja unsigned), kann man sich diesen Test sparen.

Gruß,
SP