la confusione su come utilizzare std :: meno e std :: maggiore con std :: sort

Question

In C, sorta di solito implementa come nel seguente esempio:

#include <stdio.h> 

void Sort(int* arr, int n, bool(*cmp)(int,int)) 
{ 
    for(int i=0; i<n-1; i++) 
    { 
     for(int j=i+1; j<n; j++) 
     { 
      if(cmp(arr[i], arr[j])) 
       swap(arr[i], arr[j]); 
     } 
    } 
} 

int ascending(int a, int b) { return a > b; } // greater 
int descending(int a, int b) { return a < b; } // less 

void main() 
{ 
    int arr[10] = { 1,3,5,7,9,2,4,6,8,10 }; 

    // ascending 
    Sort(arr, 10, ascending); 
    for(int i=0; i<10; i++) 
     printf("%d ", arr[i]); 

    printf("\n"); 


    // descending 
    Sort(arr, 10, descending); 
    for(int i=0; i<10; i++) 
     printf("%d ", arr[i]); 

    printf("\n"); 
} 

Così ho scritto qualche fonte come nel seguente esempio, aspettandosi stesso risultato:

#include <iostream> 
#include <algorithm> // for sort 
#include <functional> // for less & greater 
using namespace std; 

bool gt(int a, int b) { return a > b; } // greater 
bool ls(int a, int b) { return a < b; } // less 

void main() 
{ 
    int x[10] = { 1,3,5,7,9,2,4,6,8,10 }; 

    // ascending but descending 
    sort(x, x+10, gt); 
    for(int i=0; i<10; i++) 
     cout << x[i] << " "; 

    cout << endl; 

    // descending but ascending 
    sort(x, x+10, ls); 
    for(int i=0; i<10; i++) 
     cout << x[i] << " "; 

    cout << endl; 


    greater<int> g; // a > b 
    less<int> l; // a < b 

    // ascending but descending 
    sort(x, x+10, g); 
    for(int i=0; i<10; i++) 
     cout << x[i] << " "; 

    cout << endl; 

    // descending but ascending 
    sort(x, x+10, l); 
    for(int i=0; i<10; i++) 
     cout << x[i] << " "; 

    cout << endl; 
} 

Ma la mia aspettativa non era corretta.

perché non ordinare al lavoro STL come quelli in C?

Answer 1

std::sort si comporta in questo modo perché si basa sull'idea di un strict weak ordering, che è (solitamente) definito in termini di operatore <.

Quanto alla tua domanda; attualmente sembra essere "Ho scritto una funzione C che si comporta in modo diverso a std::sort. Perché è diverso?". La risposta è: perché hai scritto una funzione diversa!

Answer 2

std::sort ordina in ordine crescente per impostazione predefinita. Nel caso in cui siete alla ricerca di ordine decrescente, ecco il trucco:

int x[10] = { 1,3,5,7,9,2,4,6,8,10 }; 
std::vector<int> vec(x, x+10);   // construct std::vector object 
std::sort(vec.rbegin(),vec.rend());  // sort it in reverse manner 

In questo modo, si dice esplicitamente che std::sort dovrebbe trattare il vostro array come la sua fine è il suo inizio e viceversa, che si traduce nella propria matrice da ordinare in ordine decrescente. Here's the full example.

---

E nel caso in cui si desidera utilizzare std::less e std::greater, allora potrebbe assomigliare a questo:

int x[10] = { 1,3,5,7,9,2,4,6,8,10 }; 
std::sort(x, x + 10, std::less<int>());  // for ascending order 
std::sort(x, x + 10, std::greater<int>()); // for descending order 

esempio completo con seconda soluzione è here.