Afficher le nombre de fois que se repete une sous-chaine dans une chaine

Programme permettant de compter le nombre de fois que se répète un sous-ensemble dans un ensemble.

Voici le code :

#include <iostream>
#include <string>
#include <algorithm>

int main ()
{
    std::string const sentence { "La beaute de son visage se refletait sur son monde a elle,\net son Seigneur lui fait dons d'une beaute sans egale que nulle\nne peut s'empecher de la jalouser farouchement. Cette beaute qui fut\na l'origine de la creation divine." };
    std::string const subset { "beau" };

    long int distance { std::distance(std::begin(subset), std::end(subset)) };
    int count_subset { 0 };

    auto it_begin_sentence { std::begin(sentence) };
    auto iterator { std::search(it_begin_sentence, std::end(sentence), std::begin(subset), std::end(subset)) };

    while (iterator != std::end(sentence))
    {
        ++count_subset;
        iterator += distance;
        std::cout << *iterator << '\n'; // pour voire l'element sur lequel pointe iterator a chaque tour de boucle
        it_begin_sentence = iterator;
        iterator = std::search(it_begin_sentence, std::end(sentence), std::begin(subset), std::end(subset));
    }

    std::cout << count_subset << '\n';
    return 0;
} 

Bonjour,

Quel est le problème ?
En l’état, ton message s’apparente à du spam.

Rien à voir avec le sujet mais « ce » devrait s’écrire « se ». C’est toujours le cas de devant un verbe.

Je ne m’y connais pas tellement en C donc je laisse d’autres répondre .

Mon intention c’était d’avoir des suggestions ou bien savoir s’il existe une fonction ou algorithme de la bibliothèque qui fait la même chose, et autre chose qui m’échappe car j’ai l’impression que ce que je fais est correcte ainsi il se peut que des mauvaises habitudes m’accompagnent.

J’espère que vous avez compris la ou je veux en venir… Je n’avais pas l’intention de faire du spam, je masque tout de même si aucune remarque n’est faite. Merci

En ce qui concerne les erreurs (oui c’est tjr un se devant le verbe : merci), j’en prends note et je l’ai corrige…

Comme dans « ce faisant » ou « quoi que ce soit » ?

J’ai simplifié pour plus de facilité. Il y en en effet des cas où, « ce » peut se placer devant un verbe.

Sachant que l’algorithme Boyer-Moore est disponible dans la bibliothèque standard.

Au debut je comptais sauter la sous-chaine rechercher mais je me rends compte mtn que c’était maladroite de ma part. De plus que si la sous-chaine rechercher se trouve a la fin de la sequence (texte sur lequel la recherche est effectuee), iterator pointe sur un espace virtuel apres iterator += distance; et std::search effectue son traitement dans cet espace. Ce qui n’est pas logique du tout et peut provoquer un comportement indetermine dans mon programme. Bref grace a vous, j’ai compris ceci en faisant un petit retour en arriere.

Pas pris en compte le chevauchement de la sous-sequence. OUI iterator += 1; c’est bien plus mieux.

Ravi de prendre connaissance de l’algorithme de Boyer Moore et pour la définition d’un ensemble (j’en prends note). Bref merci a vous 2.

J’avais lu quelques part que '\n' est plus optimise que std::endl…

En ce qui concerne l’utilisation de la boucle for, j’ai reecrit le code comme ci-dessous mais il y a plus de ligne qu’avant, donc je crois que j’ai mal choisit les 3 parametres de for :

#include <iostream>
#include <string>
#include <algorithm>

int main ()
{
    std::string const string { "Elle est belle." };
    std::string const substring { "beau" };

    bool no_enter_loop { true };

    auto it_begin_string { std::begin(string) };
    auto iterator { std::search(it_begin_string, std::end(string), std::begin(substring), std::end(substring)) };

    for (int count_substring { 1 }; iterator != std::end(string); ++count_substring)
    {
        no_enter_loop = false; // Si je rentre dans la boucle
        iterator += 1;
        std::cout << *iterator << std::endl; // pour voir l'element sur lequel iterator pointe a chaque tour de boucle
        it_begin_string = iterator;
        iterator = std::search(it_begin_string, std::end(string), std::begin(substring), std::end(substring));

        if (iterator == std::end(string)) // juste avant la sortie de la boucle
        {
            std::cout << substring << " Se repete " << count_substring << " fois." << std::endl;
        }
    }

    if (no_enter_loop) // si je ne rentre pas dans la boucle
    {
        std::cout << substring << " Se repete " << 0 << " fois." << std::endl;
    }
    return 0;
}

Il me semble que '\n' et std::endl ne sont pas tout à fait pareils, même sous linux.

Sauf erreur, std::endl effectue un saut de ligne puis appelle flush. Ce qui est en effet plus lent, mais on a au moins la certitude que le résultat sera bien affiché, même si le programme plante juste après.