Falls der Wert nicht im Array vorhanden ist, soll die Funktion -1 ausspucken. Das habe ich allerdings noch nicht implementiert.. Zur Zeit habe ich noch Probleme falls die Zahlen in dem Array sind.
Folgendes habe ich geschrieben und bin es auch schon im Kopf mit den Zahlen durchgegangen, jedoch funktioniert es leider nicht:

#include <iostream>
using namespace std;

int binaerSuche(int start, int end, int val, int array[])
{
   if (val==array[(int)((end/2)+0.5)])
      return (end/2)+0.5;
   else
      return (val<array[(int)((end/2)+0.5)]) ? binaerSuche(start, (end/2)-0.5, val, array :
      binaerSuche((end/2)+0.5, end, val, array);
}

int main()
{
   int array[] = {1,4,5,7,8,9,12,15,20,36,55,128,999}
   int value;

   cout << "Geben Sie den zu suchenden Wert ein: ";
   cin >> value;
   cout << "Der Wert steht im Array an der Stelle : "
        << binaerSuche(0, 12, value, array) << endl;

   Return 0;
}

Brauche Hilfe

... jedoch funktioniert es leider nicht ...

Was genau funktioniert nicht und wie lautet deine Frage?

Habe ein kleineres Problem.
Wir sollen für die Uni eine rekursive Funktion schrieben, die folgende Art den Platz des Arrays sucht in dem der eingegebene Wert steht:
Endwert/2 und schauen, ob die gesuchte Zahl kleiner oder größer als die Zahl im mittleren Array ist - wobei bei ungeraden Teilungen wie 13/2 links der kleinere Wert stehen soll (6,7).

Falls der Wert nicht im Array vorhanden ist, soll die Funktion -1 ausspucken. Das habe ich allerdings noch nicht implementiert.. Zur Zeit habe ich noch Probleme falls die Zahlen in dem Array sind.
Folgendes habe ich geschrieben und bin es auch schon im Kopf mit den Zahlen durchgegangen, jedoch funktioniert es leider nicht:

Hallo glasklar,

Willkommen im C++-Forum.

Nun zunächst compiliert es nicht. In Zeile 9 fehlt eine ')' vor dem :; in Zeile 15 fehlt das Semikolon am Ende und in Zeile 23 hast Du return mit einem großen 'R' geschrieben.
Beim Compilieren gibt es noch einige Warnungen, davon später mehr.

Jetzt gehe ich das Programm nochmal im Kopf durch. Angenommen die Eingabe ist 8. Dann ist der erste Aufruf von binaerSuche start/end= 0 12 array[start/end]= 1 999.
Der Ausdruck '(int)((end/2)+0.5)' liefert für end==12 den Wert 6. Wichtig end/2 liefert IMMER ein int, auch wenn int ungerade ist. Addiert man dann 0.5 verwandelt sich das ganze in ein double und mit dem cast auf int wieder in int zurück. Ist end>0, so ist das +0.5 völlig wirkungslos.

weiter im Programm: array[6] == 12 und 8 ist kleiner als 12; also landet man bei
binaerSuche(start, (end/2)-0.5, val, array )
end/2 liefert int(6); -0.5 liefert double(5.5) und der cast auf int (end ist wieder ein int) liefert 5. Hier warnt der Compiler, dass was nicht stimmt. end/2-1 hätte übrigens die selbe Wirkung.

Der Aufruf ist jetzt
binaerSuche start/end= 0 5 array[start/end]= 1 9
Der Ausdruck '(int)((end/2)+0.5)' liefert für end==5 den Wert 2. (wieso s.o.)
array[2] == 5 und 8 ist nicht kleiner als 5, also landen wir jetzt bei
binaerSuche((end/2)+0.5, end, val, array)

Der Aufruf ist jetzt
binaerSuche start/end= 2 5 array[start/end]= 5 9
end bleibt bei 5 und der Ausdruck '(int)((end/2)+0.5)' liefert für end==5 immer noch den Wert 2. Das willst Du aber gar nicht, Du willst doch einen Wert zwischen 2 und 5 haben - da 8 doch zwischen array[2]==5 und array[5]==9 liegt.

Der nächste Aufruf ist demnach wieder
binaerSuche start/end= 2 5 array[start/end]= 5 9

usw. bis der Stack Deines PCs überläuft und einen Laufzeitfehler liefert.

1.Tipp mache Dich mit der Integerarithmetik vertraut
2.Tipp definiere end genau - es bietet sich an, end als letzten Index+1 zu definieren, so dass das Duo start/end ein halboffenes Intervall bildet.

Gruß
Werner

Hmm das mit dem geteilt durch 2 habe ich mir wegen des Aufteilens gemäß der Aufgabenstellung ausgedacht:
12/2-0.5 = 5.5 also 5 -> 0...5
12/2+0.5 = 6.5 also 6 -> 6...12

5/2-0.5 = 2 -> 0...2
5/2+0.5 = 3 -> 3...5

usw..

-1 anstatt von 0.5 würde dementsprechend nicht das selbe machen. Sitz aber grad in der Uni ich schau mir deine Antwort nachher nochmal genauer an

Danke schon mal im Vorraus

glG Robert