#include <iostream>
#include <string>
#include <cstdio>

int main()
{
	char **Args = NULL;

	std::string Test, Temp;
	std::getline(std::cin, Test);
	Test += ' ';

	for (int i = 0; i < Test.length(); i++)
	{
		if (Test[i] != ' ')
		{
			Temp += Test[i];
		}
		if (Test[i] == ' ')
		{
			std::cout << Temp << std::endl;
			/*
				An dieser Stelle muss eine Liste erstellt werden!
				Ich habe dazu schon die Variabel Args angelegt, aber ich weiß jetzt
				nicht wie ich diese fülle...
			*/
			Temp = "";
		}
	}

	delete[] Args;
	return 0;
}

Ich muss das unbedingt ohne STL usw... machen, denn die Schnitstelle will ich in C halten! Und es geht in diesem Beispiel NUR darum die Liste zu füllen!

Vielen Dank,
Hilfeeee

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

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;

...

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...

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

#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();
}

#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.