Beiträge von Wasserleiche

Ja, The User hat schon recht. Die Konzepte von C# und Java ähneln sich doch sehr. Auch im Hinblick auf Bytecode, Garbage Collection, OOP etc...

Aber ein extra Forum für diese beiden - ich weiß nicht. So viele Fragen wurden bisher nicht gestellt...

Zeig mal deinen bisherigen Code, dann kann ich dir leichter helfen.

Toggle wird einfach mit einem Komma hinter Pause geschrieben. Genauso wie es in der Befehlsreferenz steht. Die eckigen Klammern [ ] stehen immer für optionale Parameter, und wenn mehrere mit einem Strich | getrennt sind, darf man nur eines davon übergeben.

Da sich in letzter Zeit die Fragen im C/C++ Forum rund um C# häufen, wäre es angebracht das Forum auch dahingehend umzubenennen.

Und da C/C++ mit C# genauso viel (bzw. wenig) verwand ist wie mit Java, könnte man das auch noch mit aufnehmen.

Nur so mal als Vorschlag.

In der Referenz steht doch "Pause [, On|Off|Toggle, OperateOnUnderlyingThread?]".

Nutze einfach Toggle um zu starten und zu stoppen.

Kurz in die Command Referenz geschaut: Pause

Mit dem restlichen Code aus diesem Thread solltest du das hinbekommen...

Wenn du das nicht weißt, solltest du mal ein Tutorial komplett durcharbeiten.

Die Main() Methode ist der Einstiegspunkt des Programms. "void" bedeutet das diese Methode keinen Rückgabewert hat.
"static" heißt nur, dass man keine Instanz der Klasse benötigt, um die Methode aufzurufen. Aber das verstehst du sicher erst später, wenn du etwas über Objektorientierung gelesen hast.

Der Code ist einfach falsch.

Du musst deine Main Methode in eine Klasse packen. Globale Funktionen wie in C/C++ kennt C# nicht.

Und "using System;" müsste auch noch rein, damit der Compiler beispielsweise den Namespace von Console.Write() weiß.

Jaein, -Wall wird zwar alle Warnungen aktivieren, aber der Compiler ist kein Hellseher. Ein C/C++ Compiler bearbeitet jede cpp einzeln und erzeugt dafür Code.

Steckst du nun (beispielsweise) eine Variable in eine Funktion, die nicht in dieser Datei definiert ist, kann der Compiler keine Informationen darüber ausgeben, ob diese dort initialisiert oder lesend auf diese zugegriffen wird.

Zur Compilezeit ist also weniger bekannt, als du dir eventuell erhoffst...

Hm, ich bezweifel das die Zahlen auf dem Numpad und über den Buchstaben unterschiedliche Codes haben. Würde behaupten das von der Tastatur genau der selbe Code geschickt wird, und damit ist es auch nur so simulierbar.

Es könnte außerdem sein, dass die Spiele die Keyboardeingaben hooken und damit eine ebene "unterhalb" des Betriebssystems arbeiten. Und die keybd_event() Funktion kann das eventuell so nicht simulieren. Mit AutoHotKey schaffst du das aber : )

Achso, die Sleep() mit großem S bekommt Millisekunden übergeben. Da musst du beim Autohotkey Skript das selbe machen. Sleep mit 10 aufrufen.

Und zu deinem Problem: keybd_event() ist veraltet. Du solltest dich nach der neuen Funktion umschauen.

Also wenn ich das richtig sehe wird nur alle 10 Sekunden die Leertaste gedrückt. Mehr nicht...

Mit AutoHotKey sieht das dann so aus:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;     Grundeinstellungen      ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


#SingleInstance force
#InstallKeybdHook


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;  Das eigentliche Skript     ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


Loop
{
   Sleep, 10000
   Send {Space}
}


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;Alt + Entf -> Skript beenden ;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


$!Del::
   SoundBeep, 600,100
   ExitApp
return

Vorsicht: vollkommen ungetestet!

PS: keybd_event() wurde ersetzt, dafür gibts jetzt wohl andere Funktionen.

Erstmal was ganz wichtiges: bitte nutze die Code-tags, dass kann sonst keiner lesen!

Ich hab dein Problem nur kurz überflogen, deswegen nur mal eine Vermutung: du übergibst in deine Funktionen nur Kopien der Nodes, und arbeitest daher auf lokalen Kopien und nicht auf den originalen.
Mach Referenzen draus...

Keine Ahnung wo dein Problem ist. Habs mal kurz implementiert und funktioniert wunderbar:

#include <iostream>
using namespace std;


typedef int zustand [9];


struct queueknoten
{
	zustand data;
	queueknoten *next;
};
queueknoten *anker = NULL;


int main(int argc, char *argv[])
{
	queueknoten *node1 = new queueknoten;
	for(int i=0; i<9; ++i)
	{
		node1->data[i] = i;
	}
	node1->next = NULL;
	anker = node1;

	queueknoten *node2 = new queueknoten;
	for(int i=0; i<9; ++i)
	{
		node2->data[i] = i+10;
	}
	node1->next = node2;


	queueknoten *iter = anker;

	while(iter != NULL)
	{
		for(int i=0; i<9; ++i)
		{
			cout << iter->data[i] << endl;
		}
		iter = iter->next;
	}

	return 0;
}

Glaube ich kaum, da C# auf Bytecode aufbaut und erst JustInTime compiliert wird. Aber mit allen anderen .NET Sprachen wirst du das schaffen.

Natürlich auch mit C++/CLI (früher Managed C++).

Und was würde mir das bringen? Den Virus hätte ich ja dann trotzdem aufm PC und dürfte mich damit rumschlagen.

Egal, jetzt will ichs doch wissen, aber:

"Diese Anwendung konnte nicht richtig initialisiert werden."
Fehlt da eventuell eine Library?

Und ich versteh immernoch nicht wie das mit c/c++ zusammenhängt, aber egal...

Du bist hier im C/C++ Forum. Ich hab angenommen das es sich um die Anwendung (exe) dreht und in C/C++ geschrieben ist.

Wenn dem nicht so ist, bist du im falschen Forum...

Glaubst du wirklich es läd sich hier einer eine unbekannte exe runter und führt die aus?!

Und ohne Code kann dir sowieso niemand helfen...

Ja natürlich macht das Sinn, ich hab das nur schnell hingeklatscht ohne nachzudenken.

double& operator=(double& a_dbl, const MyClass& a_class)
{ /* ... */ }

Warum ich das so nicht überladen darf versteh ich jetzt nicht 100%ig. Aber im Prinzip ist Operatorüberladung nur syntaktischer Zucker, also bekommst du es auch ohne hin...

Doch, na klar kannst du den = Operator global überladen. Übergeben musst du nur einfach double und YourClass.

Also:

double operator=(double a_dbl, const YourClass &a_class)
{  /* ... */ }

Hab ich jetzt so aber nicht getestet...

Also ich versteh dein Problem nicht 100%ig. Ein Beispiel wäre hilfreich.

Wenn ich es richtig verstanden habe soll sowas möglich sein:

YourClass inst;
double temp = 3.4;


inst = temp; // Variante 1
temp = inst; // Variante 2

Variante 1 ist ja klar. Der Operator muss als Methode implementiert sein.
Für Variante 2 musst du eine globale Funktion definieren, die ein double und YourClass übergeben bekommt. Darin kannst du dann die nötigen Operationen ausführen.