C++ 比较最后的字符，不区分大小写（使用谓词？）

我有一个

std:：wstring fName

文件名，我想测试它是否有.txt扩展名。这样做：

return ((fName.length() >= 4) && (0 == fName.compare(fName.length() - 4, 4, L".txt")));

但它是区分大小写的，我不希望：我需要

blah.tXt

和

hello.tXt

都被接受

---

这应作为不区分大小写的版本：

std::wstring ext = L".txt";
wstring::const_iterator it = std::search(fName.end() - 4, fName.end(), ext.begin(), ext.end(), 
                               [](wchar_t ch1, wchar_t ch2) { return tolower(ch1) == ch2; }); 
                    // no need tolower(ch2) because the pattern .txt is already lowercase
return (it != str1.end());

但是

std:：search

可能远远不是最优的，因为它搜索是否包含模式（在原始字符串中的任何位置），这里我只需要逐个字符进行比较

---

由于我需要对数百万个文件名进行测试，如何提高性能以检查文件名是否有扩展名（不区分大小写）

.txt

？

我不想要简单的解决方案：

• 让我们在一个新变量中将

  fName

  小写（甚至只将

  fName

  的最后4个字符小写）

• 然后比较

因为这将需要新的变量、内存等。我是否可以使用自定义谓词

[]（wchar\u t ch1，wchar\u t ch2）{return tolower（ch1）==ch2；}）

---

---

注意：我不是在寻找Boost解决方案，也不是像这样的解决方案，一个或多个类似的问题都没有针对性能进行优化。

如果您想要一个没有假设的实现（这也不假设扩展名的长度，但假设文件名的大小至少为4个字符）：

这是上述内容的一个更混乱的版本，但应该更快：

return *((int*)&fName[index - 4]) == '.' + 't' + 'x' + 't';

你可以进一步优化这一点，如果你知道没有其他扩展会以“T”结尾，中间有一个“X”，比如这样做：

return fName[fName.length() - 1] == 't' || 'T;

---

如果您想要一个没有假设的实现（也不假设扩展名的长度，但假设文件名的大小至少为4个字符）：

这是上述内容的一个更混乱的版本，但应该更快：

return *((int*)&fName[index - 4]) == '.' + 't' + 'x' + 't';

你可以进一步优化这一点，如果你知道没有其他扩展会以“T”结尾，中间有一个“X”，比如这样做：

return fName[fName.length() - 1] == 't' || 'T;

这个怎么样

#include <string>
#include <algorithm>

template<typename CharT>
bool HasExtension(const std::basic_string<CharT>& fileName, const std::basic_string<CharT>& ext)
{
    auto b = fileName.begin() + fileName.length() - ext.length();
    auto a = ext.begin();

    while (b != fileName.end())
    {
        if (*a++ != tolower(*b++))
        {
             return false;
        }
    }
    return true;
}


int  main()
{
    std::string ext{".Txt"}; // make sure this is a lower case std::string.
    std::transform(ext.begin(), ext.end(), ext.begin(), tolower);  

    std::string fn{"test.txt"};

   return HasExtension(fn, ext) ? 0 : 1;
}

#包括
#包括
模板
bool HasExtension（const std:：basic_string和fileName，const std:：basic_string和ext）
{
自动b=fileName.begin（）+fileName.length（）-ext.length（）；
自动a=外部开始（）；
while（b！=fileName.end（））
{
如果（*a++！=tolower（*b++））
{
返回false；
}
}
返回true；
}
int main（）
{
std:：string ext{.Txt”}；//确保这是小写的std:：string。
std:：transform（ext.begin（）、ext.end（）、ext.begin（）、tolower）；
std：：字符串fn{“test.txt”}；
返回分机（fn，ext）？0:1；
}

这个怎么样

#include <string>
#include <algorithm>

template<typename CharT>
bool HasExtension(const std::basic_string<CharT>& fileName, const std::basic_string<CharT>& ext)
{
    auto b = fileName.begin() + fileName.length() - ext.length();
    auto a = ext.begin();

    while (b != fileName.end())
    {
        if (*a++ != tolower(*b++))
        {
             return false;
        }
    }
    return true;
}


int  main()
{
    std::string ext{".Txt"}; // make sure this is a lower case std::string.
    std::transform(ext.begin(), ext.end(), ext.begin(), tolower);  

    std::string fn{"test.txt"};

   return HasExtension(fn, ext) ? 0 : 1;
}

