C++字符串子串提取及GCode命令X/Y/Z参数数值提取问询

Hey there! Let's break down your two C++ tasks and find better solutions for that GCode parsing headache you're dealing with.

Extracting substrings in C++ is straightforward with the std::string class. Here are the most common scenarios:

By Fixed Position/Length #

Use the substr() method, which takes a starting index and optional length. If you omit the length, it grabs everything from the start index to the end of the string:

#include <string>
#include <iostream>

int main() {
    std::string full_str = "Sample: G1 X100 Y200";
    // Extract "G1 X100 Y200" (starts at index 7, takes remaining characters)
    std::string gcode_cmd = full_str.substr(7);
    std::cout << gcode_cmd << std::endl;

    // Extract just "X100" (starts at index 9, takes 4 characters)
    std::string x_param = full_str.substr(9, 4);
    std::cout << x_param << std::endl;
    return 0;
}

By Delimiters #

If you need to extract text between specific characters (like spaces or letters), combine find() with substr():

std::string line = "G0 Z-5.2";
size_t z_pos = line.find('Z');
if (z_pos != std::string::npos) {
    // Find the next space after Z (or end of string if none exists)
    size_t end_pos = line.find(' ', z_pos);
    if (end_pos == std::string::npos) end_pos = line.size();
    std::string z_val_str = line.substr(z_pos + 1, end_pos - z_pos - 1);
    double z_val = std::stod(z_val_str); // Convert string to numeric value
}

Your current approach of checking every combination of X/Y/Z with find() and substr() works, but it's repetitive and error-prone. Here are two cleaner, more maintainable solutions:

Option 1: Regular Expressions (C++11+) #

Regex is perfect for matching fixed-format strings like G0/G1 commands. It lets you validate the command and extract all parameters in one pass:

#include <string>
#include <regex>
#include <iostream>
#include <map>

void parse_g0g1(const std::string& line) {
    // Regex pattern: matches G0/G1, followed by optional X/Y/Z with numeric values
    // Supports positive/negative integers and decimals, ignores case (for g0/g1)
    std::regex gcode_pattern(R"(G(0|1)\s*(X(-?\d+(\.\d+)?)?)?\s*(Y(-?\d+(\.\d+)?)?)?\s*(Z(-?\d+(\.\d+)?)?)?)", std::regex::icase);
    std::smatch matches;

    if (std::regex_match(line, matches, gcode_pattern)) {
        std::map<char, double> params;

        // Extract X if present
        if (!matches[2].str().empty()) {
            params['X'] = std::stod(matches[3].str());
        }
        // Extract Y if present
        if (!matches[5].str().empty()) {
            params['Y'] = std::stod(matches[6].str());
        }
        // Extract Z if present
        if (!matches[8].str().empty()) {
            params['Z'] = std::stod(matches[9].str());
        }

        // Output results
        std::cout << "Parsed G" << matches[1].str() << " command:" << std::endl;
        for (const auto& [axis, value] : params) {
            std::cout << "  " << axis << ": " << value << std::endl;
        }
    } else {
        std::cout << "Skipping non-G0/G1 line: " << line << std::endl;
    }
}

int main() {
    parse_g0g1("G1 X123.45 Y-67 Z89");
    parse_g0g1("g0 X0 Y0"); // Works with lowercase
    parse_g0g1("G1 Z-10.5");
    parse_g0g1("G2 X50 Y50"); // Rejected (not G0/G1)
    return 0;
}

Why This Works: #

• The pattern validates that the line is a valid G0/G1 command first.
• It captures each axis's value directly, so you don't have to handle every possible combination of X/Y/Z manually.
• The icase flag handles lowercase g0/g1 commands automatically.

Option 2: String Stream Parsing (No Regex Needed) #

If you prefer to avoid regex (e.g., for older C++ standards), use std::istringstream to split the line into tokens and parse each one:

#include <string>
#include <sstream>
#include <iostream>
#include <map>
#include <cctype>

void parse_g0g1_stream(const std::string& line) {
    std::istringstream line_stream(line);
    std::string token;
    std::map<char, double> params;
    bool is_target_cmd = false;

    while (line_stream >> token) {
        if (token.empty()) continue;

        char first_char = toupper(token[0]);
        if (first_char == 'G') {
            // Check if this is G0 or G1
            if (token == "G0" || token == "G1" || token == "g0" || token == "g1") {
                is_target_cmd = true;
            } else {
                // Not a G0/G1 command, exit early
                is_target_cmd = false;
                break;
            }
        } else if (is_target_cmd && (first_char == 'X' || first_char == 'Y' || first_char == 'Z')) {
            // Extract the numeric value after the axis letter
            try {
                double value = std::stod(token.substr(1));
                params[first_char] = value;
            } catch (const std::invalid_argument& e) {
                std::cerr << "Invalid value for " << first_char << ": " << token.substr(1) << std::endl;
            }
        }
    }

    if (is_target_cmd) {
        std::cout << "Parsed parameters:" << std::endl;
        for (const auto& [axis, value] : params) {
            std::cout << "  " << axis << ": " << value << std::endl;
        }
    }
}

int main() {
    parse_g0g1_stream("G1 X123.45 Y-67 Z89");
    parse_g0g1_stream("G0 X0 Y0");
    parse_g0g1_stream("G1 Z-10.5");
    return 0;
}

Why This Works: #

• It splits the line into individual tokens (split by whitespace), so you can process each part independently.
• Once it confirms the line is a G0/G1 command, it checks each subsequent token for X/Y/Z axes and extracts their values.
• It’s flexible—you can easily extend it to handle other GCode parameters if needed.

Which Option Should You Choose? #

• Regex: Best if you want concise code and your GCode format is fixed. Requires C++11 or newer.
• String Stream: Better for older C++ environments or if you need to add more complex parsing logic later (like handling comments or other commands).

内容的提问来源于stack exchange，提问作者John T