String in Int zerlegen

[Raven280438]

Hi,

ich habe einen String, der aus Zahlen besteht. Diesen möchte ich in einen int-Vector zerlegen.
Ich habe im Internet eine Funktion gefunden, die einen String anhand eines Zeichens in einen String-Vector zerlegt.

Diese Funktion wollte ich umschreiben, damit das Ergebnis im Int-Vector gespeichert wird. Leider funktioniert das nicht richtig

void explode_string_to_int(string str,string separator,vector<int>* results) {
	int found;
	string string_found;
        found = str.find_first_of(separator);
        while(found != string::npos){
        if(found > 0){
			string_found = str.substr(0,found);
			results->push_back(atoi(string_found.c_str));
        }
        str = str.substr(found+1);
        found = str.find_first_of(separator);
    }
    if(str.length() > 0){
        results->push_back(str);
    }
}

als Fehlermeldung bekomm ich

error C2440: '=' : cannot convert from 'std::basic_string<_Elem,_Traits,_Ax>' to 'std::string *'

Mit der Fehlermeldung kann ich als Anfänger nichts anfangen

Kann mir jemand weiterhelfen?


Gruß

 

[ComFreek]

In welcher Zeile tritt der Fehler denn auf?

Ich finde den Code irgendwie etwas umständlich. Das habe ich mal schnell geschrieben (ungetestet):

vector<int> StringExplodeToInt(string src)
{
  vector<int> tmp;
  for (int i=0; i<src.length; i++)
  {
    tmp.push_back(atoi(src.at(i).c_str()));
  }
  return tmp;
}

 

[Raven280438]

Hi,

der Fehler tritt in der Zeile

string_found = str.substr(0,found);

auf.

Deine Funktion ist zwar gut, aber wenn ich sie richtig verstehe geht sie davon aus, dass der Integer-Wert aus nur einer Ziffer besteht.
Es können aber auch 2- oder 3 stellige Integer-Werte vorkommen. Alle Werte sind durch ein Leerzeichen getrennt.


Gruß

 

[Cromon]

Wenn es wirklich immer Leerzeichen sind könntest du beispielsweise folgenden Code verwenden:

void ParseString(std::string& intList, std::vector<int>& vIntOut)
{
	std::stringstream strm;
	strm.str(intList);
	int curVal = 0;
	while(strm >> curVal)
	{
		vIntOut.push_back(curVal);
	}
}

void PrintInt(int& i)
{
	std::cout << i << std::endl;
}

int main(int argc, char* argv[])
{
	std::string integers = "2 3 44 555321 1 -2 -33 4 8 asdf 8 9 ";
	std::vector<int> ints;

	ParseString(integers, ints);
	std::for_each(ints.begin(), ints.end(), &PrintInt);
}

 

[Raven280438]

Hi,

danke die Funktion funktioniert

Nur interessehalber, wie könnte ne Funktion aussehen, wenn man andere Trennzeichen benutzt.
Damit will ich zu meiner oben geposteten Funktion zurückommen.
Kann den Fehler jemand lösen?



Gruß

 

[deepthroat]

Hi.

Bitte nutze die [code=cpp]..[/code] Tags für C++ Code.

Und dann sage auch in welcher Zeile der Fehler auftritt.

results->push_back(atoi(string_found.c_str));

Du hast vergessen die c_str Methode auch aufzurufen:

results->push_back(atoi(string_found.c_str()));

Gruß

 

[Bgag]

Hallo!

Ich habe ein ähnliches Problem. Ich habe einen String vorliegen, denn ich in verschiedene Tokens zerlegen möchte. Momentan versuche ich eine Funktion zu schreiben, die überprüft, ob am Anfang des Strings ein Double-Wert aus beliebig vielen Zeichen steht und mir diesen zurück gibt. Dabei ist es wichtig zu wissen, dass der String nicht nur aus numerischen Werten, sondern auch aus verschiedenen Namen und Symbolen bestehen kann.

Bisher brauchte ich nur einen kompletten String darauf zu überprüfen, ob dieser einen Double-Wert repräsentiert. Dies habe ich mit folgender Funktion gemacht.

bool FancyRPN::isDouble(const std::string& s) {

   std::istringstream i(s);
   double temp;
   return ( (i >> temp) ? true : false );
}

Angepasst habe ich diesen nach obigem Beispiel wie folgt.

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>

double ParseString(std::string stream) {
   std::stringstream strm;
   strm.str(stream);
   double curVal = 0.0;
   while(strm >> curVal) {
      return curVal;
   }
	
   return NULL;
}
 
void PrintInt(double i) {
   std::cout << i << std::endl;
}
 
int main(int argc, char* argv[]) {
   std::vector<double> result;
   result.push_back( ParseString("+2.*a+67") );
   result.push_back( ParseString("34.458") );
   result.push_back( ParseString("-1.2e10") );
   result.push_back( ParseString("-3.2e-10") );
   result.push_back( ParseString("-3.2e-10") );
   result.push_back( ParseString(".1E+2") );
   result.push_back( ParseString("+2.*a+67") );
   std::for_each(result.begin(), result.end(), &PrintInt);
}

Frage ist nun noch, wie ich auf Erfolg prüfen kann. Reicht ein einfacher Vergleich mit NULL?

Liebe Grüße,

Andreas

 

[deepthroat]

Frage ist nun noch, wie ich auf Erfolg prüfen kann. Reicht ein einfacher Vergleich mit NULL?

Nein, das geht so nicht.

Wenn du spezifizierst, dass deine Funktion einen double zurück gibt, dann kannst du nicht einfach NULL-ge-castet-zu-double zurückgeben, denn du wüßtest schließlich nicht ob nicht auch ein ganz normaler double Wert gleich NULL-ge-castet-zu-double ist.

Du müßtest es so einrichten, das du erkennen kannst ob die Funktion erfolgreich war und einen Wert zurückgibt indem du einen Wert zurückgibst der normal nicht zurückgegeben werden kann.

Du könntest z.B. Ausnahmen verwenden oder deine Funktion so deklarieren:

bool TryParseDouble(const std::string& x, double& out) {
}

Gruß

 

[Bgag]

Danke für den Hinweis. Habe es nach deinem Vorschlag wie folgt gelöst.

#include <string>
#include <sstream>
#include <cstdio>

double parseDouble(std::string stream) {
   std::istringstream i(stream);
   double temp;
   
   if(i >> temp) {
   	return temp;
   }
   
   return 0.0;
}

bool tryParseDouble(const std::string& stream) {
	std::istringstream i(stream);
	double temp;
	return ( (i >> temp) ? true : false );
}

void test(const std::string &stream) {
	std::string isDouble = (tryParseDouble(stream) ? "Double" : "String");

	printf("%10s %10s %20.2f\n", 
		stream.c_str(), 
		isDouble.c_str(),
		parseDouble(stream)
	);
}
 
int main(int argc, char* argv[]) {
	test("+2.*a+67");
	test("34.458");
	test("-1.2e10");
	test("-3.2e-10");
	test("-3.2e-10");
	test(".1E+2");
	test("+2.*a+67");
	test("and34.4");
	test("3.4+2.3");
	test("-1.2a");
	test("#12.0+34a");
	test(".0+1");
	test("0123344");
	test("0.0f");
	test(".123");
	test("");
}

Liebe Grüße,

Andreas

 

[deepthroat]

Danke für den Hinweis. Habe es nach deinem Vorschlag wie folgt gelöst.

Aber das war nun wirklich nicht mein Vorschlag...

Findest du es wirklich sinnvoll die Konvertierung doppelt zu machen?

Gruß