SkullBox Forum  |  Development  |  Java / C / C++ / C#  |  Topic: C/C++ Q&A

#include <cstring>
#include <iostream>

class BubbleSort
{
    public:
        /**
         * @brief constructor
         * @param arrayToSort the array to sort
         * @param the number of elements in array
         */
        BubbleSort(int arrayToSort[], int dimArray);

        /**
         * @brief destructor
         */
        ~BubbleSort();

        /**
         * @brief sort the array using the bubble sort method
         */
        void Sort();

        /**
         * @brief display the content of the array
         */
        void Display();

    private:
        /**
         * the number of elements in m_array
         */
        int m_dimArray;
        /**
         * the sorted array
         */
        int* m_array;
};

BubbleSort::BubbleSort(int arrayToSort[], int dimArray)
{
    m_dimArray = dimArray;
    m_array = new int[m_dimArray];
    std::memcpy(m_array,  arrayToSort, m_dimArray * sizeof(int));
}

BubbleSort::~BubbleSort()
{
    delete [] m_array;
}

void BubbleSort::Sort()
{
    bool swapped;
    int n = m_dimArray;
    do
    {
        swapped = false;
        --n;
        for (int i = 0; i < n; i++)
        {
            if (m_array[i] > m_array[i + 1])
            {
                int temp = m_array[i];
                m_array[i] = m_array[i + 1];
                m_array[i + 1] = temp;
                swapped = true;
            }
        }
    }
    while (swapped);
}

void BubbleSort::Display()
{
    for (int i = 0; i < m_dimArray; i++)
        std::cout << m_array[i] << std::endl;
}

int main()
{
    int x [] = {32, 21, 66, 332, 85, 3, 4, 2, 10, 99, 45, 23};
    BubbleSort bsorter(x, sizeof(x) / sizeof(int));

    std::cout << "Before sorting ... " << std::endl;
    bsorter.Display();

    std::cout << "After sorting ... " << std::endl;
    bsorter.Sort();
    bsorter.Display();

    return 0;
}

Before sorting ...
32
21
66
332
85
3
4
2
10
99
45
23
After sorting ...
2
3
4
10
21
23
32
45
66
85
99
332

int[] functie(int[] param)
{
    return param;
}

#include <iostream>

int* uselessFunc1(int arr[])
{
arr[0] = 9;
return arr;
}

void displayArray(int arr[], int dimArray)
{
for (int i = 0; i < dimArray; i++)
std::cout << arr[i] << std::endl;

std::cout << std::endl << std::endl;
}


int main()
{
int array[5] = {1,2,3,4,5};

displayArray(array, sizeof(array) / sizeof(int));
int *ptr = uselessFunc1(array);
displayArray(array, sizeof(array) / sizeof(int));
ptr[0] = 7;
displayArray(array, sizeof(array) / sizeof(int));

return 0;
}

#include <iostream>

template <typename T, int N>
struct wrapper
{
// typedefs to a reference to an array of a generic type, nested in a template class
typedef T (&refType)[N];
// assure const-correctness
typedef const T(&constRefType)[N];
};

template <typename T, int N>
typename wrapper<T, N>::refType uselessFunc2(typename wrapper<T, N>::refType arr, const T& value)
{
arr[0] = value;
return arr;
}

// display the content of a static array of a generic type
// the array size being a template parameter also
template <typename T, int N>
void displayArray(typename wrapper<T, N>::constRefType arr)
{
for (int i = 0; i < N; i++)
std::cout << arr[i] << std::endl;

std::cout << std::endl << std::endl;
}


int main()
{
int array[5] = {1,2,3,4,5};

// display  the initial content of the array
displayArray<int, 5>(array);

// modify its first element at 9
wrapper<int, 5>::refType refArray = uselessFunc2<int, 5>(array, 9);

displayArray<int, 5>(array);

// modify the first element at 7
refArray[0] = 7;

displayArray<int, 5>(array);

// start over again
array[0] = 1;

// you can also do this, the end effect is to modify the first element at 101
uselessFunc2<int, 5>(array, 0)[0] = 101;

displayArray<int, 5>(array);

return 0;
}

double x=2.0/4.0;