TDM

Soweit ich weiß sind µc-Systeme basierend auf dem AVR Mikrocontroler. Folglich brauchst du ein C-Programm auf der Hardwareseite (wenn es schon da ist, dann ok) und einen Empfänger auf der PC-Seite. Da du was von serieller Schnittstelle bzw. RS232 sagtest, solltest du dir vielleicht mal das hier durchlesen. Ansonsten muss man eigentlich nur wissen, dass man serielle Ports als Datei handlen muss. Dabei hilft CreateFile und WriteFile bzw. Readfile.

Items[SelectedIndex]

Nein, ich wollte damit aber die Herangehensweise von Microsoft etwas formulieren, damit du weißt, was beim Pasten (Einfügen) in eine RTB passiert. Auch solltest du dir vielleicht folgende Funktion ansehen: RichTextBox.CanPaste

Soweit ich weiß, werden Blobs (Dateien) nie in die Zwischenablage kopiert, sondern es wird einfach nur der Link im Dateisystem gespeichert. Stell dir einfach vor, du hast eine 5 GiB große Datei, die würde nur schlecht in eine Zwischenablage passen. [Editerle] Zum eigentlichen Problem: RichTextBox.LoadFile

Achso, dachte schon es gäbe einen allgemein gültigen SQL-Befehl... Den kenn ich schon. Trotzdem danke.

Wo liegt das Problem genau?

Wie wärs mit Rauskopieren der exakten Meldungen?! :floet:

Warum nicht gleich asynchron?! Word anzeigen. Paar Zeilen aus der DB lesen. In Word schreiben. Paar Zeilen aus der DB lesen. In Word schreiben. Paar Zeilen aus der DB lesen. In Word schreiben. usw. Der Pirat meinte sicher, dass die Geschwindigkeit konstant bleibt (dauert immer noch genauso lange [wenn nicht sogar länger]), nur das Programm wird nicht blockiert...

Einfach die Funktion aufrufen?! :floet:

Sortierbeispielalgorhytmus.

Können schon, der Funktionsscope verdeckt die globale Deklaration. Ich würde die Variablen so und so nicht global machen, da C++ entweder in einer Klasse kapseln oder nur in Main. Verrätst du die auch? Auch mal was neues, dev-C++ soll besser laufen als Borland... :confused:

eingabe(e); //... ausgabe(e); Arrays sind Zeiger. :floet: [Edierle] Warum hat ausgabe(double[]) einen Rückgabewert?

Das Statement würde mich mal interessieren. Ich weiß zwar, dass man sich mit TSQL ein Query auf die Systemdatenbank erlauben kann, aber wenn es ein allgemein gültiges SQL-Statement dafür gibt, dann immer her damit. :beagolisc

Das einzige Schlimme an der Steuerung war die Abhängigkeit von der (teils) schlecht gewählten Kameraposition, alles andere ging eigentlich. Auch wenn sich das Monkeycombat bei den ersten 3 Durchspielen immer ziemlich hingezogen hatte.

Da du keinen Verbindungstyp spezifiziert hast: OdbcConnection.GetSchema("Tables")

Ich werf da mal was in den Raum: GR2 Decode

Tausche: cin>>e[i]; gegen: e[i] = getch(); Anmerkung: Gibts nen Grund, warum die Variablen global sind?

Sowas?

CString::Insert

CArchive::ReadString Anmerkung: Wird im Konstruktor mit CFile initialisiert, als kann man das so auslegen, dass man über CFile eine Zeile liest. :floet:

