Сортировка по убыванию элементов массива, расположенных до первого отрицательного элемента

#include <iostream>
#include <algorithm>
 
template <typename C>
void ShowElement(C const& elements) {
  for (const auto& element : elements) {
    std::cout << element << " ";
  }
  std::cout << '\n';
}
 
struct IsNegative {
  template <typename T>
  bool operator()(T const& value) {
    return value < 0;
  }
};
 
struct Greater {
  template <class T>
  bool operator()(T const& a, T const& b) const {
    return a > b;
  }
};
 
template <typename C>
void SortElementsInDescendingOrderBeforeFirstNegativeElement(C& elements) {
  auto first_negative =
      std::find_if(std::begin(elements), std::end(elements), IsNegative());
  std::sort(std::begin(elements), first_negative, Greater());
}
 
int main() {
  std::vector<int> elements = {4, 7, 3, 4, 5, -2, 1, 0, -1, 8, 9};
  std::cout << "Elements before sort:\n";
  ShowElement(elements);
  SortElementsInDescendingOrderBeforeFirstNegativeElement(elements);
  std::cout << "Elements after sort:\n";
  ShowElement(elements);
}

#include <iostream>
#include <algorithm>
#include <functional>
#include <vector> 
#include <iterator>
using namespace std;
template <typename C,typename VAL>
void ShowElement(const C elements) 
{
  ostream_iterator<VAL> out(cout," ");
  copy(elements.begin(),elements.end(),out);
  cout << endl;
}
 
template <typename C,typename T>
void SortElementsInDescendingOrderBeforeFirstNegativeElement(C& elements) 
{
    C::iterator first_negative =
    find_if(elements.begin(), elements.end(), bind2nd(less<T>(),0));
    sort(elements.begin(), first_negative, greater<T>());
}
 
int main() 
{
  vector<int> v;
  int elements[] = {4, 7, 3, 4, 5, -2, 1, 0, -1, 8, 9};
  for(int i=0;i<sizeof(elements)/sizeof(int);++i)
      v.push_back(elements[i]);
  cout << "Elements before sort:\n";
  ShowElement<vector<int>,int>(v);
  SortElementsInDescendingOrderBeforeFirstNegativeElement<vector<int>,int>(v);
  cout << "Elements after sort:\n";
  ShowElement<vector<int>,int>(v);
  system("pause");
  return 0;
}

#include <iostream>
#include <functional>
#include <algorithm>
using namespace std;
int main(){
    int e[46], index = -1,f=1;
    for (int i = 0; i < 46; i++){
        cin >> e[i];
        if (e[i] < 0 && f){
            index = i; f = 0;
        }
    }
    if (!f)sort(e, e + index,greater<int>());
    for (int i = 0; i < 46; i++)cout << e[i] << ' ';
    return 0;
}

#include"iostream"
using namespace std;
 
int main()
{
    const int SIZE = 5;
    int E[SIZE] = {1,2,-3,4,5};
 
    for(int i = 0; i < SIZE; ++i) {
        if(E[i] < 0) break;
 
        for(int j = 0; j < SIZE; ++j) {
            if(E[j] < 0) break;
            if(E[i] > E[j]) swap(E[i], E[j]);
        }
    }
 
    for(int i = 0; i < SIZE; ++i)
        cout << E[i] << " ";
 
        return 0;
}

#include <algorithm>
#include <functional>
#include <iostream>
#include <iterator>
#include <random>
 
int main()
{
    const size_t N = 46;
    int E[N];
    std::mt19937 gen { std::random_device()() };
    std::uniform_int_distribution<> dist(-5, 50);
    auto print = [](const int *arr, const size_t size)
    {
        std::copy(arr, arr + size, std::ostream_iterator<int>(std::cout, " "));
        std::cout << std::endl;
    };
 
    std::generate(E, E + N, [&gen, &dist] { return dist(gen); });
    std::cout << "Before:\n";
    print(E, N);
 
    auto it = std::find_if(E, E + N, [](const int x) { return x < 0; });
    std::sort(E, it, std::greater<int>());
    std::cout << "\nAfter:\n";
    print(E, N);
}

typename C::iterator first_negative =

template <typename C>
void ShowElement(const C elements)
{
  ostream_iterator<typename C::value_type> out(cout," ");

ShowElement(v);

auto first_negative = std::find_if(std::begin(elements), std::end(elements), IsNegative());

auto it = std::find_if(E, E + N, [](const int x) { return x < 0; });