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

Question

Je suis en train d'utiliser la méthode find() de std::string pour tester si une chaîne de caractères est une sous-chaîne d'une autre. Maintenant, j'ai besoin d'une version insensible à la casse de la même chose. Pour la comparaison de chaînes, je peux toujours utiliser stricmp() mais il ne semble pas y avoir de stristr().

J'ai trouvé diverses réponses et la plupart suggèrent d'utiliser Boost qui n'est pas une option dans mon cas. De plus, j'ai besoin de supporter std::wstring/wchar_t. Des idées ?

Answer 1

Vous pourriez utiliser std::search avec un prédicat personnalisé.

#include 
#include 
#include 
using namespace std;

// version modélisée de my_equal pour qu'elle puisse fonctionner avec char et wchar_t
template
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_;
};

// trouver sous-chaîne (insensible à la casse)
template
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(loc) );
    if ( it != str1.end() ) return it - str1.begin();
    else return -1; // non trouvé
}

int main(int arc, char *argv[]) 
{
    // test de string
    std::string str1 = "PREMIER BONJOUR";
    std::string str2 = "bonjour";
    int f1 = ci_find_substr( str1, str2 );

    // test de wstring
    std::wstring wstr1 = L"ОПЯТЬ ПРИВЕТ";
    std::wstring wstr2 = L"привет";
    int f2 = ci_find_substr( wstr1, wstr2 );

    return 0;
}

Answer 2

Le nouveau style C++11 :

#include 
#include 
#include 

/// Essayez de trouver dans la paille l'aiguille - en ignorant la casse
bool findStringIC(const std::string & strHaystack, const std::string & strNeedle)
{
  auto it = std::search(
    strHaystack.begin(), strHaystack.end(),
    strNeedle.begin(),   strNeedle.end(),
    [](unsigned char ch1, unsigned char ch2) { return std::toupper(ch1) == std::toupper(ch2); }
  );
  return (it != strHaystack.end() );
}

L'explication de la fonction std::search peut être trouvée sur cplusplus.com.

Answer 3

Pourquoi ne pas simplement convertir les deux chaînes en minuscules avant d'appeler find()?

tolower

Remarque:

• Inefficace pour les longues chaînes.
• Méfiez-vous des problèmes d'internationalisation.

Answer 4

Étant donné que vous effectuez des recherches de sous-chaînes (std::string) et non des recherches d'éléments (caractères), il n'existe malheureusement aucune solution existante à ma connaissance immédiatement accessible dans la bibliothèque standard pour le faire.

Néanmoins, c'est assez facile à faire : il suffit de convertir les deux chaînes en majuscules (ou les deux en minuscules - j'ai choisi majuscules 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 (frôlant le territoire de la pessimization) mais c'est la seule que je connaisse de façon immédiate. Il n'est pas non plus très difficile d'implémenter votre propre recherche de sous-chaîne insensible à la casse si vous vous préoccupez de l'efficacité.

De plus, j'ai besoin de prendre en charge std::wstring/wchar_t. Des idées ?

tolower/toupper en locale fonctionnera également sur les chaînes larges, donc la solution ci-dessus devrait être tout aussi applicable (il suffit de changer std::string en std::wstring).

[Edit] Une alternative, comme indiqué, est d'adapter votre propre type de chaîne insensible à la casse à partir de basic_string en spécifiant vos propres traits de caractère. Cela fonctionne si vous pouvez accepter que toutes les recherches de chaînes, les comparaisons, etc. soient insensibles à la casse pour un certain type de chaîne donné.

Answer 5

Aussi il est logique de fournir la version Boost : cela modifiera les chaînes originales.

#include <boost/algorithm/string.hpp>

string str1 = "hello world!!!";
string str2 = "HELLO";
boost::algorithm::to_lower(str1)
boost::algorithm::to_lower(str2)

if (str1.find(str2) != std::string::npos)
{
    // str1 contains str2
}

ou en utilisant la parfaite bibliothèque d'expression boost

#include <boost/xpressive/xpressive.hpp>
using namespace boost::xpressive;
....
std::string long_string( "very LonG string" );
std::string word("long");
smatch what;
sregex re = sregex::compile(word, boost::xpressive::icase);
if( regex_match( long_string, what, re ) )
{
    cout << word << " found!" << endl;
}

Dans cet exemple, vous devez faire attention à ce que votre mot de recherche n'ait pas de caractères spéciaux regex.