ich brauche ein Funktion, die mir einen String formatiert. Der String ist in Blöcke von Zahlen unterteilt, die hier mit einem Doppelpunkt von einander getrennt sind.

Beispiel: 23:24:28:10:29:18:12:24:11:27:10:22:10:20:28

Nun muss ich diesen String von hinten lesen und jeweils die Zahlen der einzelnen Blöcke umdrehen. Hier sollte also rauskommen:

82:02:01:22....

Meine dazu geschriebene Methode kommt nur zu folgenden Fehlern, die anscheinend dann in einer Endlosschleife stecken bleiben:

*** Error in ./noob': free(): invalid next size (fast): 0x0000000001870770 *** \*\*\* Error in./noob': malloc(): memory corruption: 0x00000000018707a0 ***

void myclass::format_output(std::string& raw_result) {

  std::stringstream output, tmp;
  bool delimiter_seen = true;
  std::cout << "\n\n" << raw_result << "\n\n";
  for(std::string::reverse_iterator rit = raw_result.rbegin(); rit != raw_result.rend(); ++rit)  { //rückwerts über String iterieren   
    if(*rit != delimiter) { //Delimiter == ":"
      tmp << *rit;
    }
    else {
      if(delimiter_seen) {
	std::reverse(tmp.str().begin(), tmp.str().end());
	output << tmp.str();
	tmp.str("");
	delimiter_seen = false;
      }
      else {
	delimiter_seen = true;
      }
    }
  }

  raw_result = output.str();
}

Vielen Dank
LG, freakC++

Wenn du jetzt noch an die (gerade umgedrehten) Daten kommen willst, um diese z.B. in einen vector zu schieben, dann kannst du folgendes machen (selbst das wäre wahrscheinlich noch eifnacher machbar):

std::vector<int> parse(std::string str)
{
	std::reverse(str.begin(), str.end());
	std::replace(str.begin(), str.end(), ':', ' ');

	std::vector<int> result;
	std::back_insert_iterator<std::vector<int>> back_it(result);

	std::stringstream ss(str);

	std::copy(std::istream_iterator<int>(ss), std::istream_iterator<int(), back_it);
}

ungetestet aus dem Kopf getippt...

Hier kämen wir mit einer einzigen Iteration und 0 Kopien aus.

23:24:28:10:29:18:12:24:11:27:10:22:10:20:28

soll

28:20:10:22:...

werden. Daher kann nicht einfach ein reverse machen. Deswegen ist mein Code etwas komplizierter. Sieht jemand das Problem?

Danke

1.) 23:24:28:10:29:18:12:24:11:27:10:22:10:20:28

2.) 232428102918122411271022102028 //Doppelpunkte raus

3.) 82029122... //umdrehen.

Jetzt ist erstens verloren gegangen, wo die Doppelpunkte standen (die Zahlenblöcke können beliebig groß sein) und außerdem drehe ich so auch die Blöcke um.

Ziel ist es die Blockreihenfolge umzudrehen, nicht die Blöcke selbst.

Danke

Hier ist übrigens eine ganz nette Lösung für dein ursprüngliches Problem, beziehungsweise eine Lösung im Stil von Skym0sh0 aber mit

Skym0sh0 schrieb:

kurz denken

Ist auf den ersten Blick unnötig umständlich, aber so ein Iterator-basierter Streambuf kam mir sehr nützlich vor und ich konnte im Netz keinen fertigen finden. Daher veröffentliche ich ihn hier mal. ist natürlich noch leicht ausbaufähig, zum Beispiel könnte man den Iteratortyp erkennen und gegebenenfalls noch die ganzen Funktionen zum Zurücksetzen oder Positionieren anbieten, je nach dem, was der Iterator so kann. Für dieses einfachste Beispiel reicht ein Inputiterator:

#include <streambuf>
#include <ios>    

template <typename Iterator> class iterator_streambuf : public std::streambuf
{
public:
  iterator_streambuf(Iterator begin, Iterator end): current(begin), end(end) { }
protected:
  virtual int_type underflow()
  {
    if (current != end)
      return *current;
    else 
      return traits_type::eof();
  }
  virtual int_type uflow()  
  {
    if (current != end)
      return *current++;
    else 
      return traits_type::eof();
  }
private:
  iterator_streambuf( const iterator_streambuf& );    
  iterator_streambuf& operator=( const iterator_streambuf& );

  Iterator current;
  Iterator end;
};

#include <string>    
#include <iostream>  
#include <forward_list> 

int main()
{
  {
    std::string foo = "!nebeirhcseg streawkceur remmi nedrew netfahcstoB ehcsinataS";

    iterator_streambuf<decltype(foo.rbegin())> buf(foo.rbegin(), foo.rend());
    std::istream in(&buf);

    for(std::string str; in >> str; std::cout << str << '\n');  
  }
  // edit: Oder etwas exotischer:
  {
    std::forward_list<int> foo = {52, 32, 56, 32, 49, 53, 32, 49, 54, 32, 50, 51, 32, 52, 50};
    iterator_streambuf<decltype(foo.begin())> buf(foo.begin(), foo.end());
    std::istream in(&buf);

    for(int i; in >> i; std::cout << i << ' ');  
    std::cout << '\n';
  }
}

