if ((a<b) && (a<c) && (a>-1)) return a;

Den Rest überlasse ich dir.

Wenn einem dieser Ansatz zu übersichtlich ist, kann man auch noch versuchen die Anzahl der Vergleiche zu minimieren.

Hallo, ich möchte mir eine Fkt. schreiben, die 3 Integerwerte übergeben bekommt, und den kleinsten, der GROESSER -1 ist, zurückgibt.

Was soll Fkt(-2, -3, -4) ergeben?

if ((a<b) && (a<c) && (a>-1)) return a;

a=1
b=-1
c=-1

in dem fall hat a den kleinsten wert von den 3 ints, der größer -1 ist.
dennoch wird nichts zurückgegeben...

standardmäßig soll -1 returnt werden

unsigned

interpretieren und diese normal sortieren. Im Zweierkomplement (auf dessen Vorhandensein du dich dabei verlassen musst) ist jede negative Zahl (in etwa) das komplement der positiven, damit es eindeutig bleibt sind das die einzigen Zahlen, bei denen das höchste Bit gesetzt ist. Aber ganz im Ernst, bei drei Zahlen kannst du dir auch einfach die Arbeit machen und den Kram ausschreiben:

int babäm (int a, int b, int c)
{
   if (a < 0)
      if (b < 0)
          if (c < 0)
              return -1;
          else
              return c;
      else
          return std::min(b, c);
   else
       if (b < 0)
           if (c < 0)
               return a;
           else
               return std::min(a, c);
       else
           if (c < 0)
               return std::min(a, b);
           else
               return std::min(std::min(a, b), c);
}

Mit uminterpretieren:

int babäääm (int a, int b, int c)
{
    unsigned& a_ = *reinterpret_cast<unsigned*> (&a);
    unsigned& b_ = *reinterpret_cast<unsigned*> (&b);
    unsigned& c_ = *reinterpret_cast<unsigned*> (&c);
    unsigned res = std::min(std::min(a_, b_), c_);
    if (res > std::numeric_limits<int>::max())
        return -1;
    else
        return int(res);
}

if ((a>-1) && ((b>-1) && (a<b)) && ((c>-1) && (a<c))) return a;

Hoffentlich habe ich mich nicht verklammert.

Wenn ich so drüber nachdenke wäre es aber vermutlich einfacher alle Werte in einen Container sortieren und hinterher den kleinsten größer -1 zu nehmen. Das wären dann nämlich im schlimmsten Fall 3 Vergleiche zum sortieren, je nach Container eventuell noch bis zu drei Verschiebungen und danach schlimmstenfalls 3 Vergleiche mit -1 (im Falle, dass alle <-1 sind). Das sind im Schnitt vermutlich deutlich weniger Operationen als mein erster Vorschlag, der, wenn ich ihn mir jetzt angucke, vielleicht doch nicht so sauber aussieht.

int _1;
	int _2;
	int _3;
	// ...
	int min = max(max(max(-1,i),max(-1,j)),max(-1,k));
	if(min!=-1)
	{
	}

#include <algorithm>

using namespace std;

int fkt(int a, int b, int c)
{
    return max(min(a, b), c), -1);
}

a = 1;
b = -2;
c = 5;

liefert -1 obwohl das Ergebis 1 sein sollte oder?

int fkt(int a, int b, int c)
{
	return max(max(max(-1,a),max(-1,b)),max(-1,c));
}

funktioniert das immer.

Die Variablennamen waren eben falsch, ansonsten

int fkt(int a, int b, int c)
{
	return max(max(max(-1,a),max(-1,b)),max(-1,c));
}

funktioniert das immer.

Echt? Das sieht für mich aus als würde er einfach den größten Wert zurück liefern .

int temp[3]={a,b,c};
std::sort(temp, temp+3);
return * std::find_if(temp, temp+3, std::bind2nd(std::greater<int>(),-1))

Ungetestet auf Syntaxfehler, aber um mal zu zeigen was ich oben meinte.

Pro: Einfach erweiterbar auf N-Zahlen, leicht wartbar, leicht zu verstehen
Contra: Overhead. Die Funktion wird immer noch sehr schnell sein, aber falls sie in einer zeitkritischen Schleife steht ist noch deutliche Optimierung möglich, indem man ausnutzt, dass es nur 3 Zahlen sind. sort und find sind nämlich ziemlicher Overkill um sie auf 3 Elemente anzuwenden. Eine sehr gute Implementierung von sort und ein optimierender Compiler mit Schleifenaufdröselung werden aber ein Ergebnis erzeugen, welches gleichwertig zu handgeschriebenem, optimierten Code ist. Es sollte daher also kein großer Nachteil sein. Eventuell ein eigenes, spezialisiertes sort für 3 Elemente schreiben.

