Is there any way I could further optimize this program? [duplicate] - c++

Question

This question already has answers here:
read words from line in C++
(2 answers)
Right way to split an std::string into a vector<string>
(12 answers)
Closed 12 days ago.
I've been trying to learn how to optimize C++ in the context of low latency trading systems, and am wondering if this implementation could be improved. I would appreciate any insight, either specific or general.
// Code to add each word in string to vector
int main() {
std::string originalText = "Hello World!";
std::vector<std::string> words;
words.reserve(originalText.length()); // unsure if this could be more accurate
std::size_t wStart = 0;
std::size_t pos = originalText.find(" ");
while(pos != std::string::npos) {
words.emplace_back(&originalText[wStart], pos - wStart);
wStart = pos + 1;
pos = originalText.find(" ", wStart);
}
words.emplace_back(&originalText[wStart], originalText.size() - wStart);
return 0;
}

Answer 1

You still allocate and copy std::strings from the input that's not needed. You can use string_views. This is no way near optimized for a trading system though.
I still use a vector and the will reallocate while it grows.
When optimizing code there is two things, keep thinking/researching if there is another algorithm (that usually brings the biggest performance gain). Then keep profiling to find your (real) bottlenecks.
Anyway here is a split function that can split without making string copies and can split on multiple characters (you can still optimize that to only split on spaces if that is the only delimiter)
std::vector<std::string_view> split_string(std::string_view string, std::string_view delimiters)
{
std::vector<std::string_view> substrings;
if(delimiters.size() == 0ul)
{
substrings.emplace_back(string);
return substrings;
}
auto start_pos = string.find_first_not_of(delimiters);
auto end_pos = start_pos;
auto max_length = string.length();
while(start_pos < max_length)
{
end_pos = std::min(max_length, string.find_first_of(delimiters, start_pos));
if(end_pos != start_pos)
{
substrings.emplace_back(&string[start_pos], end_pos - start_pos);
start_pos = string.find_first_not_of(delimiters, end_pos);
}
}
return substrings;
}