struct Entry{
 std::string name;
 int number;
};

std::vector<Entry>book;

int phoneSort(/*что мне передавать здесь?*/){
 struct Entry *ia=(struct Entry *)a;
 struct Entry *ib=(struct Entry *)b;
 return ia->number-ib->number;

}
main(){
 sort(book,bookLen,sizeof(struct Entry),phoneSort);

}

S> sort(book,bookLen,sizeof(struct Entry),phoneSort);

// Для qsort:
int phoneSort ( void const* left, void const* right ) {
    Entry const* leftEntry = static_cast<Entry const*> ( left ); // static_cast - более безопасный, нежели C-style cast ( struct Entry* )
    Entry const* rightEntry = static_cast<Entry const*> ( right );

    // -1, если меньше, 0, если равно и 1, если больше:
    if ( leftEntry->number < rightEntry->number ) {
        return -1;
    }
    else if ( leftEntry->number == rightEntry->number ) {
        return 0;
    }
    else {
        return 1;
    }
}


// Для std::sort:
struct SortByPhone {
    bool operator() ( Entry const& left, Entry const& right ) const {
        return left.number < right.number;
    }
};

#include <cstdlib> // для qsort
#include <algorithm> // для std::sort

// ...

std::vector<Entry> book;

int main () {
    // C-style:
    std::qsort ( &book[ 0 ], book.size (), sizeof ( Entry ), &phoneSort );

    // C++-style (рекомендую его):
    std::sort ( book.begin (), book.end (), SortByPhone () );
}

AF>struct SortByPhone {
AF>    bool operator() ( Entry const& left, Entry const& right ) const {
AF>        return left.number < right.number;
AF>    }
AF>};
AF>

bool operator() ( const Entry& left, const Entry& right ) const {

AF>>const T& и T const& в данном случае (с указателями будут нюансы) эквивалентны, это вопрос привычки

const T*
T* const // не эквивалентны

S>bool operator() ( const Entry& left, const Entry& right ) const {

class string
{
  char *m_begin;
  size_t m_size, m_capacity;
  char m_buffer[BUFSIZE];

public:
  .....
};