Ist auf den ersten Blick unnötig umständlich, aber so ein Iterator-basierter Streambuf kam mir sehr nützlich vor und ich konnte im Netz keinen fertigen finden.

Wenn du schon im Himmel der Iteratoren bist, wieso möchtest du dann wieder zurück in die Höllen der Streams?

Rate mal, wie GCCs stdlibc++ den Input parst: Mit Stream-Iteratoren.

Das heisst in diesem Falle:

std::string s = "23:24:28:10:29:18:12:24:11:27:10:22:10:20:28:";
for (auto curr=s.rbegin(),last=curr;(last=curr++,curr=std::find(curr,s.rend(),':'))!=s.rend();)
  std::copy(curr.base(), last.base(), std::ostreambuf_iterator<char>(std::cout));
std::cout << '\n';

Und du? Dein Ansatz kann genau Wörter bis zu nächsten Whitespace einlesen. Punkt. Nicht mehr. Was wenn an ":" getrennt werden soll (wie die Aufgabe *wirklich* lautete)? Dann halt von operator>> zu getline wechseln. Was wenn an ":" oder ";" getrennt werden soll? Ups. Das artet zu Locale-Rumgepfriemle aus. Will niemand.

for (auto curr=s.rbegin(),last=curr;last=curr++,curr=std::find(curr,s.rend(),':'),last!=s.rend();)

SeppJ schrieb:

Ist auf den ersten Blick unnötig umständlich, aber so ein Iterator-basierter Streambuf kam mir sehr nützlich vor und ich konnte im Netz keinen fertigen finden.

Wenn du schon im Himmel der Iteratoren bist, wieso möchtest du dann wieder zurück in die Höllen der Streams?

Rate mal, wie GCCs stdlibc++ den Input parst: Mit Stream-Iteratoren.

Ich glaube, du hast nicht kapiert, was mein Code macht. Iterator->Stream, nicht Stream->Iterator.

eSsThehelL schrieb:

SeppJ schrieb:

Ist auf den ersten Blick unnötig umständlich, aber so ein Iterator-basierter Streambuf kam mir sehr nützlich vor und ich konnte im Netz keinen fertigen finden.

Wenn du schon im Himmel der Iteratoren bist, wieso möchtest du dann wieder zurück in die Höllen der Streams?

Rate mal, wie GCCs stdlibc++ den Input parst: Mit Stream-Iteratoren.

Ich glaube, du hast nicht kapiert, was mein Code macht. Iterator->Stream, nicht Stream->Iterator.

Ich glaube, du hast nicht kapiert:
Iterator:
Stream:

Folglich
Stream -> Iterator
Iterator -> Stream

edit: Mach doch mal das zweite Beispiel aus meinem Code mit deiner Methode nach.

Und, dass dein Ansatz am verallgemeinerten Problem scheitert: "12:34;56" => "56;34:12" (also an ":" und ";" splitten und den Separator beibehalten).

Ich versuch mich solange an deinem exotischen Problem.

Egal, beide haben überhaupt kein Problem mit irgendwelchen Separatoren. Ich bin immer mehr überzeugt, dass du gar nicht kapierst, was der Code macht.

std::forward_list<char> s = {53, 32, 56, 32, 49, 53, 32, 49, 54, 32, 50, 51, 32, 52, 50}; 
bool last_was_digit = true;
for (char c : s)
  if (!std::isdigit(c))
    last_was_digit = false;
  else
    last_was_digit = std::cout << (last_was_digit?"":" ") << c;

Löse du mal das Problem von freakC++ mit deiner Streamlösung: "12:34:56" soll werden zu "56:34:12". Und das möglichst ohne (a) Integer-Overflows (b) alles zu kopieren bei der Eingabe "allesohnedoppelpunkte".

Zu deiner Lösung meines exotischen Problems: Ähh, du hast es nicht gelöst. Es geht nicht darum, die Zeichen auszugeben. Ich will die Zahlen haben! Wir wollen damit rechnen.

Wenn du nun beginnst, num_get nachzuprogrammieren: Holzweg. Dann fang ich an, Fließkommazahlen hexadezimal in Scientificschreibweise mit Vorzeichen in die Liste zu packen und es soll immer noch funktionieren. Bitte eine universelle Lösung, die meiner ebenbürtig ist.

Ziel ist es die Blockreihenfolge umzudrehen, nicht die Blöcke selbst.

Und wenn du nun 'Block' durch 'Woerter' ersetzt, erkennst du, dass das Internet viele bekannte Loesungen in vielen bekannten und unbekannten Sprachen bereithaelt. Denken muss man wirklich nicht. Oder der MAtrixstil: Nicht denken, wissen!

Ach, ich bin da eher faul: http://www.geeksforgeeks.org/reverse-words-in-a-given-string/

