Use the tools the library provides
You can greatly simplify your string manipulations by using std::string::replace, e.g.
std::string inside_parentheses{input.substr(idx_open_bracket+1, idx_close_bracket-idx_open_bracket-1)};
// perform operations inside parentheses ( )
parseMultDivMod(inside_pa...
I think string::replace() invalidates the iterators though? Other points taken. I think if I wrap each number in brackets as I suggest in a comment to the answer by @G.Sliepen, perhaps I can eliminate all edge cases and really really streamline the code to reflect the logic behind it in hi-fi. Also, isn't const std::string& == std::string_view?
@Giogre assigning over it also invalidates iterators, of which you have none. No, string view is a good replacement for const ref, particularly for taking substrings, as it doesn't copy
At the end of the loop, I use string.assign(new_string) which overwrites string with new content and deletes the old. Iterators are ready and working for the next iteration in the loop. If I were to use replace() to insert the parentheses result in the middle of the input string, I would break iterators for the next iteration
@Giogre You are not using any iterators. You take the index of a character after replacing content of input with assign. You can do the same, take the index of a character after replacing content of input with replace.
@Giogre What I'm suggesting is replacing everything from std::string plug_result{}; to input.assign(plug_result) with input.replace(...). I.e. the part where you replace part of input with something else
@Giogre I think you misunderstand what "invalidates iterators" means. When you have a std::string::iterator that points somewhere, and do something to the std::string that causes it to reallocate, that iterator no longer points anywhere. You can still assign a new iterator value to that, and it will then point to the new location. In the same way, your indexes no longer point to ( and ) when you replace the bracket with a number, but you don't use those indexes after that, you reassign them
Ok let's say the program replaces a single operation in parentheses inside the string with its result, so we remove 5 chars from the middle of the string and replace them with 1 char. What I knew is that iterators from the point of insertion forward, up to the end of the string are invalidated. You write about assigning new iterators: I take you intend the programmer has to manually do it, create an iterator object in a statement. Then, you can easily get to the end of the string as its contents are stored contiguously, but I am not sure about a complete (begin, end) string traversal
What invalidation means, is that if you have a char * pointing at some part of the string, operations on the string that reallocate can, as action-at-a-distance, make that pointer no longer point to a char
Any of the non-const members of std::string can do that, which makes all pointers, references and iterators to elements of the string invalid
And all of this doesn't matter, because you don't have any char *s, char &s or std::string::iterator objects in your loops
Yes. Which also stop pointing where they used to. Consider what happens when you evaluate 2*(3+4). You replace (3+4) with 7, so the index for ) is now off the end of the string.
Which doesn't matter, because you aren't using it anymore.
if I follow with find(input.begin(), input.end(), '7') will it work? I guess yes. Only a previously defined iterator auto my_iter{input[3]} will be left invalidated
Discussion between Caleth and Giogre
Discussion between Caleth and Giogre