nach einem Refactoring braucht der Sortieralgorithmus auf einmal
dreimal so lange wie vorher.

Der Aufruf ist vorher gewesen:

std::list< std::vector< double > > list = ...;
list->sort( SortList() );

Nach dem Refactoring gibt es eine eigene Container-Klasse:

std::list< Container > list = ...;
list->sort( SortList() );

Liegt das an der Sortierklasse?

Vorher:

enum MatrixCol
{
	FROM = 0, 
	TO = 1,
	COUNT = 2,
	RANGE = 3,
	MEAN = 4,
	COUNT_FULL = 5
};

class SortList
{
public:
	bool operator()( const std::vector<double> & x, const std::vector<double> & y )
	{
		if( x[MatrixCol::RANGE] == y[MatrixCol::RANGE] )
		{
			if( x[MatrixCol::MEAN] == y[MatrixCol::MEAN] )
			{
				if( x[MatrixCol::FROM] == y[MatrixCol::FROM] )
				{
					return x[MatrixCol::TO] < y[MatrixCol::TO];
				}
				return x[MatrixCol::FROM] < y[MatrixCol::FROM];
			}
			return x[MatrixCol::MEAN] > y[MatrixCol::MEAN];
		}
		return x[MatrixCol::RANGE] > y[MatrixCol::RANGE];
	}
};

Nachher:

class Container
{
public:
	int m_from, m_to, m_count;
	double m_range, m_mean;
};

class SortList
{
public:
	bool operator()( const Container & x, const Container & y )
	{
		if( x.m_range == y.m_range )
		{
			if( x.m_mean == y.m_mean )
			{
				if( x.m_from == y.m_from )
				{
					return x.m_to < y.m_to;
				}
				return x.m_from < y.m_from;
			}
			return x.m_mean < y.m_mean;
		}
		return x.m_range > y.m_range;
	}
};

Wie würde man das besser machen? Der Nachteil an der alten Variante ist,
dass from, to und count eben keine doubles, sondern integers sind.

Danke für Antworten!

Es lag nicht an der Sortierklasse, sondern an verkehrter Parameterübergabe an anderer Stelle im Programm.

So weit so gut!