Controleer of een string een string bevat in C++

Ik heb een variabele van het type std::string. Ik wil controleren of het een bepaalde std::stringbevat. Hoe zou ik dat doen?

Is er een functie die true retourneert als de tekenreeks wordt gevonden, en false als dat niet het geval is?


Antwoord 1, autoriteit 100%

Gebruik std::string::findals volgt:

if (s1.find(s2) != std::string::npos) {
    std::cout << "found!" << '\n';
}

Opmerking: “gevonden!” wordt afgedrukt als s2een substring is van s1, zowel s1als s2zijn van het type std::string.


Antwoord 2, autoriteit 16%

Je kunt proberen de findfunctie:

string str ("There are two needles in this haystack.");
string str2 ("needle");
if (str.find(str2) != string::npos) {
//.. found.
} 

Antwoord 3, autoriteit 4%

Eigenlijk kun je proberen om de boost-bibliotheek te gebruiken, ik denk dat std::string niet genoeg methode biedt om alle algemene stringbewerkingen uit te voeren. In boost kun je gewoon de boost::algorithm::contains:

#include <string>
#include <boost/algorithm/string.hpp>
int main() {
    std::string s("gengjiawen");
    std::string t("geng");
    bool b = boost::algorithm::contains(s, t);
    std::cout << b << std::endl;
    return 0;
}

Antwoord 4, autoriteit 3%

Vanaf C++23 kun je std::string::contains gebruiken

#include <string>
const auto haystack = std::string("haystack with needles");
const auto needle = std::string("needle");
if (haystack.contains(needle))
{
    // found!
}

Antwoord 5, autoriteit 2%

Je kunt dit proberen

string s1 = "Hello";
string s2 = "el";
if(strstr(s1.c_str(),s2.c_str()))
{
   cout << " S1 Contains S2";
}

Antwoord 6

In het geval dat de functionaliteit van cruciaal belang is voor uw systeem, is het nuttig om een ​​oude strstr-methode te gebruiken. De std::searchmethode binnen het algorithmis de langzaamst mogelijke. Ik vermoed dat het veel tijd kost om die iterators te maken.

De code die ik heb gebruikt om het hele ding te timen is

#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <random>
#include <chrono>
std::string randomString( size_t len );
int main(int argc, char* argv[])
{
        using namespace std::chrono;
        const size_t haystacksCount = 200000;
        std::string haystacks[haystacksCount];
        std::string needle = "hello";
        bool sink = true;
        high_resolution_clock::time_point start, end;
        duration<double> timespan;
        int sizes[10] = { 10, 20, 40, 80, 160, 320, 640, 1280, 5120, 10240 };
        for(int s=0; s<10; ++s)
        {
                std::cout << std::endl << "Generating " << haystacksCount << " random haystacks of size " << sizes[s] << std::endl;
                for(size_t i=0; i<haystacksCount; ++i)
                {
                        haystacks[i] = randomString(sizes[s]);
                }
                std::cout << "Starting std::string.find approach" << std::endl;
                start = high_resolution_clock::now();
                for(size_t i=0; i<haystacksCount; ++i)
                {
                        if(haystacks[i].find(needle) != std::string::npos)
                        {
                                sink = !sink; // useless action
                        }
                }
                end = high_resolution_clock::now();
                timespan = duration_cast<duration<double>>(end-start);
                std::cout << "Processing of " << haystacksCount << " elements took " << timespan.count() << " seconds." << std::endl;
                std::cout << "Starting strstr approach" << std::endl;
                start = high_resolution_clock::now();
                for(size_t i=0; i<haystacksCount; ++i)
                {
                        if(strstr(haystacks[i].c_str(), needle.c_str()))
                        {
                                sink = !sink; // useless action
                        }
                }
                end = high_resolution_clock::now();
                timespan = duration_cast<duration<double>>(end-start);
                std::cout << "Processing of " << haystacksCount << " elements took " << timespan.count() << " seconds." << std::endl;
                std::cout << "Starting std::search approach" << std::endl;
                start = high_resolution_clock::now();
                for(size_t i=0; i<haystacksCount; ++i)
                {
                        if(std::search(haystacks[i].begin(), haystacks[i].end(), needle.begin(), needle.end()) != haystacks[i].end())
                        {
                                sink = !sink; // useless action
                        }
                }
                end = high_resolution_clock::now();
                timespan = duration_cast<duration<double>>(end-start);
                std::cout << "Processing of " << haystacksCount << " elements took " << timespan.count() << " seconds." << std::endl;
        }
        return 0;
}
std::string randomString( size_t len)
{
        static const char charset[] = "abcdefghijklmnopqrstuvwxyz";
        static const int charsetLen = sizeof(charset) - 1;
        static std::default_random_engine rng(std::random_device{}());
        static std::uniform_int_distribution<> dist(0, charsetLen);
        auto randChar = [charset, &dist, &rng]() -> char
        {
                return charset[ dist(rng) ];
        };
        std::string result(len, 0);
        std::generate_n(result.begin(), len, randChar);
        return result;
}

Hier genereer ik willekeurige haystacksen zoek daarin de needle. Het aantal hooibergen is ingesteld, maar de lengte van de snaren binnen elke hooiberg wordt verhoogd van 10 aan het begin tot 10240 aan het einde. Meestal besteedt het programma eigenlijk aan het genereren van willekeurige strings, maar dat is te verwachten.

De uitvoer is:

Generating 200000 random haystacks of size 10
Starting std::string.find approach
Processing of 200000 elements took 0.00358503 seconds.
Starting strstr approach
Processing of 200000 elements took 0.0022727 seconds.
Starting std::search approach
Processing of 200000 elements took 0.0346258 seconds.
Generating 200000 random haystacks of size 20
Starting std::string.find approach
Processing of 200000 elements took 0.00480959 seconds.
Starting strstr approach
Processing of 200000 elements took 0.00236199 seconds.
Starting std::search approach
Processing of 200000 elements took 0.0586416 seconds.
Generating 200000 random haystacks of size 40
Starting std::string.find approach
Processing of 200000 elements took 0.0082571 seconds.
Starting strstr approach
Processing of 200000 elements took 0.00341435 seconds.
Starting std::search approach
Processing of 200000 elements took 0.0952996 seconds.
Generating 200000 random haystacks of size 80
Starting std::string.find approach
Processing of 200000 elements took 0.0148288 seconds.
Starting strstr approach
Processing of 200000 elements took 0.00399263 seconds.
Starting std::search approach
Processing of 200000 elements took 0.175945 seconds.
Generating 200000 random haystacks of size 160
Starting std::string.find approach
Processing of 200000 elements took 0.0293496 seconds.
Starting strstr approach
Processing of 200000 elements took 0.00504251 seconds.
Starting std::search approach
Processing of 200000 elements took 0.343452 seconds.
Generating 200000 random haystacks of size 320
Starting std::string.find approach
Processing of 200000 elements took 0.0522893 seconds.
Starting strstr approach
Processing of 200000 elements took 0.00850485 seconds.
Starting std::search approach
Processing of 200000 elements took 0.64133 seconds.
Generating 200000 random haystacks of size 640
Starting std::string.find approach
Processing of 200000 elements took 0.102082 seconds.
Starting strstr approach
Processing of 200000 elements took 0.00925799 seconds.
Starting std::search approach
Processing of 200000 elements took 1.26321 seconds.
Generating 200000 random haystacks of size 1280
Starting std::string.find approach
Processing of 200000 elements took 0.208057 seconds.
Starting strstr approach
Processing of 200000 elements took 0.0105039 seconds.
Starting std::search approach
Processing of 200000 elements took 2.57404 seconds.
Generating 200000 random haystacks of size 5120
Starting std::string.find approach
Processing of 200000 elements took 0.798496 seconds.
Starting strstr approach
Processing of 200000 elements took 0.0137969 seconds.
Starting std::search approach
Processing of 200000 elements took 10.3573 seconds.
Generating 200000 random haystacks of size 10240
Starting std::string.find approach
Processing of 200000 elements took 1.58171 seconds.
Starting strstr approach
Processing of 200000 elements took 0.0143111 seconds.
Starting std::search approach
Processing of 200000 elements took 20.4163 seconds.

Antwoord 7

Als de tekenreeksen relatief groot zijn (honderden bytes of meer) en c++17 beschikbaar is, kunt u de Boyer-Moore-Horspool-zoeker gebruiken (voorbeeld van cppreference.com):

#include <iostream>
#include <string>
#include <algorithm>
#include <functional>
int main()
{
    std::string in = "Lorem ipsum dolor sit amet, consectetur adipiscing elit,"
                     " sed do eiusmod tempor incididunt ut labore et dolore magna aliqua";
    std::string needle = "pisci";
    auto it = std::search(in.begin(), in.end(),
                   std::boyer_moore_searcher(
                       needle.begin(), needle.end()));
    if(it != in.end())
        std::cout << "The string " << needle << " found at offset "
                  << it - in.begin() << '\n';
    else
        std::cout << "The string " << needle << " not found\n";
}

Antwoord 8

Als u geen standaard bibliotheekfuncties wilt gebruiken, vindt u hieronder een oplossing.

