[C++] std::string split di una linea in tre parti

[gianvituzzi]

Salve,

volevo sapere come potevo fare per dividere una stringa in tre parti, inpraticafacendo uno split(" ", line, 3)

#include <string>
#include <iostream>

struct reqline
{
	const char *method;
	const char *uri;
	const char *vprot;
	reqline() : method(""), uri(""), vprot("") {}
};

bool splitReqLine(std::string const & line, reqline &rl);

int main()
{
	std::string line = "GET /index.html HTTP/1.1";
	reqline rl;

	if( splitReqLine(line, rl) )
	{
		std::cout << "method: " << rq.method << std::endl;
		std::cout << "uri: " << rq.uri << std::endl;
		std::cout << "vport: " << rq.vprot << std::endl;
	}
	return 0;
}

bool splitReqLine(std::string const & line, reqline &rl)
{

	// ...code here...

	return true;
}

la linea sarà sempre composta da: "caratteri/spazio/caratteri/spazio/caratteri"...

come si fa lo split con std::string??

grazie

[Stoicenko]

si usa la strtok

[antotan]

Se vuoi usare i metodi della classe string, devi lavorare con i metodi find per trovare i delimitatori e con la substr per estrarre i token.
Altrimenti puoi usare la strkot, come ti è stato suggerito, in una maniera simile:

std::vector<std::string> split(const std::string& str, const char* delim){
    std::vector<std::string> vs;    
    char* token;
    token = strtok((char*)str.c_str(), delim);
    while (token != NULL){
        vs.push_back(std::string(token));        
        token = strtok(NULL, delim);
    }
    
    return vs;
} 

[gianvituzzi]

ti ringrazio! ora però vorrei fare una cosa più complessa...vorrei evitare di chiamare il metodo che poi riempe la struttura, ma bensi un costruttore che faccia tutto da solo, ovvero:

	struct reqline
	{
		const std::string method;
		const std::string uri;
		const std::string vprot;
		reqline(std::string const & line); // costruttore
	};

così che possa fare:

std::string line = "GET /index.html HTTP/1.1";
reqline rl(line);

// rl.method -> GET
// rl.uri -> /index.html
// vprot -> HTTP/1.1

purtroppo però non riesco a fare una cosa del genere definendo questo costruttore:

	reqline::reqline(const std::string &line)
	{
		std::vector<std::string> vs;
		char* token;
		const char* delim = " ";
		token=strtok((char*)line.c_str(), delim);

		while (token != NULL)
		{
			vs.push_back(std::string(token));
			token = strtok(NULL, delim);
		}

		method = vs[0];
		uri = vs[1];
		vprot = vs[2];

	}

in pratica non mi va l'assegnazione, però credevo che a run time si potesse assegnare un valore ad una costante in un costruttore :-(

[gianvituzzi]

da notare che tutto questo ambaradam è all'interno di un namespace

mylib.h

#define _CRT_SECURE_NO_WARNINGS
#include <string>
#include <vector>

namespace mylib
{
	struct reqline
	{
		const std::string method;
		const std::string uri;
		const std::string vprot;
		reqline();
		reqline(std::string const & line);
	};

}

mylib.cpp

#include "mylib.h"

namespace mylib
{
	// reqline
	reqline::reqline() : method(""), uri(""), vprot("") {}
	reqline::reqline(const std::string & line)
	{
		std::vector<std::string> vs;
		char* token;
		const char* delim = " ";
		token=strtok((char*)line.c_str(), delim);

		while (token != NULL)
		{
			vs.push_back(std::string(token));
			token = strtok(NULL, delim);
		}

		method = vs[0];
		uri    = vs[1];
		vprot  = vs[2];

	}
}

ma non credo che la cosa influenzi affatto il comportamento anomalo...

da main() mi piacerebbe richiamarlo così:

#include <string>
#include "mylib.h"
using namespace mylib;

int main()
{
	std::string line = "GET /index.html HTTP/1.1";
	reqline rl(line);
	(...)
	return 0;
}

Per me è importante che i campi di quella struttura siano readonly...

grazie

[Stoicenko]

ti conviene fare i campi struttura privati e non costanti..

per accederci in lettura fai dei metodi che ritornano il valore