Einfach ' ' durch ':' ersetzen, http://ideone.com/Xc1Sz5 . Mann muss zwei Mal drueberiterieren, ist aber inplace. Trivial parallelisierbar. Um Sonderfaelle zu beachten, brauche ich eine bessere Problembeschreibung.

Danke!

LG, freakC++

verallgemeinerten Problem

Soll ich mal anfangen zu verallgemeinern?
1.) Variabler Separator
2.) Separator variabler Laenge
3.) Separator escapen um als Teilwort betrachtet zu werden.
4.) Escapezeichen escapen
5.) Keine Strings sondern Streams mit verschiedenen Fehlerzustaenden
6.) Keine Strings sonder Bitstreams deren Wortgroesse kein Vielfaches von 8 Bit sind
7.) Muahahahaha
8.) Werner darf nicht mitmachen
9.) Mehr Muahahahaha ...

Hat jemand was dagegen?

void myclass::format_output(std::string& raw_result) {

  std::string::iterator num_begin = raw_result.begin();

  for(std::string::iterator it = raw_result.begin(); it != raw_result.end(); ++it) {   
    if(*it == delimiter){
      	std::reverse(num_begin, it);
	num_begin = it+1;
    }
  }
  std::reverse(raw_result.begin(), raw_result.end());
  raw_result.erase(0,1);
}

Viele Grüße
freakC++

Hat jemand was dagegen?

Warum sollte es eine Methode und nicht eher eine freie Funktion sein?

Später brauche ich die Klasse nur als Hilfsmittel. Diese Formatierungsfunktion ist privat und muss nicht nach außen sichtbar sein.

??? Aufmerksam lesen: Meine Streamlösung ist für den Fall, dass 12:34:56 zu 65, 43, 21 werden soll. So wie vom TE ursprünglich verlangt

Ja, ursprünglich.

freakC++ schrieb:

Sorry Leute! Ich habe Blödsinn geredet. Aus

23:24:28:10:29:18:12:24:11:27:10:22:10:20:28

soll

28:20:10:22:...

werden. Daher kann nicht einfach ein reverse machen. Deswegen ist mein Code etwas komplizierter. Sieht jemand das Problem?

Sollte doch nur eine kleine Änderung in deinem Code sein sein, nicht?

und als Demonstration für Skym0sh0, wie es ohne drei Umwege und trotzdem universell gehen könnte. Damit ist das eine ganz wunderbare Lösung, die kaum einen Prozessortakt zu viel verschwendet, dabei aber universell auf viele Probleme angewandt werden kann.

Ich habe mal deine Lösung mit

std::string foo = "!nebeirhcseg streawkceur remmi nedrew netfahcstoB ehcsinataS";
  for (int i=0; i<20; i++)
    foo = foo + foo;

getestet und ich erhalte:

reverse string + streambuf:  3.30s user 0.16s system 99% cpu 3.467 total
seppjs reversed streambuf :  2.93s user 0.10s system 99% cpu 3.034 total
iterator + for-loo p      :  0.78s user 0.10s system 99% cpu 0.883 total

Oooh, wie unerwartet. istream hält einen eigenen buffer, ostream hält einen buffer und formatierter Input ist teuer.

std::ostreambuf_iterator<char> out(std::cout);
auto it=foo.rbegin(), end=foo.rend();
while (it != end) {
  while (std::isspace(*it) && it != end)
    ++it;
  while (!std::isspace(*it) && it != end)
    *out++ = *it++;
  *out++ = ' ';
}

Meine Aussage: IOstream-Parsen ist sehr langsam und für Nicht-Whitespace-getrennten-Standarddatentypen-Input enorm umständlich. (Bei langsamen Festplatten fällt das Parsen vielleicht weniger ins Gewicht, aber wenn der Input schon im RAM ist, ist stringstream der Tod)

Für Speed soll man auf Iteratoren wechseln (istreambuf_iterator im Fall von externen Streams, sonst halt was gegeben ist). Ist oft auch kürzer und einleuchtender. Wenn einem Whitespaces egal sind, ist der Stream nur hinderlich.

Zu deiner Lösung meines exotischen Problems: Ähh, du hast es nicht gelöst. Es geht nicht darum, die Zeichen auszugeben. Ich will die Zahlen haben! Wir wollen damit rechnen.

Das ist deine Interpretation fürs Problem. Klar ist eine Streamlösung einfacher, wenn wir Parsen wollen. Das war aber nie gefragt.

Wenn du nun beginnst, num_get nachzuprogrammieren: Holzweg. Dann fang ich an, Fließkommazahlen hexadezimal in Scientificschreibweise mit Vorzeichen in die Liste zu packen und es soll immer noch funktionieren. Bitte eine universelle Lösung, die meiner ebenbürtig ist.

Nimmstu std::stoi. Das Design der Iostreams ist so kaputt, dass ich num_get nur mit istreambuf_iterator<char|wchar_t> verwenden kann (d.h. ich brauche deinen Iter2Streambuf aufgrund von Iostream-Limitations).

Ich wiederhole: Wie würdest du die eigentliche (im Gegensatz zur ursprünglichen) Aufgabe von freakC++ lösen?