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;
}

这个lambda表达式[](std::pair< ULARGE_INTEGER, TCHAR > n1, std::pair< ULARGE_INTEGER, TCHAR > n2) -> bool { return (n1.first.QuadPart < n2.first.QuadPart); }无法编译，为什么???

感谢。

===只是作为一个注意事项===

创建一个类：

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

然后将driveMap声明为

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

然后一切都好。

深入了解MS的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，减运算符仅受随机访问操作符支持。

Answer 1

std :: sort需要随机访问迭代器，但std :: map迭代器是双向迭代器。

我认为你应该阅读更多关于std :: map的内容。它基于键类型和可选谓词进行隐式排序。

我的lambda表达式做地图密钥比较有什么问题？

1 个答案: