Sowas hier geht nicht:

if( a = inf ) { blablabla }

INFINITY
und
NAN

bb

if( a = inf ) { blablabla }

Das ist ja auch eine Zuweisung...

Ehrlich gesagt: Ich habe keine Ahnung...

Ich spar mir jetzt mal den 'let me google that for you'-Link

Es gibt wohl in

#include<limits>
if(std::isinf(myValue)){}

Gruß,
CSpille

edit: @unskilled: Man kann aber mit NAN nicht auf Gleichheit prüfen. Und bei INFINITY bin ich mir da auch nicht so sicher, müsste man mal nachlesen.

static const bool has_infinity = false;
  static const bool has_quiet_NaN = false;
  static const bool has_signaling_NaN = false;
/*...*/
  static T infinity() throw();
  static T quiet_NaN() throw();
  static T signalign_NaN() throw();

ich hab zwar keinen plan, was der unterschied zwischen quiet_nan und signaling_nan ist, aber ok... ^^

bb

zur not gibts aber in numeric_limits auch wirklich was für C++:

static const bool has_infinity = false;
  static const bool has_quiet_NaN = false;
  static const bool has_signaling_NaN = false;
/*...*/
  static T infinity() throw();
  static T quiet_NaN() throw();
  static T signalign_NaN() throw();

ich hab zwar keinen plan, was der unterschied zwischen quiet_nan und signaling_nan ist, aber ok... ^^

bb

Aber was nützt das? Damit kann man doch nur feststellen was der Typ so kann, aber man kann nicht prüfen ob eine variable von diesem Typ diesen Wert hat. Denn nan != nan.

Der Unterschied zwischen quiet_NaN und signaling_NaN ist, ist dass ein signaling_NaN eine Exception wirft wenn man bestimmte Sachen damit macht, während ein quiet_nan einfach durchgereicht wird. Ich wüsste aber keinen Fall, wo signaling_nans tatsächlich vorkommen würden, auch wenn die Idee ganz nett ist.

template<typename T>
bool is_infinity(const T& to_proof, bool only_positive = false)
{
  if(!std::numeric_limits<T>::has_infinity())
    return false;

  if(to_proof == std::numeric_limits<T>::infinity())
    return true;

  if(only_positive)
    return false;

  return to_proof == -std::numeric_limits<T>::infinity();
}

bb

edit: wenn es nur einen NaN-Zustand gäbe, könnte man ja mit memcmp was anstellen - das ist das ja aber nicht der Fall..
allerdings kann man das ==-op verhalten ja auch ausnutzen:

template<typename T>
bool is_nan(const T& test_me)
{
  if(!std::numeric_limits<T>::has_quiet_NaN())
    return false;

  return test_me != test_me;
}