C++ Windows是否有默认的单词词典？

我正在尝试为我的C++/MFC项目（仅使用

WinAPI

开发）创建一个密码复杂性指示器。类似于以下内容：

我可以做大多数检查，如字符数、包含字母、数字、符号、重复字符等。但我还想添加一个功能，查看一个人是否使用了字典中的单词。这似乎是决定密码强度的最重要因素之一

（例如，密码

“Monkey123！”

如果不考虑字典中单词的存在，就会被评估为

非常强

，这实际上使它非常弱。否则，它有10个字符长，有小字母和大写字母，有数字和标点符号。除了使用字典单词之外，唯一的警告是它有序列号。）

所以我想知道Windows是否有一个字典单词列表（与Linux在

/usr/share/dict/words

中的情况非常相似），如果有，我该如何利用它

另外，如果这在WindowsXPSP3及以上版本上可用，那就太好了

---

PS2。到目前为止，我所能想到的只是将其纳入我的项目中。（不幸的是，它增加了大约1.3MB的内存，并且只将其硬编码为英语。）

Windows 8是第一个具有内置功能的Windows版本，但我认为它不允许您直接访问其字典，您必须尝试在密码中查找单词边界，并分别对这些单词进行拼写检查，以查看它们是否存在于词典中

将学分分配给了。Windows 8显然支持内置接口。因此，作为指南，下面是显示其用法的代码：

#include <Spellcheck.h>

HRESULT hr;

hr = CoInitializeEx(NULL, COINIT_MULTITHREADED);
BOOL bInitted = SUCCEEDED(hr);
if (true)
{
    CComPtr<ISpellCheckerFactory> factory;
    if (SUCCEEDED(hr = CoCreateInstance(__uuidof(SpellCheckerFactory),
        nullptr,
        CLSCTX_INPROC_SERVER,
        __uuidof(factory),
        reinterpret_cast<void **>(&factory))))
    {
        BOOL supported;
        if (SUCCEEDED(hr = factory->IsSupported(L"en-US", &supported)))
        {
            if (supported)
            {
                CComPtr<ISpellChecker> checker;
                if (SUCCEEDED(hr = factory->CreateSpellChecker(L"en-US", &checker)))
                {
                    LPCTSTR pText = L"usa"; // L"Cann I I haev some?";  // L"ACLU";

                    CComPtr<IEnumSpellingError> errors;
                    if (SUCCEEDED(hr = checker->Check(pText, &errors)))
                    {
                        for (;;)
                        {
                            CComPtr<ISpellingError> error;
                            hr = errors->Next(&error);
                            if (hr == S_OK)
                            {
                                //Found a spelling error

                                //To get a position of a spelling error
                                ULONG startIndex;
                                ULONG length;
                                VERIFY(SUCCEEDED(hr = error->get_StartIndex(&startIndex)));
                                VERIFY(SUCCEEDED(hr = error->get_Length(&length)));

                                wstring word(pText + startIndex, pText + startIndex + length);

                                //Get corrective action
                                CORRECTIVE_ACTION action;
                                VERIFY(SUCCEEDED(hr = error->get_CorrectiveAction(&action)));

                                //We must have gotten something
                                ASSERT(action != CORRECTIVE_ACTION_NONE);

                                if (action == CORRECTIVE_ACTION_GET_SUGGESTIONS)
                                {
                                    //Spellchecker issued suggestions
                                    TRACE(L"Suggestions for \"%s\":\n", word.c_str());

                                    CComPtr<IEnumString> suggestions;
                                    if (SUCCEEDED(hr = checker->Suggest(word.c_str(), &suggestions)))
                                    {
                                        for (;;)
                                        {
                                            wchar_t* pSuggestion = NULL;
                                            hr = suggestions->Next(1, &pSuggestion, NULL);
                                            if (hr == S_OK)
                                            {
                                                //Got suggestion
                                                ASSERT(pSuggestion);

                                                TRACE(L" - %s\n", pSuggestion);

                                                CoTaskMemFree(pSuggestion);
                                            }
                                            else if (hr == S_FALSE)
                                            {
                                                //No more suggestions
                                                break;
                                            }
                                            else
                                            {
                                                //Some other error
                                                ASSERT(NULL);
                                                break;
                                            }
                                        }
                                    }
                                    else
                                        ASSERT(NULL);
                                }
                                else if (action == CORRECTIVE_ACTION_REPLACE)
                                {
                                    //Spellchecker wants to replace a part of the phrase
                                    wchar_t* pstrReplacement = NULL;
                                    VERIFY(SUCCEEDED(hr = error->get_Replacement(&pstrReplacement)));
                                    ASSERT(pstrReplacement);

                                    TRACE(L"Replace \"%s\" with \"%s\"\n", word.c_str(), pstrReplacement);

                                    CoTaskMemFree(pstrReplacement);
                                }
                                else if (action == CORRECTIVE_ACTION_DELETE)
                                {
                                    //Spellchecker wants to delete a part of the phrase
                                    TRACE(L"Delete \"%s\"\n", word.c_str());
                                }

                            }
                            else if (hr == S_FALSE)
                            {
                                //No more spelling errors
                                break;
                            }
                            else
                            {
                                //Some other error
                                ASSERT(NULL);
                                break;
                            }
                        }
                    }
                }
            }
            else
            {
                //Such language is not supported
                ASSERT(NULL);
            }
        }
    }
}

