C++ 从字符串中的每个轴获取 substring

Question

How can i acquire the value from each axis on a string?

#include <iostream>
#include <string>

using namespace std;

int main()
{
    string text = "X:-600.913 Y:100.54 Z:412.22";
    //do stuff
    string X; // must be -600.913
    string Y; // must be 100.54
    string Z; // must be 412.22
    //print individual values
    std::cout << X;
    std::cout << Y;
    std::cout << Z;
}

my previous attempt was

int main()
{
    string text = "X:-600.913 Y:100.54 Z:412.22";
    cin >> text;
    int Xsecond = text.find(" Y:");
    string X = text.substr(2, Xsecond - 4);
    int Yfirst = text.find("Y:");
    int Ysecond = text.find(" Z:");
    string Y = text.substr(Yfirst + 1, Ysecond-Yfirst - 1);
    cout << X;
}

which was too fuzzy and complicated and did not work at all. Any help would be appreciated!

Answer 1

#include <iostream>
#include <string>
int main()
{
    std::string text="X:-600.913 Y:100.54 Z:412.22";
    size_t colon=text.find(":");
    size_t space=text.find(" ");
    std::string X=text.substr(colon+1,space-colon-1);
    colon=text.find(":",colon+1);
    space=text.find(" ",space+1);
    std::string Y=text.substr(colon+1,space-colon-1);
    colon=text.find(":",colon+1);
    space=text.find(" ",space+1);
    std::string Z=text.substr(colon+1,space-colon-1);
    std::cout<<X<<std::endl<<Y<<std::endl<<Z;
}

After the first find , consecutive calls begin searching from the previous hit. We're subtracting 1 each time because we added it before and we need the distance. Simple math logic.

Answer 2

As mentioned in the comments, regular expressions work well for this kind of thing. Use the module regex . Like so:

#include <iostream>
#include <cstdlib>
#include <regex>

int main()
{
    const std::string s = "X:-600.913 Y:100.54 Z:412.22"; 
    std::smatch m;
    std::regex e(R"(X:(-?\d+\.\d+)\sY:(-?\d+\.\d+)\sZ:(-?\d+\.\d+))");
 
    if (std::regex_search(s, m, e))
        std::cout << "X:" << m[1] << " Y:" << m[2] << " Z:" << m[3] << std::endl;
}

X:-600.913 Y:100.54 Z:412.22

Answer 3

You can use regex. For example ([XYZ]):(-?[0-9]+(\.[0-9]+)?)

[XYZ] matches X , Y or Z

: matches :

-? matches - or empty string

[0-9]+ matches one or more characters from 0 - 9 range

(\.[0-9]+)? matches dot followed by [0-9]+ or empty

There are additional parentheses to make capture groups (we can access them with std::smatch[x] ).

std::string text = "X:-600.913 Y:100.54 Z:412.22";
 
std::regex regex("([XYZ]):(-?[0-9]+(\.[0-9]+)?)");

auto begin = std::sregex_iterator(text.begin(), text.end(), regex);
auto end = std::sregex_iterator();

for (std::sregex_iterator it = begin; it != end; it++)
{
    const std::smatch &match = *it;
    std::cout << match[1] << " is " << match[2] << std::endl;
}

The code above will simply output:

X is -600.913
Y is 100.54
Z is 412.22

Answer 4

find returns the index of the first char matching the string. Given the indices of the start of a substing iStart and the index past the end of the substing iEnd you can get the substing using value.substr(iStart, iEnd - iStart) .

Applying this to your strings (and hardcoding some of the lengths of the search strings) you could use the following code:

int main()
{
    std::string text = "X:-600.913 Y:100.54 Z:412.22";

    const size_t xStart = 0;
    const size_t yStart = text.find(" Y:");
    const size_t zStart = text.find(" Z:");

    std::string X = text.substr(2, yStart - 2);
    std::string Y = text.substr(yStart + 3, zStart - (yStart + 3));
    std::string Z = text.substr(zStart + 3); // assuming here there are no chars after the end of the last number

    std::cout << X << ", " << Y << ", " << Z;

    return 0;

}

Answer 5

As @snoopy mentioned in the comments, this problem is a good fit for regular expressions.

• A decent-looking tutorial on regular expressions in general , if you're unfamiliar.
• Regular expressions in the C++ standard library .

You could use one regular expression for X, one regular expression for Y, and one regular expression for Z, and use regex_search to search the input string for each one independently.

Or, you could combine X, Y, and Z into a single regular expression, use regex_match to match it against the whole input string at once, and then extract the parts from there .

@alex_noname's answer gives a specific implementation.

---

Alternatively, you could parse your input with more ad-hoc methods, like using .find() to split the string on colon ( : ) and space ( ) characters.

A disadvantage to these approaches is that you generally have to be more careful about handling wrongly-formatted input.

For example:

X: -600.913 Y: 100.54 Z: 412.22

This input has extra spaces, and may break a naive .find() -based parser in unintuitive ways, like apparently "succeeding" but reporting empty strings as the output.

On the other hand, regular expressions naturally tend to be stricter. If your input was formatted unexpectedly, regex_match() will helpfully return false , and you can handle the error accordingly.