Kann man die Funktion noch Optimieren?

template<typename T>
class Field
{
//...
		T get_at( int x, int y ) const
		{
			if( ( x < 0 ) || ( x >= m_m ) )
			{
				throw std::range_error( "out of bounds" );
			}
			if( ( y < 0 ) || ( y >= m_n ) )
                        {
				throw std::range_error( "out of bounds" );
			}
			return m_values[ x * m_n + y ];
		}

Ich hab es buchstabentechnisc optimiert, auf das seid ihr doch immer so geil!
Ist aber wahrscheinlich so eher langsamer / gleich schnell.

T const& get_at( std::size_t x, std::size_t y ) const
{
  std::size_t const index = x * m_n + y;
  if (index > last_index_) {
    throw std::range_error("out of bounds");
  }
  return m_values[index];
}

Achja? Aber wenns nach dir geht darf man in einem 1000x1 Feld auf das Element [0][999] und [999][0] und sogar [1000][0] und [0][1000] zugreifen.

T const& get_at( std::size_t x, std::size_t y ) const
{
  std::size_t const index = x * m_n + y;
  if (index > last_index_) {
    throw std::range_error("out of bounds");
  }
  return m_values[index];
}

eigentlich falsch. überläufe nicht bedacht.
aber der unsigned-trick ist fein.

T get_at( unsigned x, unsigned y ) const 
        { 
            if( ( x < m_m ) && ( y < m_n ) && y & x) 
            { 
                return m_values[ x * m_n + y ]; 
            } 
            throw std::range_error( "out of bounds" ); 
        }

Das & x&y muss natuerlich weg, weis net was ich dabei gedacht hab. Wollte irgendwie die 0 weg haben.

T get_at( unsigned x, unsigned y ) const 
        { 
            if( ( x < m_m ) && ( y < m_n ) && y & x) 
            { 
                return m_values[ x * m_n + y ]; 
            } 
            throw std::range_error( "out of bounds" ); 
        }

Ich hab es buchstabentechnisc optimiert, auf das seid ihr doch immer so geil!
Ist aber wahrscheinlich so eher langsamer / gleich schnell.

warum das "&& y & x" ?
ohne dem isses richtiger und schneller.

eigentlich falsch. überläufe nicht bedacht.
aber der unsigned-trick ist fein.

Verrat mir den Trick, bitte

volkard schrieb:

eigentlich falsch. überläufe nicht bedacht.
aber der unsigned-trick ist fein.

Verrat mir den Trick, bitte

unsigned Werte sind nie negativ

ps: volkhard du bist einfach zu langsam!

T get_at( unsigned x, unsigned y ) const 
        { 
            if( ( x < m_m ) && ( y < m_n ) && y & x) 
            { 
                return m_values[ x * m_n + y ]; 
            } 
            throw std::range_error( "out of bounds" ); 
        }

Ich hab es buchstabentechnisc optimiert, auf das seid ihr doch immer so geil!
Ist aber wahrscheinlich so eher langsamer / gleich schnell.

Wenn jemand hier für x und y 0 eingibt kommt bei x & y auch 0 raus, wodurch dann die exception getriggert wird.

Edit: zu langsam getipped

Ich würd es zu folgendem ändern:

const T& get_at( size_t x, size_t y ) const
        {
            if( ( x >= m_m ) || y >= m_n )
              throw std::range_error( "out of bounds" );

            return m_values[ x * m_n + y ];
        }

Nen signed Typ für die Indizes zu nehmen ist ein Fehler, wenn negative Werte keine gültigen Werte sind. Eine const-Referenz zurückzugeben ist sicher auch nicht verkehrt, aber bei kleinen Typen wäre es ja egal.

Nen signed Typ für die Indizes zu nehmen ist ein Fehler, wenn negative Werte keine gültigen Werte sind. Eine const-Referenz zurückzugeben ist sicher auch nicht verkehrt, aber bei kleinen Typen wäre es ja egal.

Was heisst klein? Es sind Zeiger:

private:
		T* m_values;
		unsigned m_m;
		unsigned m_n;

bool operator==( const Creature& lhs, const Creature& rhs )
{
	return typeid( lhs ) == typeid( rhs ) ? true : false;
}

Zwei Kreaturen sollen auf gleiche Art verglichen werden.
Arten sind Subklassen von Creature,

Und was wäre hier zu machen?

bool operator==( const Creature& lhs, const Creature& rhs )
{
	return typeid( lhs ) == typeid( rhs ) ? true : false;
}

Zwei Kreaturen sollen auf gleiche Art verglichen werden.
Arten sind Subklassen von Creature,

Wenn die "optimierte" Version 100% dasselbe verhalten haben soll kann man hier garnix machen, ausser den sinnlosen "?" Operator wegmachen (was bei einem guten Compiler aber genau 0 Auswirkungen auf die Laufzeit haben wird).

Double dispatch (wurde erwähnt) wäre eine Möglichkeit wenn man in alle Subklassen eingreifen kann und möchte.

Wäre es ev. schneller, den Creature Subtypen eine static ID mitzugeben, die dann verglichen wird?

Wäre es ev. schneller, den Creature Subtypen eine static ID mitzugeben, die dann verglichen wird?

Mit dem MSVC wäre das garantiert um einiges (!) schneller.
(Andere compiler weiss ich nicht, müsstest du ausprobieren)