std::pair<unsigned int, int> sortieren lassen

[uuuff]

Ja ich habe natürlich ein array aus pairs, welches ich nach dem zweiten pair-eintrag sortieren will ja sorry.

[LordJaxom]

Dann sieht die Sache ja schon anders aus

Dann müsste es so gehen:

std::sort(mypair, mypair+dim, Cache_Comparator()

Die Fehlermeldung sieht aber so aus als hättest Du folgendes versucht:

mypair->sort(...);

Im Cache_Comparator musst Du aber eine <-Beziehung herstellen, Du hast zur Zeit eine <=-Beziehung. Dafür sollte folgendes reichen:

return a.second < b.second;

[uuuff]

Danke aber mit dem folgendem code:

std::sort(mypair, mypair + dim, Cache_Comparator());

struct Cache_Comparator
{
	template <class T>
			bool operator()(const std::pair<unsigned int, int> & a, const std::pair<unsigned int, int> & b)
	{	
		return a.second < b.second;
	}
};

gibts ne riesiege fehlermeldung:

/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/stl_algo.h: In function »void std::partial_sort(_RandomAccessIterator, _RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = std::pair<unsigned int, int>*, _Compare = Cache_Comparator]«:
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/stl_algo.h:2666:   instantiated from »void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = std::pair<unsigned int, int>*, _Size = int, _Compare = Cache_Comparator]«
/usr/lib/gcc/i486-linux-gnu/4.1.2/../../../../include/c++/4.1.2/bits/stl_algo.h:2749:   instantiated from »void std::sort(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = std::pair<unsigned int, int>*, _Compare = Cache_Comparator]«

und das geht noch ewig so weiter bis er zu meinem std::sort aufruf kommt

[camper]

Du hast ein Membertemplate, dessen Templateparameter (wozu dient der überhaupt?) nicht aus den Funktionsargumenten hergeleitet werden kann - mithin muss dieser Parameter explizit angegeben werden.

[crashterpiece]

falscher operator

bool operator<(const std::pair<unsigned int, int> & a, const std::pair<unsigned int, int> & b) ...

doofes syntaxhiglighting

[uuuff]

da wird ja der hund in der pfanne verrückt - bin ich blind? Der folgende code produziert immer noch den fehler

struct Cache_Comparator
{
	bool operator<(const std::pair<unsigned int, int> & a, const std::pair<unsigned int, int> & b)
	{	
		return a.second < b.second;
	}
};

[uuuff]

bool Cache_Comparator::operator<(const std::pair<unsigned int, int>&, const std::pair<unsigned int, int>&)« muss genau ein Argument nehmen

das ist der fehler jetzt....ja klar ein argument.....nur wie mach ich jetzt den vergleich?

[LordJaxom]

[quote="crashterpiece"]falscher operator ;)[quote]
Nein.

bool operator<(const std::pair<unsigned int, int> & a, const std::pair<unsigned int, int> & b) ...

Funktoren zeichnen sich i.A. dadurch aus, dass sie mit () aufgerufen werden...

@uuuff:
Abgesehen von dem Templateparameter war der operator() mit return a.second < b.second schon richtig.

Wenn Du in dem Cache_Comparator einen operator< (mit einem Argument) implementierst, kannst Du zwei Cache_Comparator'en vergleichen, aber das ist wohl nicht gewünscht

[uuuff]

Jap, mit () gehts einwandfrei - danke an alle

[*D*Evil]

namespace util
{
    template<typename first, typename second>
    struct pair_second_greater
    {
        bool operator()(std::pair<first, second> const& lhs, std::pair<first, second> const& rhs)
        {    return (lhs.second < rhs.second); }
    };

    template<typename first, typename second>
    struct pair_first_greater
    {
        bool operator()(std::pair<first, second> const& lhs, std::pair<first, second> const& rhs)
    {    return (lhs.first < rhs.first); }
};

std::vector< std::pair<unsigned int, int> > g_data;
// ...
std::sort(g_data.begin(), g_data.end(), util::pair_second_greater<unsigned int, int>());
// oder 
std::sort(g_data.begin(), g_data.end(), util::pair_first_greater<unsigned int, int>());

... ^^

[uuuff]

hui danke