#include <iostream>
#include <string>
bool CheckSubstring(std::string firstString, std::string secondString){
    if(secondString.size() > firstString.size())
        return false;
    for (int i = 0; i < firstString.size(); i++){
        int j = 0;
        // If the first characters match
        if(firstString[i] == secondString[j]){
            int k = i;
            while (firstString[i] == secondString[j] && j < secondString.size()){
                j++;
                i++;
            }
            if (j == secondString.size())
                return true;
            else // Re-initialize i to its original value
                i = k;
        }
    }
    return false;
}
int main(){
    std::string firstString, secondString;
    std::cout << "Enter first string:";
    std::getline(std::cin, firstString);
    std::cout << "Enter second string:";
    std::getline(std::cin, secondString);
    if(CheckSubstring(firstString, secondString))
        std::cout << "Second string is a substring of the frist string.\n";
    else
        std::cout << "Second string is not a substring of the first string.\n";
    return 0;
}

Antwoord 9

#include <algorithm>        // std::search
#include <string>
using std::search; using std::count; using std::string;
int main() {
    string mystring = "The needle in the haystack";
    string str = "needle";
    string::const_iterator it;
    it = search(mystring.begin(), mystring.end(), 
                str.begin(), str.end()) != mystring.end();
    // if string is found... returns iterator to str's first element in mystring
    // if string is not found... returns iterator to mystring.end()
if (it != mystring.end())
    // string is found
else
    // not found
return 0;
}

Antwoord 10

Van zoveel antwoorden op deze website vond ik geen duidelijk antwoord, dus in 5-10 minuten vond ik het antwoord zelf.
Maar dit kan in twee gevallen:

  1. Ofwel u WEETde positie van de subtekenreeks waarnaar u zoekt in de tekenreeks
  2. Ofwel u weet nietde positie en zoekt ernaar, teken voor teken…

Dus, laten we aannemen dat we zoeken naar de substring “cd” in de string “abcde”, en we gebruiken de eenvoudigste substringebouwde functie in C++

voor 1:

#include <iostream>
#include <string>
    using namespace std;
int i;
int main()
{
    string a = "abcde";
    string b = a.substr(2,2);    // 2 will be c. Why? because we start counting from 0 in a string, not from 1.
    cout << "substring of a is: " << b << endl;
    return 0;
}

voor 2:

#include <iostream>
#include <string>
using namespace std;
int i;
int main()
{
    string a = "abcde";
    for (i=0;i<a.length(); i++)
    {
        if (a.substr(i,2) == "cd")
        {
        cout << "substring of a is: " << a.substr(i,2) << endl;    // i will iterate from 0 to 5 and will display the substring only when the condition is fullfilled 
        }
    }
    return 0;
}

Antwoord 11

Dit is een eenvoudige functie

bool find(string line, string sWord)
{
    bool flag = false;
    int index = 0, i, helper = 0;
    for (i = 0; i < line.size(); i++)
    {
        if (sWord.at(index) == line.at(i))
        {
            if (flag == false)
            {
                flag = true;
                helper = i;
            }
            index++;
        }
        else
        {
            flag = false;
            index = 0;
        }
        if (index == sWord.size())
        {
            break;
        }
    }
    if ((i+1-helper) == index)
    {
        return true;
    }
    return false;
}

Antwoord 12

U kunt ook de systeemnaamruimte gebruiken.
Dan kunt u de methode bevat gebruiken.

#include <iostream>
using namespace System;
int main(){
    String ^ wholeString = "My name is Malindu";
    if(wholeString->ToLower()->Contains("malindu")){
        std::cout<<"Found";
    }
    else{
        std::cout<<"Not Found";
    }
}

Antwoord 13

We kunnen in plaats daarvan deze methode gebruiken.
Even een voorbeeld uit mijn projecten.
Raadpleeg de code.
Sommige extra’s zijn ook inbegrepen.

Kijk naar de if-statements!

/*
Every C++ program should have an entry point. Usually, this is the main function.
Every C++ Statement ends with a ';' (semi-colon)
But, pre-processor statements do not have ';'s at end.
Also, every console program can be ended using "cin.get();" statement, so that the console won't exit instantly.
*/
#include <string>
#include <bits/stdc++.h> //Can Use instead of iostream. Also should be included to use the transform function.
using namespace std;
int main(){ //The main function. This runs first in every program.
    string input;
    while(input!="exit"){
        cin>>input;
        transform(input.begin(),input.end(),input.begin(),::tolower); //Converts to lowercase.
        if(input.find("name") != std::string::npos){ //Gets a boolean value regarding the availability of the said text.
            cout<<"My Name is AI \n";
        }
        if(input.find("age") != std::string::npos){
            cout<<"My Age is 2 minutes \n";
        }
    }
}

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Other episodes