Chr(34) (Ich hmm, wenns 3 nicht waren, wars vielleicht 4... """")

\" (c#) """ (vb)

Ich spiel mal Debugger...: Start Main() Erstelle Zeiger A auf ein object. Erstelle neues Object, reserviere speicher und weise Addresse A zu. Schreibe in A-> Inhalt 0. Beginne Schleife Wert = 0 Start einfuegen. Parameter inhaltneu = 1 Parameter anfang = A Erstelle Zeiger tmp auf ein object. Weise tmp = A zu. Überprüfe tmp -> next. (= A -> next) tmp -> next == NULL. Überspringe Schleife. Erstelle neues Object B, reserviere speicher und weise Addresse A->Next zu. Weise tmp B zu. Setze tmp -> inhalt auf inhaltneu Erhöhe Wert um 1. Wert = 2. Prüfe Wert < 5. Start einfuegen. Parameter inhaltneu = 2 Parameter anfang = A Erstelle Zeiger tmp auf ein object. Weise tmp = A zu. Überprüfe tmp -> next. (= A -> next) Weise tmp A -> next zu. Überprüfe tmp -> next. (= B -> next) tmp -> next == NULL. Breche ab. Erstelle neues Object C, reserviere speicher und weise Addresse B->Next zu. Weise tmp C zu. Setze tmp -> inhalt auf inhaltneu Wiederhole //Schreibfaul. Ende Schleife Gebe alle Elemente aus. Ende Main Reicht?

Meinst du HilfsHandle ist NULL oder (HilfsHandle - Next) == NULL? (Der Pfeil nach links irritiert etwas :beagolisc) Wenn du letzteres meinst, dann ist es richtig. listenanfang inhalt = 0 next = inhalt = 1 next = NULL (= HilfsHandle)

#include "stdafx.h" using namespace System; //die Struktur für den verwalteten Heap ref struct beispiel { int inhalt; beispiel ^next; [COLOR="Green"]hier wird eine Struktur angelegt. Die Struktur enthält ein Feld inhalt und einen weiteren Zeiger oder Handle welcher wiederum auf inhalt eines weiteren Speichers zugreifen bzw. zeigen kann.[/COLOR] }; void einfuegen(int inhaltneu, beispiel ^anfang) { [COLOR="Green"]unter int inhaltneu wird jetzt 1 aus main übergeben und unter beispiel ^anfang anfang von main. Kann mir jemand sagen, was genau jetzt in dieser Funktion einfuegen in klammern stehen würde ? Wird durch die Übergabe der Parameter an diese Funktion bereits ein Wert in der Struktur gespeichert ?[/COLOR] [COLOR="Red"]Falsch. Die Funktion wird mehrmals aufgerufen. Paramater: 1, anfang (aus main) Paramater: 2, anfang (aus main) Paramater: 3, anfang (aus main) Paramater: 4, anfang (aus main) [/COLOR] beispiel ^zeiger; zeiger=anfang; [COLOR="Green"]hier wird nun ein weiterer Handle zeiger erstellt und auf listenanfang gesetzt. zeigt dieser zeiger Handle jetzt auf 0 oder auf 0 + next oder auf 1 und next ?[/COLOR] [COLOR="Red"] Auf anfang (aus main); folglich 0. [/COLOR] while (zeiger->next!=nullptr) { zeiger=zeiger->next; } [COLOR="Green"]Liste durchgehen, bis zeiger.next ungleich null ist. Dann wird dieser Zeiger auf next gesetzt. [/COLOR] zeiger->next=gcnew beispiel; [COLOR="Green"]wieder Speicher reservieren[/COLOR] zeiger=zeiger->next; [COLOR="Green"]zeiger wird nochmals auf next gesetzt ? welches next ist das denn jetzt ? das von zeiger oder von anfang oder der struktur selbst ?[/COLOR] [COLOR="Red"]zeiger->next ist zu dem Zeitpunkt = gcnew beispiel (neues object)[/COLOR] zeiger->inhalt=inhaltneu; [COLOR="Green"]das ist wieder klar[/COLOR] } void ausgabe(beispiel ^anfang) { beispiel ^zeiger; zeiger=anfang; Console::WriteLine("{0}", zeiger->inhalt); while (zeiger->next != nullptr) { zeiger = zeiger->next; Console::WriteLine("{0}", zeiger->inhalt); } }[COLOR="Green"]diese Funktion ist auch wieder klar ![/COLOR] int main(array<System::String ^> ^args) { beispiel ^anfang; [COLOR="Green"]hier wird ein Handle bzw. Zeiger anfang erstellt, welcher die Daten der Struktur (also inhalt und next) speichern kann[/COLOR] anfang=gcnew beispiel; [COLOR="Green"]hier wird für den Handle speicher reserviert[/COLOR] anfang->inhalt=0; [COLOR="Green"]das erste Element wird in den handle anfang geschrieben. Da ja der Handle indirekt mit der Struktur beispiel arbeitet, wird hier jetzt indirekt dieser Wert in die Struktur geschrieben oder in anfang selbst ?[/COLOR] for (int schleife=1;schleife<5;schleife++) { einfuegen(schleife, anfang); [COLOR="Green"]in dieser schleife wird das nächste element und anfang an die funktion einfuegen übergeben. Was wird denn hier genau mit anfang übergeben ?[/COLOR] [COLOR="Red"]Das weiter oben definierte Objekt anfang (erstes Element in der Liste)[/COLOR] } ausgabe(anfang); [COLOR="Green"]das ist klar ![/COLOR] return 0; }