Insensible à la casse std::string.find()

Vous pouvez utiliser std::search avec un prédicat.

#include <locale>
#include <iostream>
#include <algorithm>
using namespace std;
//templated version of my_equal so it could work with both char and wchar_t
template<typename charT>
struct my_equal {
my_equal( const std::locale& loc ) : loc_(loc) {}
bool operator()(charT ch1, charT ch2) {
return std::toupper(ch1, loc_) == std::toupper(ch2, loc_);
}
private:
const std::locale& loc_;
};
//find substring (case insensitive)
template<typename T>
int ci_find_substr( const T& str1, const T& str2, const std::locale& loc = std::locale() )
{
typename T::const_iterator it = std::search( str1.begin(), str1.end(), 
str2.begin(), str2.end(), my_equal<typename T::value_type>(loc) );
if ( it != str1.end() ) return it - str1.begin();
else return -1; //not found
}
int main(int arc, char *argv[]) 
{
//string test
std::string str1 = "FIRST HELLO";
std::string str2 = "hello";
int f1 = ci_find_substr( str1, str2 );
//wstring test
std::wstring wstr1 = L"ОПЯТЬ ПРИВЕТ";
std::wstring wstr2 = L"привет";
int f2 = ci_find_substr( wstr1, wstr2 );
return 0;
}

OriginalL'auteur Kirill V. Lyadvinsky

Pourquoi ne pas simplement convertir les chaînes de caractères en minuscules, avant d'appeler find()?

tolower

Avis:

• Inefficace pour de longues cordes.
• Méfiez-vous des enjeux liés à l'internationalisation.

OriginalL'auteur DavidS

Puisque vous êtes en train de faire sous-chaîne de recherches (std::string) et pas d'élément (personnage) des recherches, il n'y a malheureusement pas de solution, je suis au courant de qui est immédiatement accessible dans la bibliothèque standard pour ce faire.

Néanmoins, il est assez facile: il suffit de convertir les chaînes de caractères en majuscules (ou les deux à la baisse des cas, j'ai choisi supérieure dans cet exemple).

std::string upper_string(const std::string& str)
{
string upper;
transform(str.begin(), str.end(), std::back_inserter(upper), toupper);
return upper;
}
std::string::size_type find_str_ci(const std::string& str, const std::string& substr)
{
return upper(str).find(upper(substr) );
}

Ce n'est pas une solution rapide (frontière dans pessimization territoire) mais c'est le seul que je connaisse de la main gauche. C'est pas non plus difficile à mettre en œuvre votre propre casse de chaîne de finder si vous êtes inquiet au sujet de l'efficacité.

En outre, j'ai besoin de soutien
std::wstring/wchar_t. Des idées?

tolower/toupper dans les paramètres régionaux travailleront sur l'échelle de cordes, de sorte que la solution ci-dessus devrait être tout aussi applicable (changement simple std::string à std::wstring).

[Modifier] Une alternative, comme l'a souligné, est de s'adapter à votre propre casse de chaîne type de basic_string en précisant vos propres traits de caractère. Cela fonctionne si vous pouvez accepter toutes les recherches de chaînes, de comparaisons, etc. pour être sensible à la casse pour une donnée de type chaîne de caractères.

OriginalL'auteur stinky472

Si vous voulez “réel” comparaison selon Unicode et les paramètres régionaux règles, utilisez Intensifs Collateur de la classe.

OriginalL'auteur Philipp

J'adore les réponses de Cyrille V. Lyadvinsky et CC. mais mon problème était un peu plus précis que simplement l'insensibilité à la casse; j'avais besoin d'un paresseux compatibles Unicode argument de ligne de commande de l'analyseur qui pourrait permettre d'éliminer les faux positifs/négatifs lorsqu'ils traitent avec chaîne alphanumérique de recherches qui pourraient avoir des caractères spéciaux dans la chaîne de base utilisé pour le format numérique des mots-clés, je cherchais à l'encontre, par exemple, Wolfjäger ne devrait pas correspondre à jäger mais <jäger> devrait.

Il est fondamentalement juste Kiril/CC réponse à la manutention supplémentaire pour alphanumériques exacte de la longueur des matches.

/* Undefined behavior when a non-alpha-num substring parameter is used. */
bool find_alphanum_string_CI(const std::wstring& baseString, const std::wstring& subString)
{
/* Fail fast if the base string was smaller than what we're looking for */
if (subString.length() > baseString.length()) 
return false;
auto it = std::search(
baseString.begin(), baseString.end(), subString.begin(), subString.end(),
[](char ch1, char ch2)
{
return std::toupper(ch1) == std::toupper(ch2);
}
);
if(it == baseString.end())
return false;
size_t match_start_offset = it - baseString.begin();
std::wstring match_start = baseString.substr(match_start_offset, std::wstring::npos);
/* Typical special characters and whitespace to split the substring up. */
size_t match_end_pos = match_start.find_first_of(L" ,<.>;:/?\'\"[{]}=+-_)(*&^%$#@!~`");
/* Pass fast if the remainder of the base string where
the match started is the same length as the substring. */
if (match_end_pos == std::wstring::npos && match_start.length() == subString.length()) 
return true;
std::wstring extracted_match = match_start.substr(0, match_end_pos);
return (extracted_match.length() == subString.length());
}

OriginalL'auteur kayleeFrye_onDeck