suma - Una forma sencilla de dividir una secuencia de cadenas separadas por nulos en C++

programa que sume reste multiplique y divida en c++

Question

Tengo una serie de cadenas almacenadas en una sola matriz, separadas por nulos (por ejemplo, [''f'', ''o'', ''o'', ''/ 0'', ''b'', ''a'', ''r'', ''/ 0 ''...]), y necesito dividir esto en un std::vector<std::string> o similar.

Podría escribir un bucle de 10 líneas para hacer esto usando std::find o strlen (de hecho, acabo de hacerlo), pero me pregunto si hay una forma más simple / elegante de hacerlo, por ejemplo, algún algoritmo STL. Lo he pasado por alto, lo que puede ser persuadido para hacer esto.

Es una tarea bastante simple, y no me sorprendería si hubiera algún truco STL inteligente que se pueda aplicar para hacerlo aún más simple.

¿Ningún arrendatario?

Answer 1

Aquí está la solución que se me ocurrió, asumiendo que el búfer termina inmediatamente después de la última cadena:

std::vector<std::string> split(const std::vector<char>& buf) {
auto cur = buf.begin();
while (cur != buf.end()) {
auto next = std::find(cur, buf.end(), ''/0'');
drives.push_back(std::string(cur, next));
cur = next + 1;
}
return drives;
}

Answer 2

En C, string.h tiene este chico:

char * strtok ( char * str, const char * delimiters );

el ejemplo en cplusplus.com:

/* strtok example */
#include <stdio.h>
#include <string.h>
int main ()
{
char str[] ="- This, a sample string.";
char * pch;
printf ("Splitting string /"%s/" into tokens:/n",str);
pch = strtok (str," ,.-");
while (pch != NULL)
{
printf ("%s/n",pch);
pch = strtok (NULL, " ,.-");
}
return 0;
}

No es C ++, pero funcionará.

Answer 3

Lo siguiente se basa en std::string tiene un constructor implícito que toma un const char* , lo que hace que el bucle sea un sistema de dos líneas muy simple:

#include <iostream>
#include <string>
#include <vector>
template< std::size_t N >
std::vector<std::string> split_buffer(const char (&buf)[N])
{
std::vector<std::string> result;
for(const char* p=buf; p!=buf+sizeof(buf); p+=result.back().size()+1)
result.push_back(p);
return result;
}
int main()
{
std::vector<std::string> test = split_buffer("wrgl/0brgl/0frgl/0srgl/0zrgl");
for (auto it = test.begin(); it != test.end(); ++it)
std::cout << ''"'' << *it << "/"/n";
return 0;
}

Esta solución supone que el tamaño del búfer es conocido y el criterio para el final de la lista de cadenas. Si la lista termina en "/0/0" , la condición en el bucle debe cambiarse de p!=foo+sizeof(foo) a *p .

Answer 4

Mis dos centavos :

const char* p = str;
std::vector<std::string> vector;
do {
vector.push_back(std::string(p));
p += vector.back().size() + 1;
} while ( // whatever condition applies );

Answer 5

Solución de impulso:

#include <boost/algorithm/string.hpp>
std::vector<std::string> strs;
//input_array must be a Range containing the input.
boost::split(
strs,
input_array,
boost::is_any_of(boost::as_array("/0")));

Answer 6

Una mala respuesta, en realidad, pero dudé de su reclamo de un bucle de 10 líneas para la división manual. 4 líneas lo hacen por mí:

#include <vector>
#include <iostream>
int main() {
using std::vector;
const char foo[] = "meh/0heh/0foo/0bar/0frob";
vector<vector<char> > strings(1);
for (const char *it=foo, *end=foo+sizeof(foo); it!=end; ++it) {
strings.back().push_back(*it);
if (*it == ''/0'') strings.push_back(vector<char>());
}
std::cout << "number of strings: " << strings.size() << ''/n'';
for (vector<vector<char> >::iterator it=strings.begin(), end=strings.end();
it!=end; ++it)
std::cout << it->data() << ''/n'';
}

Answer 7

Una solución más elegante y real (en comparación con mi otra respuesta) utiliza getline y se reduce a 2 líneas con solo C ++ 2003, y no se requiere una contabilidad y acondicionamiento de bucles manuales:

#include <iostream>
#include <sstream>
#include <string>
int main() {
const char foo[] = "meh/0heh/0foo/0bar/0frob";
std::istringstream ss (std::string(foo, foo + sizeof foo));
std::string str;
while (getline (ss, str, ''/0''))
std::cout << str << ''/n'';
}

Sin embargo, tenga en cuenta que el constructor de cadenas basado en rango ya indica un problema inherente con la división en - ''/ 0''s: debe saber el tamaño exacto, o encontrar otro char-combo para el Ultimate Terminator.