#包括
#包括
模板
bool HasExtension（const std:：basic_string和fileName，const std:：basic_string和ext）
{
自动b=fileName.begin（）+fileName.length（）-ext.length（）；
自动a=外部开始（）；
while（b！=fileName.end（））
{
如果（*a++！=tolower（*b++））
{
返回false；
}
}
返回true；
}
int main（）
{
std:：string ext{.Txt”}；//确保这是小写的std:：string。
std:：transform（ext.begin（）、ext.end（）、ext.begin（）、tolower）；
std：：字符串fn{“test.txt”}；
返回分机（fn，ext）？0:1；
}

建议的解决方案是

#include <iostream>
#include <string>

bool isTXT(const std::wstring& str)
{
    std::wstring::size_type idx;
    idx = str.rfind('.');
    if( idx != std::wstring::npos ){
        std::wstring ext = str.substr(idx+1);
        if( ext == L"txt" || ext == L"TXT" ) // do all possible combinations.
            return true;
    }
    return false;
}

int main()
{
    std::wstring fileName = L"haihs.TXT";
    std::wcout << isTXT(fileName) << std::endl;

    return 0;
}

#包括
#包括
布尔isTXT（常量标准：：wstring和str）
{
std:：wstring:：size_type idx；
idx=str.rfind（'.'）；
if（idx！=std:：wstring:：npos）{
std:：wstring ext=str.substr（idx+1）；
如果（ext==L“txt”| | ext==L“txt”）//执行所有可能的组合。
返回true；
}
返回false；
}
int main（）
{
std:：wstring fileName=L“haihs.TXT”；
std:：wcout建议的解决方案是

#include <iostream>
#include <string>

bool isTXT(const std::wstring& str)
{
    std::wstring::size_type idx;
    idx = str.rfind('.');
    if( idx != std::wstring::npos ){
        std::wstring ext = str.substr(idx+1);
        if( ext == L"txt" || ext == L"TXT" ) // do all possible combinations.
            return true;
    }
    return false;
}

int main()
{
    std::wstring fileName = L"haihs.TXT";
    std::wcout << isTXT(fileName) << std::endl;

    return 0;
}

#包括
#包括
布尔isTXT（常量标准：：wstring和str）
{
std:：wstring:：size_type idx；
idx=str.rfind（'.'）；
if（idx！=std:：wstring:：npos）{
std:：wstring ext=str.substr（idx+1）；
如果（ext==L“txt”| | ext==L“txt”）//执行所有可能的组合。
返回true；
}
返回false；
}
int main（）
{
std:：wstring fileName=L“haihs.TXT”；
std:：wcout正如@fghj的评论所建议的，这是一个很好的解决方案：

std::equal(fName.end() - ext.length(), fName.end(), ext.begin(),
           [](wchar_t ch1, wchar_t ch2) { return tolower(ch1) == ch2; });

正如@fghj的评论所建议的，这是一个很好的解决方案：

std::equal(fName.end() - ext.length(), fName.end(), ext.begin(),
           [](wchar_t ch1, wchar_t ch2) { return tolower(ch1) == ch2; });

为什么不使用第一个变量，而不是将
std:：wstring:：compare
与自定义谓词一起使用
std:：equal
？
返回（（fName.length（）>=4）和&（0==fName.compare（fName.length（）-4，4，L.txt）））；
如果扩展名超过3个字符怎么办？您的操作系统应该已经有了使用文件名并提供适当部分名称的函数（例如Windows
Pathxxx
函数）。不需要被角盒绊倒。@user1034749您的意思是
std:：equal（fName.end（）-ext.length（），fName.end（）），ext.begin（），[]（wchar\u t ch1，wchar\u t ch2）{return tolower（ch1）=ch2；}）
？这似乎确实是解决方案！为什么不使用第一个变量，而不是
std:：wstring:：compare
使用
std:：equal
与自定义谓词一起使用
return（（fName.length（）>=4）和（0==fName.compare（fName.length（）-4，4，L.txt）））)；
如果扩展名超过3个字符怎么办？您的操作系统应该已经有了使用文件名并提供适当部分名称的函数（例如Windows
Pathxxx
函数）。不需要被角盒绊倒。@user1034749您的意思是
std:：equal（fName.end（）-ext.length（），fName.end（）），ext.begin（），[]（wchar_t ch1，wchar_t ch2）{return tolower（ch1）=ch2；}）
？这似乎确实是解决方案！这两种方法都会导致未定义的行为。此外，这种处理大小写不敏感吗？
假设其他扩展的ASCII值之和