How to omit string change when two vowels are next to eachother

I am trying to write a code that makes use of the language Oppengloppish by adding "opp" before each vowel in an English word. This is the code that I currently have written but I am having trouble with one thing:

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

bool is_vowel(char c)
{
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
using namespace std;
int main()
{
    const string vowel_postfix = "opp";
    string word, oword;
    cin >> word;
    auto vowel_count = count_if(word.begin(), word.end(), is_vowel);
    oword.reserve(word.length() + vowel_count * 2);
    for (char c : word) {
        oword.push_back(c);
        if (is_vowel(c))
            oword.insert(oword.length() -1, vowel_postfix);
    }
    cout << oword << std::endl;
}

I would like to try to omit "opp" from being added when there is a grouping of vowels but still have it added to only the first vowel.

Example: score-> scopporoppe

Expected behavior: team-> toppeam
Current behavior: team-> toppeoppam

It is not clear where you want to add the word (before or after the first vowel in the vowels group). In any case, what you are looking for is the transition from a consonant to a vowel. You need to remember the previous letter and see if it is a consonant and if the current letter is a vowel. The following code adds the word before the first vowel (demo):

char prev = 'b'; // must be initialized to an arbitrary consonant, otherwise if the first letter is a vowel, it won't be detected.
for (char c : word)
{
  if (!is_vowel(prev) && is_vowel(c))
    oword += "opp"; // transition detected
  oword += prev = c;
}

A less intuitive solution would be to test the last letter added to the output word:

for (char c : word)
{
  if (is_vowel(c) && (oword.empty() || !is_vowel(oword.back())))
    oword += "opp";
  oword += c;
}

Note that you should also test capital letters.

You could:

• walk the input string.
• creating an output string along the way.
• keeping count if the previous character was a vowel or not.
• in case the previous character was not a vowel, and the current one is, add oop to the output string.
• always add the current character to the output string.

[Demo]

#include <fmt/core.h>
#include <string>
#include <string_view>

std::string insert_opp(std::string_view text) {
    auto is_vowel = [](char c) {
        static std::string_view vowels{ "aeiouAEIOU" };
        return vowels.contains(c);
    };
    std::string ret{};
    bool is_vowel_previous_c{ false };
    for (auto c : text) {
        auto is_vowel_c{ is_vowel(c) };
        if (!is_vowel_previous_c && is_vowel_c) {
            ret += "oop";
        }
        ret += c;
        is_vowel_previous_c = is_vowel_c;
    }
    return ret;
}

int main() {
    for (auto& text : { "team", "score", "aeiou", "" }) {
        fmt::print("'{}' -> '{}'\n", text, insert_opp(text));
    }
}

// Outputs:
//
// 'team' -> 'toopeam'
// 'score' -> 'scooporoope'
// 'aeiou' -> 'oopaeiou'
// '' -> ''

This problem can easily be solved using a regex replacement. First create a regex that captures 1 or more consecutive vowels:

std::regex vowels{"([aeiou]+)"};

and then replace all occurrences of this pattern with "opp" followed by the pattern itself (which is denoted by $1):

auto oword = std::regex_replace(word, vowels, "opp$1");

Here's a demo.