0

I want to write a small program to learn C++ 11 multi-thread program. so I decided to write a mergeSort to test it.

Here is my code:

    class SortMethods
    {
    protected:
        int N;
        int *aux;
    public:
        void mergeSort(int a[])
        {
            aux = new int[N];
            mergeSort(a, 0, N - 1);
        }
        void merge(int a[], int low, int high)
        {
            int mid = (low + high) / 2;

            //optimization 3 for nearly-sorted array
            //we can add a condition to improve performance when the array has already sorted or nearly-sorted.
            if (a[mid] <= a[mid + 1])
            {
                return;
            }

            int i = low;
            int j = mid + 1;

            for (int k = low; k <= high; k++)
            {
                aux[k] = a[k];
            }

            for (int k = low; k <= high; k++)
            {
                if (i > mid)
                    a[k] = aux[j++];
                else if (j > high)
                    a[k] = aux[i++];
                else if (lessThan(aux[j], aux[i]))
                    a[k] = aux[j++];
                else
                    a[k] = aux[i++];
            }
        }
        void mergeSort(int a[], int low, int high)
        {
            if (high <= low)
            {
                return;
            }
            int mid = low + (high - low) / 2;

            //single_thread
            mergeSort(a, low, mid);
            mergeSort(a, mid + 1, high);
            /*merge(a, low, high);*/

            //multi_thread
            /*thread left(mergeSort, a, low, mid);
            thread right(mergeSort, a, mid + 1, high);
            left.join();
            right.join();*/

            merge(a, low, high);

        }
    }
int main()
{
    int *a = new int(100);

    for(int i=0; i<100; i++)
    {
       a[i] = rand() % 1000;
    }
    SortMethods sort(100);
    sort.mergeSort(a);
}

But when I complier the code in VS2015, it will throw an error that no instance of constructor "std::thread" matches the argument list.

can you help me find the problem with my code?

=============================================

because of your guys help, i find out that because i overload the mergeSort methods. I rename the method to mergeSort_multi_thread

thread left(&SortMethods::mergeSort_multi_thread, a, low, mid);

I got the error failed to specialize function template 'unknown-type std::invoke(_Callable &&, _Types &&...)

1>  g:\dataalog\datastructuresandalgo\basic_data_structures\sorting.h(240): note: see reference to function template instantiation 'std::thread::thread<void(__thiscall SortMethods::* )(int [],int,int),int&[],int&,int&,void>(_Fn &&,int &[],int &,int &)' being compiled
1>          with
1>          [
1>              _Fn=void (__thiscall SortMethods::* )(int [],int,int)
1>          ]
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========

[enter image description here][1]

Thx

Damon Du
  • 3
  • 2
  • 1
    You are using a method, not a function. Check this answer http://stackoverflow.com/questions/10673585/start-thread-with-member-function to learn how to pass member functions and their respective objects – Nadir Feb 25 '16 at 09:54
  • 2
    Don't comment out the code that causes the error, because otherwise people can't reproduce the error! Post the code that doesn't work! However, this has been answered a million times already. – Jonathan Wakely Feb 25 '16 at 10:02

1 Answers1

1

You overloaded mergeSort, so the compiler doesn't know which one you mean. Use static_cast to select the correct one.

static_cast<void(SortMethods::*)(int[], int, int)>(&SortMethods::mergeSort)

When you create the thread, you'll have to pass this too:

std::thread left(static_cast<...>(...), this, a, low, mid);

It probably gave you the error for failing to find a matching constructor in thread because it was trying to find a constructor for the overload set. If you look at the full error information, it should say something about that.

Weak to Enuma Elish
  • 4,622
  • 3
  • 24
  • 36