Question

BOOL utils::GetLogicDrivesByFreeSpace(LPTSTR pDrives)
{
    TCHAR szBuff[257];
    TCHAR chMaxDrive;
    DWORD dwLogicalDrives;
    ULARGE_INTEGER freeBytesAvaliable, maxFreeBytesAvaliable;
    ULARGE_INTEGER totalNumberOfBytes;
    std::map< ULARGE_INTEGER, TCHAR > driveMap;

    maxFreeBytesAvaliable.QuadPart = 0;
    dwLogicalDrives = GetLogicalDrives();
    for (int nDrive = 0; nDrive < 32; ++nDrive) {
        if (dwLogicalDrives && (1 << nDrive)) {
            _stprintf(szBuff, TEXT("%c:\\"), TEXT('A') + nDrive);
            //如果是硬盘分区
            if (GetDriveType(szBuff) == DRIVE_FIXED) {
                GetDiskFreeSpaceEx(szBuff,
                    &freeBytesAvaliable, &totalNumberOfBytes, NULL);
                driveMap.insert( std::pair< ULARGE_INTEGER, TCHAR >(freeBytesAvaliable.QuadPart, TEXT('A') + nDrive));
            }
        }
    }
    std::sort( driveMap.begin(), driveMap.end(), [](std::pair< ULARGE_INTEGER, TCHAR > n1, std::pair< ULARGE_INTEGER, TCHAR > n2) -> bool { return (n1.first.QuadPart < n2.first.QuadPart); } );
    int i = 0;
    for (std::map< ULARGE_INTEGER, TCHAR >::const_iterator iter = driveMap.begin(); iter != driveMap.end(); ++iter, ++i) {
        pDrives[i] = iter->second;
    }
    return true;
}

This lambda expression [](std::pair< ULARGE_INTEGER, TCHAR > n1, std::pair< ULARGE_INTEGER, TCHAR > n2) -> bool { return (n1.first.QuadPart < n2.first.QuadPart); } could not compile, Why???

thanks.

===JUST AS A NOTE===

Create a class:

struct CompareLargeInteger {
    bool operator()(ULARGE_INTEGER n1, ULARGE_INTEGER n2) {
        return (n1.QuadPart > n2.QuadPart);
    }
};

Then declare the driveMap as

std::map< ULARGE_INTEGER, TCHAR, CompareLargeInteger > driveMap;

Then everything is OK.

Give a insight into the MS’s STL

template<class _RanIt,
    class _Diff> inline
    void _Sort(_RanIt _First, _RanIt _Last, _Diff _Ideal)
    {   // order [_First, _Last), using operator<
    _Diff _Count;
    for (; _ISORT_MAX < (_Count = _Last - _First) && 0 < _Ideal; )
        {   // divide and conquer by quicksort
        _STD pair<_RanIt, _RanIt> _Mid =
            _Unguarded_partition(_First, _Last);
        _Ideal /= 2, _Ideal += _Ideal / 2;  // allow 1.5 log2(N) divisions

        if (_Mid.first - _First < _Last - _Mid.second)
            {   // loop on second half
            _Sort(_First, _Mid.first, _Ideal);
            _First = _Mid.second;
            }
        else
            {   // loop on first half
            _Sort(_Mid.second, _Last, _Ideal);
            _Last = _Mid.first;
            }
        }

    if (_ISORT_MAX < _Count)
        {   // heap sort if too many divisions
        _STD make_heap(_First, _Last);
        _STD sort_heap(_First, _Last);
        }
    else if (1 < _Count)
        _Insertion_sort(_First, _Last); // small
    }

__Count = __Last - __First, the minus operator is only supported by random access opeartor.

Answer 1

std::sort requires random access iterators, but std::map iterators are bidirectional iterators.

I think you should read more about std::map. It is implicitly sorted based on the key type and the optional predicate.