C ++ stringstream parsing - c ++, stringstream

Estoy tratando de leer una entrada de usuario válida desde el símbolo del sistema:

por ejemplo, la entrada de usuario válida está en el siguiente formato:

getData <>

<> - cualquier valor de tipo de cadena

en el símbolo del sistema:

mi.g getData name => Correct (solo se ingresó un parámetro después de getData como se esperaba) por ejemplo, ID de getData => InCorrect (más de un parámetro ingresado después de getData) por ejemplo, getData => InCorrect (debido a que no se ingresó ningún parámetro después de getData)

¿Cómo verifico el número de parámetros? Mi código lógico es el siguiente:

string cmd_input;

getline(cin, cmd_input)

stringstream ss(cmd_input);

string input;
string parameter;

ss >> input; //getData
ss >> parameter; //name

¿Cómo hago para la verificación válida / inválida? No quiero ejecutarlo a través del bucle hasta el flujo de EOF y contar el número de parámetros. Leí en peek () y no estoy seguro de cómo encaja aquí. Además, no quiero usar vectores para almacenar parámetros.

¡Gracias!

Respuestas

1 para la respuesta № 1

Puede verificar el estado del flujo en sí mismo después de recuperar la entrada. Si la recuperación tuvo éxito, será true. Quieres que vuelva true despues de dos recuperaciones, pero se false en el tercero.

if (!(ss >> input1) || input1 != "getData") { //... error : unexpected cmd
}
if (!(ss >> input2)) { //... error: no param
}
if (ss >> input3) { //... error: too many params
}
//... okay

---

1 para la respuesta № 2

Con la restricción de no usar bucles y ni siquiera std::vector, podría verse de la siguiente manera:

std::string line, command, arg1, arg2, arg3;

if (std::getline(std::cin, line)) {

std::istringstream is(line);
if (is >> command) {
std::string word;
if (is >> arg1) {
...
if (is >> arg2) {
...
if (is >> arg3) {
...
}
}
}
} // end of is >> command
}

---

Sin embargo, si cambias de opinión y decides utilizar std::vector, podría verse así:

std::string line, command;
std::vector<std::string> arguments;

if (std::getline(std::cin, line)) {

std::istringstream is(line);
if (is >> command) {
std::string word;
while (is >> word)
arguments.push_back(word);
}
}

---

0 para la respuesta № 3

ss >> input;
if( ss.eof() )
//no parameter code
else
{
ss >> param;
if( !ss.eof() )
// too many param code
else
// good input
}

---

0 para la respuesta № 4

Aquí hay un simple programa de prueba de lectura. commands. Si el command es getData se extrae un argumento y, si esto tiene éxito, se omite cualquier espacio en blanco al final. En este punto, se espera que la corriente que analiza la línea haya llegado a su fin, es decir, eof() necesita ser configurado:

#include <iostream>
#include <sstream>
#include <string>

int main()
{
for (std::string line; std::getline(std::cin, line); ) {
std::istringstream in(line);
std::string command, name;
if (in >> command) {
if (command == "getData" && in >> name && (in >> std::ws).eof()) {
std::cout << "getData: read one argument: "" << name << "n";
}
else {
std::cout << "wrong format on line "" << line << ""n";
}
}
}
}

---