if (bInitted)
{
    ::CoUninitialize();
}

#包括
HRESULT-hr；
hr=coinitializex（空，COINIT\u多线程）；
BOOL-binited=成功（hr）；
如果（真）
{
买方工厂；
如果（成功）（hr=CoCreateInstance（uuuIdof（SpellCheckerFactory）），
nullptr，
CLSCTX_INPROC_服务器，
__乌伊多夫（工厂），
重新解释（铸造（工厂）））
{
布尔支持；
如果（成功（hr=factory->IsSupported（L“en-US”，&supported）））
{
如果（支持）
{
会计核算员；
如果（成功（hr=factory->CreateSpellChecker（L“en-US”、&checker）））
{
LPCTSTR pText=L“usa”；//L“Can I have some？”；//L“ACLU”；
会计差错；
如果（成功（hr=checker->Check（pText，&errors）））
{
对于（；；）
{
CComPtr错误；
hr=错误->下一步（&错误）；
如果（hr==S_正常）
{
//发现一个拼写错误
//获取拼写错误的位置
乌龙星索引；
乌龙长度；
验证（成功（hr=error->get_StartIndex（&StartIndex））；
验证（成功（hr=error->get_Length（&Length））；
wstring字（pText+startIndex，pText+startIndex+length）；
//采取纠正措施
纠正措施；
验证（成功（hr=error->get_CorrectiveAction（&action））；
//我们一定得到了什么
断言（动作！=纠正动作\u无）；
如果（措施==纠正措施获得建议）
{
//拼写检查器发出建议
TRACE（L“对\%s\”的建议：\n”，word.c_str（）；
买方建议；
if（成功（hr=checker->Suggest（word.c_str（），&suggestions）））
{
对于（；；）
{
wchar_t*pSuggestion=NULL；
hr=建议->下一步（1，&pSuggestion，NULL）；
如果（hr==S_正常）
{
//得到建议
断言（pSuggestion）；
记录道（L“-%s\n”，pSuggestion）；
CoTaskMemFree（pSuggestion）；
}
else if（hr==S_FALSE）
{
//没有更多的建议
打破
}
其他的
{
//其他一些错误
断言（空）；
打破
}
}
}
其他的
断言（空）；
}
否则如果（措施==纠正措施\u替换）
{
//拼写检查器要替换短语的一部分
wchar_t*pstrReplacement=NULL；
验证（成功（hr=error->get_Replacement（&pstrReplacement））；