Отсортировать массив по убыванию и найти в нем элемент, равный X

#include <iostream>
#include <cstdlib>
void b_heapify(int* arr, size_t N, size_t i, 
               bool (*pcmp)(int, int));
void psort(int* arr, size_t N, bool (*pcmp)(int, int));
bool bfind(const int* f, const int* l, int x, 
           bool (*pcmp)(int, int));
 
bool compare(int a, int b){ return (a > b); }
 
 
 
int main(void){
    const size_t N = 20;
    int A[N];
 
    for(size_t i = 0; i < N; ++i){
        A[i] = std::rand() % 10;
        std::cout << A[i] << ' ';
    }
    std::cout << std::endl;
 
    //сортируем
    psort(A, N, compare);
 
    //вывести отсортированный массив
    for(size_t j = 0; j < N; ++j){
        // для теста
        if(bfind(A, A + N, A[j], compare))
            std::cout << A[j] << ' ';
    }
    std::cout << std::endl;
 
    // найти число X
    int X = 7;
/*  
    std::cout << "Enter X: ";
    std::cin  >> X;
    std::cin.sync();
*/
    if(bfind(A, A + N, X, compare))
        std::cout << "Yes find." << std::endl;
    else
        std::cerr << "not found X!" << std::endl;
    return 0;
}
 
 
/* двоичный поиск ищет значение в упорядоченном 
   массиве, значение x */
bool bfind(const int* f, const int* l, int x, 
           bool (*pcmp)(int, int)){
    size_t i, j, m;
    if((*pcmp)(x, *f) || (*pcmp)(*(l - 1), x))
        return false;
 
    i = 0;
    j = (size_t)(l - f);
    while(i < j){
        m = (i + j) >> 1;
        if((*pcmp)(x, f[m]))
            j = m;
        else {
            if(x == f[m])
                return true;
            i = m + 1;
        }
    }
    return false;
}
 
//---------------------------------------------
 
//восстановление свойства бинарной кучи
void b_heapify(int* arr, size_t N, size_t i, 
               bool (*pcmp)(int, int)) {
    size_t li, ri, big;
 
    while(1){
        li = (i << 1) + 1;
        ri = (i << 1) + 2;
        if((li < N) && (*pcmp)(arr[i], arr[li]))
            big = li;
        else
            big = i;
 
        if((ri < N) && (*pcmp)(arr[big], arr[ri]))
            big = ri;
 
        if(big != i){
            std::swap(arr[big], arr[i]);
            i = big;
        } else
            break;
    }
}
 
// пирамидальная сортировка
void psort(int* arr, size_t N, bool (*pcmp)(int, int)){
    //собрать кучу
    for(size_t i = N >> 1; i > 0; --i) 
        b_heapify(arr, N, i, pcmp);
    b_heapify(arr, N, 0, pcmp);
 
    for(size_t j = 0; j < N; ++j){
        std::swap(arr[0], arr[N - 1 - j]);
        b_heapify(arr, N - 1 - j, 0, pcmp);
    }
}