Liste erzeugen...

Leute... Das Problem ist nicht das Splitten oder die Verwendung von std::string

Ich möchte NUR die Liste füllen und damit das jeder versteht habe ich noch dieses simple Beispiel drum rum gebaut...

David_pb

Ahja, was für eine Liste denn? Ein Array oder wie? Wenns C sein soll bist du definitiv im falschen Forum.

David_pb schrieb:

Ahja, was für eine Liste denn? Ein Array oder wie? Wenns C sein soll bist du definitiv im falschen Forum.

Ja! Wäre sinvoll meinen Code anzusehen:
"Ich habe dazu schon die Variabel Args angelegt..."
Ich bin eben davon ausgegangen, das die Leute sich hier noch mit new, und Arrays auskennen...

char **Args = NULL;

/*
Füllen?
*/

delete[] Args;

...

David_pb

Hilfeeee schrieb:

Ich bin eben davon ausgegangen, das die Leute sich hier noch mit new, und Arrays auskennen...

Bevor du weiterredest überleg mal Haarscharf ob new tatsächlich in dein gewünschtes Konzept "only C" passt...

Ihr versteht es nicht, oder? Die Schnitstelle soll in C sein. Wie das ganze erzeugt wird ist im Endeffekt egal! Ein Mehrfachaufwand von erst: Boost installieren mache ich mir hierfür aber auch nicht! Na ja vielleicht hatte mein Freund recht, dass ich lieber in einem anderen Forum fragen sollte....

David_pb

Ja solltest du evtl tun! Is ja schon unverschämt wie du hier Lösungen einforderst...

Vielleicht sollte ich mich für dieses Verhalten entschuldigen, jedoch war ich über die Antworten sehr verärgert, da ich davon ausgegangen bin, das mein Problem klar geschildert ist und ich um Antworten wie "dann brauchst du auch kein std::string benutzen" extra geschrieben hatte, das dies nur ein Beispiel ist. Da ich "new" benutzt habe, bin ich davon ausgegangen, dass ich ruhig im C++-Bereich fragen kann, da es schließlich auch Arrays in C++ gibt.

Ich wäre nun über eine Lösung meines Problems sehr dankbar und entschuldig emich nochmals für mein Verhalten.

Mit freundlichen Grüße,
Hilfeeee

Badestrand

Als erstes würde ich die Leerzeichen zählen, damit du weißt, wieviele Strings du brauchst (Leerzeichenanzahl+1).
Dann kannst du ja durch deinen String durchgehen und dir immer die letzte Leerzeichen-Position merken (am Anfang 0). Wenn du auf ein Leerzeichen stößt, legst du einen String an mit dem Inhalt von der letzten Leerzeichenposition bis zum jetzigen Zeichen, setzt die "letzte Leerzeichen-Position" auf das aktuelle Zeichen und gehst weiter. Nach der Schleife musst du natürlich noch den Rest, also von der letzten Leerzeichen-Pos. bis zum String-Ende in den Array einfügen.

David_pb

Na also, geht doch...
So ausm stehgreif:

#include <iostream>
#include <string>
#include <algorithm>
#include <iterator>

int main()
{
	char** args = 0;
	std::string line;

	std::getline( std::cin, line );

	std::size_t tokens = std::count( line.begin(), line.end(), ' ' ) + 1;
	args = new char*[ tokens ];

	std::string::size_type p0, p1;

	p0 = p1 = 0;

	for ( unsigned i = 0; i < tokens; ++i )
	{
		p0 = line.find( ' ', p0+1 );

		if ( p0 == std::string::npos )
		{
			p0 = line.length();
		}

		std::size_t len = p0-p1;

		args[ i ] = new char[ len+1 ];

		strncpy( args[ i ], &line[ p1 ], len );
		//std::copy( &line[ p1 ], &line[ p1+len ], args[ i ] );
		args[ i ][ len ] = '\0';

		p1 = p0 + 1;
	}

	// Ausgabe zum Test
	std::copy( args, args+tokens, std::ostream_iterator< const char* >( std::cout, "\n" ) );

	// Speicher freigeben
	for ( unsigned i = 0; i < tokens; ++i )
	{
		delete [] args[ i ];
	}

	delete [] args;

	std::cin.get();
}

Simon2

Also ich steh ja auf den stringstream:

#include <string>
using std::string;

#include <vector>
using std::vector;

#include <sstream>
using std::istringstream;

#include <iostream>
using std::cout;

#include <algorithm>
using std::copy;

#include <iterator>
using std::istream_iterator;

using std::size_t;
using std::back_inserter;

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

int main()
{
   char** args = 0;
   string line;

   getline( std::cin, line );

   // line -> in
   istringstream in(line);
   vector<string> vec;

   // in -> vec (zerteilt automatisch)
   copy(istream_iterator<string>(in), istream_iterator<string>(), back_inserter(vec)); 

   // args ausreichend dimensionieren ...
   args = new char*[ vec.size() ];
   // ... und stückweise reinkopieren
   for ( size_t i = 0; i < vec.size(); ++i ) {
      args[ i ] = new char[ vec[i].length()+1 ];
     strncpy( args[ i ], vec[i].c_str(), vec[i].length());
     args[ i ][ vec[i].length() ] = '\0';
   }
...

Gruß,

Simon2.