edit: Ups, die Bedingung für find_if war genau falsch rum. Korrigiert.

Sorry, hab die Aufgabenstellung nur halb gelesen...

Brauchst dich ja net zu entschuldigen . Der Thread-Ersteller ist anscheinend mit den bekommenen Antworten zufrieden.

Und solange er net Software entwickelt die womöglich meine Gesundheit beeinträchtigt, soll es mir auch recht sein.

#include <algorithm>
#include <limits>
using namespace std;

template<typename T>
T getsmallestmax(T a, T b, T c, T m)
{
	const T tmax = T(std::numeric_limits<T>::max);
	a=max(a,m)==m?tmax:a;
	b=max(b,m)==m?tmax:b;
	c=max(c,m)==m?tmax:c;
	return (a==b && a==c)?m:min(min(a,b),c);
}

void f()
{
    getsmallestmax(1,2,3,-1);
}

#include <algorithm>
#include <limits>

int minmax(int x_p, int y_p, int z_p) {
  unsigned x = x_p,
           y = y_p,
           z = z_p;
  unsigned r = std::min(x, std::min(y, z));
  unsigned int_max = std::numeric_limits<int>::max();

  return r <= int_max ? static_cast<int>(r) : -1;
}

Auf allen gängigen Rechnern ginge auch

int minmax(unsigned x, unsigned y, unsigned z) {
  return std::max(-1, static_cast<int>(std::min(x, std::min(y, z)));
}

...aber streng genommen ist die Umwandlung von unsigned nach int außerhalb des von int darstellbaren Wertebereichs implementation-defined, und man sollte sich nicht ohne Not undefiniertes Verhalten einfangen.

Der Vorteil des Ansatzes liegt darin, dass die Umwandlung von int nach unsigned in Zweierkomplementdarstellung rein konzeptuell ist und der größte Teil der Logik so auf allen gängigen Architekturen vom Compiler wegoptimiert werden kann.

int babäm (int a, int b, int c)
{
   if (a < 0)
      if (b < 0)
          if (c < 0)
              return -1;
          else
              return c;
      else
          return std::min(b, c);
   else
       if (b < 0)
           if (c < 0)
               return a;
           else
               return std::min(a, c);
       else
           if (c < 0)
               return std::min(a, b);
           else
               return std::min(std::min(a, b), c);
}

´

Ich hab es jetzt mal so wie .filmor gemacht...
sein code ist zwar nicht 100% korrekt aber es funzt, auch wenn es ganz und gar nicht schön aussieht...

assert(greatestmax(1, 1, 1, -1) == 1);

@seldon:
Das hab ich vorher schonmal geschrieben und zwar so, dass der Compiler nicht über Vorzeichenverlust warnt

@threadstarter:

int babäm (int a, int b, int c)
{
   if (a < 0)
      if (b < 0)
          if (c < 0)
              return -1;
          else
              return c;
      else
          if (c < 0)
              return b;
          else
              return std::min(b, c);
   else
       if (b < 0)
           if (c < 0)
               return a;
           else
               return std::min(a, c);
       else
           if (c < 0)
               return std::min(a, b);
           else
               return std::min(std::min(a, b), c);
}

sollte korrekt sein. Du kannst das ganze auch rekursiv mit variadic templates machen

return (a==m && a==b && a==c)?m:min(min(a,b),c);

stehen. Der Nachteil ist auch, dass numeric_limits<T>::max für alle Werte ebenfalls min liefert. Der Vorteil allerdings ist, dass der Min-Wert frei wählbar ist.

getsmallestmax(4.4f,4.3f,4.5f,4.35f);

Auf allen gängigen Rechnern ginge auch

int minmax(unsigned x, unsigned y, unsigned z) {
  return std::max(-1, static_cast<int>(std::min(x, std::min(y, z)));
}

...aber streng genommen ist die Umwandlung von unsigned nach int außerhalb des von int darstellbaren Wertebereichs implementation-defined, und man sollte sich nicht ohne Not undefiniertes Verhalten einfangen.

1. Was bringt das, das nicht zu definieren?
2. Ginge es so?

int minmax(unsigned x, unsigned y, unsigned z)
{
  return std::max(-1, (*((int *)(&(std::min(x, std::min(y, z))))));
}

Zu 2.: Mit Pointergecaste bist du da keinesfalls besser dran. Das Ergebnis von

int x = 2;
unsigned y = *((unsigned*)&x);

dürfte nicht definiert sein; der Standard schreibt nicht vor, dass int und unsigned gleichen Wertes das gleiche Bitmuster haben müssen. Außerdem versuchst du so, std::max(int, unsigned) aufzurufen, welches nicht existiert.