oppure, non so se funziona, usi un cast per togliere il const nel momento di essegnare..
ma credo che sia una scelta sbagliata

[gianvituzzi]

seli faccio privati poi mi tocca fare un mini metodo pubblico per tornarli...

[Stoicenko]

non credo tu abbia tante soluzioni per tenerli readonly

[gianvituzzi]

ho cambiato un pò il codice:

// mylib.h

	struct reqline
	{
	public:
		const std::string method;
		const std::string uri;
		const std::string vprot;
		reqline();
		reqline(std::string const & line);
	private:
		std::string getMethodFrom(const std::string & line) const;
		std::string getUriFrom(const std::string & line) const;
		std::string getVprotFrom(const std::string & line) const;
	};

// mylib.cpp

	reqline::reqline() : method(""), uri(""), vprot("") {}

	reqline::reqline(const std::string & line) : 
		method(getMethodFrom(line)),uri(getUriFrom(line)),vprot(getVprotFrom(line)) {}

	std::string reqline::getMethodFrom(const std::string & line) const
	{
		const std::string delim(" ");
		std::string::size_type first = 0;
		std::string::size_type last = line.find_first_of(delim, first);
		return line.substr(first, last);
	}

	std::string reqline::getUriFrom(const std::string & line) const
	{
		const std::string delim(" ");
		std::string::size_type first = 0;
		std::string::size_type last = line.find_first_of(delim, first);
		first = last + 1;
		last = line.find_first_of(delim, first);
		return line.substr(first, last);
	}

	std::string reqline::getVprotFrom(const std::string & line) const
	{
		const std::string delim(" ");
		std::string::size_type first = 0;
		std::string::size_type last = line.find_first_of(delim, first);
		first = last + 2;
		last = line.find_first_of(delim, first);
		return line.substr(first, last);
	}

nel main faccio:

//using namespace std;

line = "GET /wiki/Pagina_principale HTTP/1.1";
mylib::reqline rq(line);

cout << endl << endl;
cout << "method: " << rq.method << endl;
cout << "uri: " << rq.uri << endl;
cout << "vport: " << rq.vprot << endl;

soltanto che method viene splittao bene: GET
ma uri e vport ritornano la stessa riga // wiki/Pagina_principale HTT

lo split avviene quà:

		const std::string delim(" ");
		std::string::size_type first = 0;
		std::string::size_type last = line.find_first_of(delim, first);
		first = last + 1;
		last = line.find_first_of(delim, first);
		return line.substr(first, last);

[antotan]

Fondamentalmente ci sono due errori. Il metodo substr è questo

string substr ( size_t pos = 0, size_t n = npos ) const; 

Quindi se hai "ciao" e vuoi estrarre la 'a', devi scrivere:

a.substr(2,1); 

cioè parti dal carattere due e prelevi 1 carattere. Tu invece passi come secondo argomento il termine della stringa, da quanto ho capito.

Poi c'è un problema quando prelevi la versione del protocollo. Non capisco bene perchè scrivi first = last +2. Comunque il corpo delle get può essere questo:

std::string reqline::getMethodFrom(const std::string & line) const
{
    const std::string delim(" ");
    std::string::size_type first = 0;
    std::string::size_type last = line.find_first_of(delim, first);
    return line.substr(first, last-first); // nota last-first
}

std::string reqline::getUriFrom(const std::string & line) const
{
    const std::string delim(" ");
    std::string::size_type first = 0;
    std::string::size_type last = line.find_first_of(delim, first);    
    first = last + 1;    
    last = line.find_first_of(delim, first);    
    return line.substr(first, last-first); // nota last-first
}

std::string reqline::getVprotFrom(const std::string & line) const
{
    const std::string delim(" ");
    std::string::size_type first = 0;
    std::string::size_type last = line.find_first_of(delim, first);
    first = last + 1;
    last = line.find_first_of(delim, first);
    first = last + 1;
    return line.substr(first, last-first); // nota last-first
} 

Il secondo argomento della substr è last-first per indicare quanti caratteri prendere. L'ho fatto anche per getMethodFrom. In realtà first è 0 quindi last-first = last come avevi scritto, ma migliora la leggibilità.
Quando prelevi il protocollo salti al terzo campo, quindi applichi la logica della terza e quarta riga di getUriFrom due volte in sostanza.