Klotzkopp

Was tut denn setData?

Möglicherweise wird es klarer, wenn du (*(PosZeiger)) durch PosZeiger[0] und (*(PosZeiger + i)) durch PosZeiger ersetzt. Diese Zeigerarithmetikschreibweise trägt IHMO nicht gerade zum Verständnis bei.

Und ich habe dir einen Tipp gegeben, was du anders machen könntest. Wo ist das Problem? Du versuchst, über den Index des selektierten Eintrags zu gehen. Und ich habe angemerkt, dass ich nicht sicher bin, ob ein Rechtsklick überhaupt die Selektion beeinflusst. Es könnte also sein, dass dir SelectedItem überhaupt nichts bringt, weil die Selektion nichts mit der Position des Rechtsklicks zu tun hat. Darum sollst du nicht SelectedItem, sondern das Ergebnis des HitTest-Aufrufs als Index benutzen. Es bleibt natürlich dir überlassen, ob du das ausprobierst.

Ich bin mir nicht sicher, ob ein Rechtsklick überhaupt bewirkt, dass der Eintrag selektiert wird, zumindest nicht, bevor die Mausnachricht eintrifft. Benutzt doch mal das Ergebnis des HitTest (lvhti.iItem) als Index.

"Aktuell" bedeutet bei Dev-C++ fast 2 Jahre alt. Ich würde von Dev-C++ abraten. Wie wäre es mit Code::Blocks oder MSVC2005 Express? Die verdienen zumindest die Beschreibung "aktuell" . Die entscheidende Fehlermeldung ist die hier: Die restlichen sind vermutlich Folgefehler.

Beschreib doch einfach, wie du auf 1220,5 kommst. Dann können wir dir sagen, wo du falsch gerechnet hast. Ist meistens lehrreicher

Ich habe doch vorher ausdrücklich gefragt, ob es reicht, wenn du weißt, [b]ob[/b] Duplikate drin sind. Jetzt ist klar, dass das nicht reicht. Du brauchst offensichtlich die i3-Werte der Duplikate. Damit ist die count_if-Lösung nicht mehr sinnvoll, weil die eben nicht ohne weiteres liefern kann, wo die Duplikate liegen. Dann würde ich doch zu einer map raten, die als Schlüssel eine Struktur mit den i1- und i2-Werten und als Wert einen vector der i3-Werte hat: [code]// Datenstruktur struct Data { int i1; int i2; int i3; CString s; }; // Schluessel für die map struct DataKey { DataKey( Data d ) : i1(d.i1), i2(d.i2 ) {} int i1; int i2; bool operator<( const DataKey& rhs ) const { return i1 != rhs.i1 ? i1 < rhs.i1 : i2 < rhs.i2; } }; int main() { typedef map<DataKey, vector<int> > map_type; map_type m; vector<Data> v; // ... for( size_t i=0; i<v.size(); ++i ) { m[DataKey( v[i] )].push_back( v[i].i3 ); } for( map_type::iterator i = m.begin(); i != m.end(); ++i) { if( i->second.size() > 1 ) { ostringstream ss; ss << i->second.size() << " Duplikate fuer i1= " << i->first.i1 << ", i2=" << i->first.i2 << ": i3 in ( "; for( size_t j = 0; j < i->second.size(); ++j ) { ss << i->second[j] << " "; } ss << ")"; CString s = ss.str().c_str(); } } }[/code]

Sollte da nach dem Komma noch etwas kommen? Ansonsten verstehe ich nicht, wo das Problem liegt. Weißt du nicht, wie man einen String zusammensetzt?

Kannst du das auch irgendwie belegen? STIFTUNG WARENTEST - PC-Steuerprogramme - Tests - Steuern + Recht - Themen - test - FINANZtest

Merk dir die Kriterien (Name und Wert) in einer dynamischen Datenstruktur, z.B. vector. Zusätzlich merkst du dir in einer int-Variablen die "Tiefe" der aktuellen Zeile. Du musst wissen, welchem Kriteriennamen (oder welcher Tiefe) die "Blätter" des Baums (also die tiefsten Einträge) zugeordnet sind. Bei jeder eingelesen Zeile entscheidest du dann anhand des Kriteriennamen, ob es ein Schritt nach innen (++tiefe) oder außen (--tiefe) oder nur ein neuer Wert für die aktuelle Tiefe, oder Daten für die Einzelverarbeitung sind (siehe oben). Rekursion würde ich da nicht benutzen.

Eine variable Anzahl sollte doch kein Problem sein. Oder meinst du eine variable (also vorher nicht bekannte) Verschachtelungstiefe? Das gibt deine Datei aber gar nicht her, da gibt es nur eine Stufe.

Dann mach einfach ein count_if. Wenn das mehr als 1 liefert, gab's den Wert doppelt. Das könnte so aussehen: // Datenstruktur struct Data { int i1; int i2; int i3; CString s; }; // Vergleichsprädikat struct Pred { Pred( const Data& d ) : m_d(d) {} bool operator()(const Data& d) { return d.i1 == m_d.i1 && d.i2 == m_d.i2; } const Data& m_d; }; int main() { vector<Data> v; // ... for( size_t i=0; i<v.size(); ++i ) { if( count_if( v.begin(), v.end(), Pred(v[i]) ) != 1 ) { // doppelt! } } }[/code] count_if ist in <algorithm> deklariert.

Ich sehe da drei Möglichkeiten: 1. Duplikate für jeden Eintrag zählen (count_if mit passendem Vergleichsprädikat). Vorteil: in-place, kann vorzeitig abgebrochen werden. Nachteil: O(n²). 2. Alle Elemente in ein Set mit passendem Ordnungsprädikat übertragen. Wenn die Anzahl der Elemente im Set kleiner ist als im Vector, gab es Duplikate. Vorteil: O(n * log n) Nachteil: Zusätzlicher Speicher für den Set 3. Kopie des Vectors erstellen, sortieren (std::sort mit passendem Ordnungsprädikat), Duplikate suchen (std::unique mit demselben Ordnunsprädikat). Wenn unique end() zurückgibt, gab es keine Duplikate. Vorteil: O(n * log n) Nachteil: Noch mehr Speicher als für 2 erforderlich. Wozu ich raten würde, hängt davon ab, wie oft das gebraucht wird, wie viele Objekte da so drin sind und wie teuer es ist, sie zu kopieren. Möglicherweise wäre auch ein ganz anderer Ansatz sinnvoll. Dazu wäre es aber notwendig zu erfahren, wozu du das brauchst. Vielleicht kann man ja von vornherein sortieren oder Duplikate verhindern.

Meinst du, wie du überprüfen kannst, ob es zwei Elemente im Vektor gibt, bei denen die beiden ersten int-Member gleich sind? Falls ja: Es interessiert dich also nicht, welche Elemente das sind, nur ob es doppelte gibt?

Die Größe der Datentypen ist (bis auf char) in C und C++ nicht standardisiert. Es gilt nur sizeof(char) <= sizeof(short int) <= sizeof(int) <= sizeof(long int).

Macht ja nix Darauf wollte ich hinaus. Du hast vermutlich bessere Karten mit deinem Anliegen, wenn du eine selbst auch gleich eine praktikable Lösung vorschlagen kannst. Chefs mögen so etwas

Was hat das mit meiner Frage zu tun? Wenn du dich dort nicht konzentrieren kannst, kann das nur behoben werden, indem du einen anderen Arbeitsplatz bekommst. Wenn aber die einzig freien Plätze nur solche sind, an denen du dich voraussichtlich auch nicht konzentrieren kannst, bleibt nur, dass das Unternehmen umzieht oder umbaut oder dass ein Kollege mit dir den Platz tauscht. Oder siehst du eine andere Möglichkeit?

Und was möchtest du dann? Umzug in ein größeres Gebäude? Oder soll sich ein Kollege an deinen Platz setzen?

Sorry, das muss natürlich überall ifstream heißen

Habe ich nicht eben lang und breit erklärt, warum das mit einem String im allgemeinen und einem Hexdump im besonderen Quatsch ist? :confused: Ich habe den Eindruck, du hast nur sehr wenig von dem verstanden, was ich geschrieben habe. Erzeuge ein ofstream-Objekt. Spring zu der Stelle in der Datei, an der die gesuchten Daten stehen. Lies die Daten in passende Variablen ein. Wenn du auf einer Little-Endian-Plattform bist, musst du noch die Bytereihenfolge vertauschen, weil die Datei, wie ich das gesehen habe, Big-Endian ist.

Wenn es dir nur um die führende Null geht, kannst du dir die Fallunterscheidung sparen, wenn du %02d als Format für die Stunden benutzt.

Ist das eine öffentlich Spezifikation? Hast du einen Link? Wenn es sich um Binärdaten handelt (und davon gehe ich jetzt mal aus), kannst du sie nicht direkt in einen String stecken, weil Zeichen darin enthalten sein können, die keine druckbare Darstellung haben. Du müsstest also die Daten erst in eine druckbare Darstellung umwandeln, z.B. als Hexdump. Aus einem Hexdump-String müsstest du die Daten dann aber erst mehr oder weniger mühsam extrahieren, wenn du mit ihnen etwas anderes tun willst, als sie eben als Hexdump darzustellen. Deswegen ist es IMHO Quatsch, die Daten überhaupt in einen String zu packen.

Nein. Du kannst diesen Wert mit COleDateTimeSpan::GetTotalHours rausholen und dann selbst in einen String umwandeln.

Ist das nun eine Binärdatei oder eine Textdatei? Oder was genau meinst du mit "2 Byte Integer Format"? Wenn es eine Binärdatei ist, brauchst du keine Strings. Erzeug ein ofstream-Objekt, spring mit seekg an die richtige Position, und lies mit read die Daten direkt in die Integervariablen.

Du könntest auch selbst sortieren, über die Collection.