using namespace std;
#include<iostream>
#include<cmath>
#include<iomanip>
void sortof(int[], int[]);
int main()
{ int st, sr,n;
int storearray[4], sortarray[4];
int a, b , c, d;
cout<<"Enter four numbers: ";
sortof(storearray, sortarray);
for(n=0; n<4; n++)
{
cin>>st;
storearray[n]=st;
}

cout<<fixed<<setw(6)<<"\nUnsorted numbers"<<setw(25)<<"Sorted numbers"<<endl;

for(n=0; n<4; n++)
{
cout<<setw(6)<<storearray[n];
};
if (a==sr)cout<<"The greater number"<<endl;

system ("pause");
return 0;
}

void sortof(int st[], int sr[])
{ int n;
int store, store_ind;
int sort, sort_ind;
store=st[0];
store_ind=0;
for(n=0; n<4; n++)
{ if (store<st[n])
sr[n]=st[n];
};
}

#include <iostream>

#include <cstdlib>
#include <cstring>

using namespace std;

#ifdef __cplusplus
extern "C" {
#endif

int integer_compare(const void* first, const void* second)
{
    if(first && second)
    {
        const int* pfirst  = (const int*)first;
        const int* psecond = (const int*)second;

        return (*pfirst - *psecond);
    }
    else
    {
        return 0;
    }
}

void sortof(const int* src, const size_t src_len, int* dest, const size_t dest_len)
{
    if(src && dest)
    {
        if(src_len == dest_len)
        {
            memcpy(dest, src, (dest_len * sizeof(int)));
            qsort(dest, dest_len, sizeof(int), integer_compare);
        }
    }
}

#ifdef __cplusplus
}
#endif

typedef void (*INT_ARRAY_SORT)(const int*, const size_t, int *, size_t);

int main()
{
    int unsorted[4] = {0};
    for(size_t i = 0; i < sizeof(unsorted)/sizeof(int); i++)
    {
        cout << "Enter an integer number: ";
        int tmp;
        cin >> tmp;
        if(!cin.fail() && cin.good())
        {
            unsorted[i] = tmp;
        }
        else
        {
            cout << "\nUser failure to follow simple instructions\nresult in computer dismay.\nExiting...\n";
            exit(cin.fail());
        }
    }
    int sorted[4];
    INT_ARRAY_SORT IntegerArraySort = &sortof;
    IntegerArraySort(unsorted, sizeof(unsorted)/sizeof(int), sorted, sizeof(sorted)/sizeof(int));

    for(size_t i = 0; i < sizeof(unsorted)/sizeof(int); i++)
    {
        cout << unsorted[i] << " ";
    }
    cout << endl;
    for(size_t i = 0; i < sizeof(sorted)/sizeof(int); i++)
    {
        cout << sorted[i] << " ";
    }
    cout << endl;

    return 0;
}

 int st, sr,n;
int storearray[4], sortarray[4];
int a, b , c, d;

cout<<"Enter four numbers: ";
sortof(storearray, sortarray);

if (a==sr)cout<<"The greater number"<<endl;

void sortof(int st[], int sr[])

#include <iostream>

using std::cout;
using std::endl;

void bubbleSort(int[], int);

const int ARRAY_SIZE = 4;

int main()
{
    int intArray[ARRAY_SIZE] = {1, 36, -534, 2};
    
    cout << "The original array\n" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        cout << intArray[i] << endl;
    }
    cout << "\n";
    
    bubbleSort(intArray, ARRAY_SIZE);
    
    cout << "The array sorted.\n" << endl;
    for (int i = 0; i < ARRAY_SIZE; i++)
    {
        cout << intArray[i] << endl;
    }
    
    return 0;
}

// Simplest sort ever.
// First argument is array, second is number of elements in array
void bubbleSort(int intArray[], int size)
{
    // This variable signals if the array is possibly not sorted.
    // If elements are moved during an iteration, this
    // is set to false to signal that the array MIGHT not be sorted yet.
    bool sorted = false;

    // We continue to loop as long as the array is (possibly) not sorted
    while (!sorted)
    {
        // We're optimistic and assume that THIS time finally the array IS sorted
        // (This way we also avoid an infinite loop)
        sorted = true;
        
        // We go through the array each time.
        // i starts at 1 because we access elements at i - 1
        for (int i = 1; i < size; i++)
        {
            if (intArray[i - 1] > intArray[i])
            {
                // If the element in the lower index really is greater than the one in the
                // higher index, we swap the elements. So the greater elements slowly move to the
                // end of the array
                int temp = intArray[i];
                intArray[i] = intArray[i - 1];
                intArray[i - 1] = temp;
                // Finally we set sorted to false to signal that a swap operation has occurred
                // and the sequence must continue.
                sorted = false;
            }
        }
    }
    
}