How to sort vector of pointer-to-struct

int (*)(void*, void*) is the comparator for C qsort() function. In C++ std::sort() the prototype to the comparator is:

bool cmp(const hits_object* lhs, const hits_object* rhs)
{
    return lhs->position < rhs->position;
}

std::sort(hits.begin(), hits.end(), &cmp);

On the other hand, you can use std::pair struct, which by default compares its first fields:

typedef std::pair<int position, unsigned long int hash> hits_object;
// ...
std::sort(hits.begin(), hits.end());

Without knowing what concurrent_vector is, I can't be sure what's causing the segmentation fault. Assuming it's similar to std::vector, you need to populate it with hits.push_back(obj) rather than hits[i] = j; you cannot use [] to access elements beyond the end of a vector, or to access an empty vector at all.

The comparison function should be equivalent to a < b, returning a boolean value; it's not a C-style comparison function returning negative, positive, or zero. Also, since sort is a template, there's no need for C-style void * arguments; everything is strongly typed:

bool compareByPosition(hits_object const * elem1, hits_object const * elem2) {
    return elem1->position < elem2->position;
}

Also, you usually don't want to use new (and certainly never malloc) to create objects to store in a vector; the simplest and safest container would be vector<hits_object> (and a comparator that takes references, rather than pointers, as arguments). If you really must store pointers (because the objects are expensive to copy and not movable, or because you need polymorphism - neither of which apply to your example), either use smart pointers such as std::unique_ptr, or make sure you delete them once you're done with them.

The third argument you pass to std::sort() must have a signature similar to, and the semantics of, operator<():

bool is_smaller_position(const hits_object* lhs, const hits_object* rhs)
{
  return lhs->position < rhs->position;
}

When you store pointers in a vector, you cannot overload operator<(), because smaller-than is fixed for all built-in types.

On a sidenote: Do not use malloc() in C++, use new instead. Also, I wonder why you are not using objects, rather than pointers. Finally, if concurrent_vector is anything like std::vector, you need to explicitly make it expand to accommodate new objects. This is what your code would then look like:

concurrent_vector<hits_object*> hits;

for(i=0;...){
    hits_object obj;
    obj.position=i;
    obj.hash=_prevHash[tid];
    hits.push_back(obj);
}

This doesn't look right:

for(i=0;...){
    hits_object *obj=(hits_object*)malloc(sizeof(hits_object));
    obj->position=i;
    obj->hash=_prevHash[tid];
    hits[i]=obj;
}

here you already are sorting the array based on 'i' because you set position to i as well as it becomes the index of hits!

also why using malloc, you should use new(/delete) instead. You could then create a simple constructor for the structure to initialize the hits_object

e.g.

struct hits_object
{
   int position;
   unsigned int hash;

   hits_object( int p, unsigned int h ) : position(p), hash(h) {;}
};

then later write instead

hits_object* obj = new hits_object( i, _prevHash[tid] );

or even

hits.push_back(  new hits_object( i, _prevHash[tid] ) );

Finally, your compare function should use the same data type as vector for its arguments

bool cmp( hits_object* p1, hits_object* p2 )
{
  return p1->position < p2->position;
}

You can add a Lambda instead of a function to std::sort.

struct test
{
    int x;
};

std::vector<test> tests;

std::sort(tests.begin(), tests.end(),
    [](const test* a, const test* b) 
    { 
        return a->x < b->x; 
    });