Q:

¿Cómo separar las palabras que contiene un string en C++? 'Split '

¿Cuál es la forma más eficiente de separar un string en c++? como el que se muestra en el código, el cual contiene espacios entre las palabras, este es el método que yo estoy usando actualmente.
#include <iostream>
#include <sstream>

int main(int argc, char** argv){

    std::string str("Texto para dividir");
    std::istringstream isstream(str);

    while(!isstream.eof()){

        std::string tempStr;

        isstream >> tempStr;

        std::cout << tempStr << std::endl;
    }

    return 0;
}

A:

Lo de elegancia es algo difícil de decir, es cuestión de gustos. Pero la legibilidad del código siempre es importante. Por eso, este código se puede simplificar así: (a mi me parece más legible)
std::string tempStr;
while(isstream >> tempStr) {
    std::cout << tempStr << std::endl;
}

Con lo cual, metiendo todo en una función quedaría algo así:
std::vector<std::string> split_istringstream(std::string str) {
    std::vector<std::string> resultado;
    std::istringstream isstream(str);
    std::string palabra;

    while(isstream >> palabra){
        resultado.push_back(palabra);
    }

    return resultado;
}

Otra alternativa, que incluso permite definir el delimitador (el operador >> de istringstream solo divide la cadena por los espacios - ASCII 32) es utilizar std::getline. 
std::vector<std::string> split_getline(std::string str, char delim) {
    std::vector<std::string> resultado;
    std::istringstream isstream(str);
    std::string palabra;

    while(std::getline(isstream, palabra, delim)){
        resultado.push_back(palabra);
    }

    return resultado;
}

Aquí abajo te dejo una comparativa entre ambas opciones, son prácticamente iguales en eficiencia, dejando de un lado los vectores, reservan prácticamente la misma memoria.
http://cpp.sh/3jtw

A:

Normalmente lo eficiente y lo bonito no suelen ir dados de la mano. El código bonito suele tener código excesivo (al menos 'por detrás'), pero en ese caso lo que prima es la legibilidad del código... cuando se persigue la eficiencia lo que se acaba consiguiendo es código menos legible... pero más eficiente (en esto habría que especificiar si la eficiencia se refiere a velocidad de ejecución o a consumo de memoria).
Bueno, ya te han puesto códigos bonitos yo te pongo uno que tira por la vía de la rapidez. ¿Cómo de rápido? pues más o menos un 30%-40% más rápido que la opción del istringstream........ claro que el código ya no queda tan bonito:
std::vector<std::string>
split_iterator(const std::string& str)
{
  std::vector<std::string> resultado;

  std::string::const_iterator itBegin = str.begin();
  std::string::const_iterator itEnd   = str.end();

  int numItems = 1;
  for( std::string::const_iterator it = itBegin; it!=itEnd; ++it )
    numItems += *it==' ';

  resultado.reserve(numItems);

  for( std::string::const_iterator it = itBegin; it!=itEnd; ++it )
  {
    if( *it == ' ' )
    {
      resultado.push_back(std::string(itBegin,it));
      itBegin = it+1;
    }
  }

  if( itBegin != itEnd )
    resultado.push_back(std::string(itBegin,itEnd));

  return resultado;
}

En este caso uso iteradores, lo que evita el sobrecoste de crear y llamar a los métodos istringstream. Además como optimización adicional, antes de separar el string precalculo el número total de elementos. De esta forma evito que el vector tenga que llamar a realloc continuamente.
Un saludo

A:

Usando la clase iterator
#include <iterator>
#include <iostream>
#include <string>
#include <sstream>

int main() {
    using namespace std;
    string s = "Texto para dividir";
    istringstream iss(s);
    copy(istream_iterator<string>(iss),
         istream_iterator<string>(),
         ostream_iterator<string>(cout, "\n"));
}

se tendrá por ejemplo la salida:
Texto
para
dividir

Ver ejemplo online!

