class ToggleCheat : public Cheat
{
public:
	ToggleCheat(HANDLE hProcess, string description, int adress, int num_bytes, ...);
	~ToggleCheat();

	virtual void Toggle() = 0;

protected:
	bool cheat_is_active;
};

Und eine Klasse die davon Erben soll:

class InjectionCheat : public ToggleCheat
{
public:
	InjectionCheat(HANDLE hProcess, string description, int adress, int num_bytes, ...);
	~InjectionCheat();

private:
	BYTE* bytes_original;
	BYTE* bytes_custom;

};

Ich möchte nun, dass die variable Argumentliste bei der Definition von InjectionCheat an ToggleCheat weitergereicht wird. Ist das überhaupt möglich? Wenn ja, wie?

// cpp-datei
InjectionCheat::InjectionCheat(HANDLE hProcess, string description, int adress):ToggleCheat(int num_bytes, ...){
//
}

Probiert?

Nachtrag:
Nein geht doch nicht.

Dazu braucht man
http://www.cplusplus.com/reference/clibrary/cstdarg/va_list/
und Konsorten.

Damit kriegt man die ellipse aber doch auch nicht weitergereicht?!

Shade Of Mine schrieb:

Dazu braucht man
http://www.cplusplus.com/reference/clibrary/cstdarg/va_list/
und Konsorten.

Damit kriegt man die ellipse aber doch auch nicht weitergereicht?!

Aber du kannst die va_list weiterrreichen...

darkfate schrieb:

Shade Of Mine schrieb:

Dazu braucht man
http://www.cplusplus.com/reference/clibrary/cstdarg/va_list/
und Konsorten.

Damit kriegt man die ellipse aber doch auch nicht weitergereicht?!

Aber du kannst die va_list weiterrreichen...

class A{
public:
	A(int num_bytes, va_list valist);
}; 

class B : public A{
public:
	B(double a, int num_bytes, ...);

}; 

B::B(double a, int num_bytes, ...):A(num_bytes, va_arg){ }

Weder die Zeile 3 noch Zeile 12 wird akzeptiert.
So geht das zumindest nicht.

Ich möchte eine gewisse Menge von Bytes in den Arbeitsspeicher schreiben. Bei Arrays geht das ja recht cool:

BYTE arr[] = {0x90, 0x12, 0x15, 0x24}
WriteProcessMemory(Process, adress, arr, 4, 0);

Allerdings geht diese Notation ja leider nur bei der Initialisierung.

einfach

void foo(BYTE arr[]) {...}

foo({0x90, 0x12, 0x15, 0x24})

geht ja nicht, daher will ich das mit einer variablen Argumentliste machen, um mir hässliche Konstrukte wie:

BYTE arr1[] = {0x90, 0x12, 0x15, 0x24}
foo(arr1)

BYTE arr2[] = {0x12, 0x34, 0x56, 0x78}
foo(arr2)

...

Zu ersparen sondern einfach nur

foo(4, 0x90, 0x12, 0x15, 0x24)
foo(4, 0x12, 0x34, 0x56, 0x78)

...

machen zu können, wobei ich das mit der Übergabe der zu verarbeiten Argumente (im Beispiel 4) auch etwas doof finde. Am liebsten hätte ich das auch noch irgendwie automatisiert ermittelt.
So etwas wie bei der Arrayinitialisierung fände ich daher optimal.

Nun, mein Problem ist folgendes:

Ich möchte eine gewisse Menge von Bytes in den Arbeitsspeicher schreiben. Bei Arrays geht das ja recht cool:

Dann reiche doch das Array und dessen Dimension(en) weiter?

void f(va_list l);

void f2(int i, ...) {
  va_list l;
  va_start(l, i);
  f(l);
  va_end(l);
}

@Stephan86:
http://www.drdobbs.com/article/printableArticle.jhtml;jsessionid=FK1ACWGV5RUUBQE1GHPSKHWATMY32JVN?articleId=184403542&dept_url=/architecture-and-design/
oder
http://www.codeproject.com/KB/stl/PGIL.aspx

Wie gesagt will ich ja Konstrukte wie

BYTE GodOneHitInjcCave[] = { 0x56, 0x8B, 0x35, 0x8C, 0xF9, 0x01, 0x11, 0x83, 0xFE, 0x01,
									 0x8B, 0xF0, 0x75, 0x0D, 0x39, 0x1D, 0x43, 0xF9, 0x01, 0x11, 
									 0x74, 0x05, 0xBE, 0x00, 0x00, 0x00, 0x00, 0x56, 0x8B, 0x35, 
									 0x88, 0xF9, 0x01, 0x11, 0x83, 0xFE, 0x01, 0x5E, 0x75, 0x08, 
									 0x39, 0x1D, 0x43, 0xF9, 0x01, 0x11, 0x74, 0x02, 0x89, 0x33, 
									 0x5E, 0x8B, 0xD8, 0x8B, 0x44, 0x24, 0x14, 0xE9, 0xCA, 0x29, 
									 0xCD, 0xFF }; 

foo(GodOneHitInjcCave)

vermeiden und hätte die Definition der Bytes gerne direkt in foo().

@darkfate:

void f(va_list l);

void f2(int i, ...) {
  va_list l;
  va_start(l, i);
  f(l);
  va_end(l);
}

@Stephan86:
http://www.drdobbs.com/article/printableArticle.jhtml;jsessionid=FK1ACWGV5RUUBQE1GHPSKHWATMY32JVN?articleId=184403542&dept_url=/architecture-and-design/
oder
http://www.codeproject.com/KB/stl/PGIL.aspx

Ich bin eigentlich von dem hier ausgegangen:

Stephan86 schrieb:

Ich möchte nun, dass die variable Argumentliste bei der Definition von InjectionCheat an ToggleCheat weitergereicht wird. Ist das überhaupt möglich? Wenn ja, wie?

Dazu müsste doch die va_list durch den Konstruktor?

Wie gesagt will ich ja Konstrukte wie

BYTE GodOneHitInjcCave[] = { 0x56, 0x8B, 0x35, 0x8C, 0xF9, 0x01, 0x11, 0x83, 0xFE, 0x01,
									 0x8B, 0xF0, 0x75, 0x0D, 0x39, 0x1D, 0x43, 0xF9, 0x01, 0x11, 
									 0x74, 0x05, 0xBE, 0x00, 0x00, 0x00, 0x00, 0x56, 0x8B, 0x35, 
									 0x88, 0xF9, 0x01, 0x11, 0x83, 0xFE, 0x01, 0x5E, 0x75, 0x08, 
									 0x39, 0x1D, 0x43, 0xF9, 0x01, 0x11, 0x74, 0x02, 0x89, 0x33, 
									 0x5E, 0x8B, 0xD8, 0x8B, 0x44, 0x24, 0x14, 0xE9, 0xCA, 0x29, 
									 0xCD, 0xFF }; 

foo(GodOneHitInjcCave)

vermeiden und hätte die Definition der Bytes gerne direkt in foo().

und warum??

irgendwie schreit so ein großer Block Daten doch danach einen Namen zu bekommen. Hast du ja in foo(GodOneHitInjcCave); gemacht

Ich weiß ja in der Regel nicht wie groß mein Array ist. Das können mal gut und gerne 30 Werte sein. Jedesmal durchzählen ist zum einen mühleelig und zum anderen Fehleranfällig.

count = sizeof(array)/sizeof(double);

Dazu müsste doch die va_list durch den Konstruktor?

Ja.

... kann man schwer verwenden. Man muss ... in etwas umwandeln dass man angreifen kann. Die va_list ist dabei die angreifbare Form von ...

... kann man schwer verwenden. Man muss ... in etwas umwandeln dass man angreifen kann. Die va_list ist dabei die angreifbare Form von ...

?!?

Könntest du das in Code ausdrücken? Bzw. hier ergänzen.

#include <cstdarg>
#include <vector>

class A{
private:
	std::vector<double> vals;
public:
	A(int size, va_list vl);
};

A::A(int size, va_list vl){
	va_start(vl, size);
	vals.push_back(va_arg(vl,double));
	va_end(vl); 
}

class B : public A{ public: B(int size, va_list vl ); };

B::B(int size, va_list vl):A(size, vl){ }

int main(){
	va_list vl()
	B classb(3,va_list(1.0,2.0,3.0));
}

B* makeB (int size, ...) {
   va_list ap;
   return new B (size, ap);
}

aber das ist alles mist mit diesen va_lists in konstruktoren.

Könntest du das in Code ausdrücken? Bzw. hier ergänzen.

Ah, ich sehe was du meinst.
Ja, da muss man wohl auf eine init() Funktion zurueck greifen, da man die va_list nicht in der initliste definieren kann.
Oder eine globale Variable verwenden.

#include <cstdarg>
#include <vector>
va_list helper;

class A{
private:
    std::vector<double> vals;
public:
    A(int size, va_list vl);
};

A::A(int size, va_list vl){
    vals.push_back(va_arg(vl,double));
}

class B : public A{ public: B(int size, ...); };

B::B(int size, ...):A(size, (va_start(helper,size),helper)){ }

int main(){
    B classb(3,1.0,2.0,3.0);
}

gewinnt aber wohl keine Preise.

Besser doch boost.Assign oder inline_container verwenden.

Oder eine globale Variable verwenden.

nee voll nicht, lieber eine funktion.

Ich möchte nun, dass die variable Argumentliste bei der Definition von InjectionCheat an ToggleCheat weitergereicht wird. Ist das überhaupt möglich? Wenn ja, wie?

Ellipsen sich nicht typsicher und daher grundsätzlich zu vermeiden. Sie sind Teil von C++ um mit C kompatibel zu sein. Also, denke Dir eine Alternative Lösung aus - ohne Ellipsen.

nee voll nicht, lieber eine funktion.

Das habe ich mir am Anfang gedacht, dass man die va_list einfach über eine Funktion befüllen kann - aber ich bin auf keine Lösung gekommen.

Hast du eine?

PS:
Wie man das ohne Ellipsen machen kann habe ich bereits gepostet.

DrGreenthumb schrieb:

nee voll nicht, lieber eine funktion.

Das habe ich mir am Anfang gedacht, dass man die va_list einfach über eine Funktion befüllen kann - aber ich bin auf keine Lösung gekommen.

Hast du eine?

PS:
Wie man das ohne Ellipsen machen kann habe ich bereits gepostet.

Unter C weiß ich zumindest dass so ein Vorgehen nicht vorgesehen ist.
Unter C++ existiert es nur aus Kompatibilitätsgründen.
In GNU C++ ist es soweit ich weiß auf dem sterbenen Ast (deprecated).
Es lässt sich auch in C bequem durch die Übergabe eines Arrays umgehen.

//Deklaration
typ in_vect(typ vect[], int size); // Eindimensional
typ in_matrix(typ matrix[][dim2], int size); // Mehrdimensional
//Aufruf
in_vect(typ *vect,sizeof(vect)/sizeof(vect[0]); //Eindimensional
in_matrix(typ *matrix[dim2],dim1); // Mehrdimensioinal

Unter C weiß ich zumindest dass so ein Vorgehen nicht vorgesehen ist.
Unter C++ existiert es nur aus Kompatibilitätsgründen.
In GNU C++ ist es soweit ich weiß auf dem sterbenen Ast (deprecated).
Es lässt sich auch in C bequem durch die Übergabe eines Arrays umgehen.

Ein Array ist kein Ersatz für variadic Funktionen. Zumindest nicht immer.

Die korrekte Lösung habe ich ja bereits gepostet:
Boost.Assign oder inline_container
oder eben Boost.Format ansehen - aber da habe ich keine Ahnung wie die Technik dahinter aussieht.

DrGreenthumb schrieb:

nee voll nicht, lieber eine funktion.

Das habe ich mir am Anfang gedacht, dass man die va_list einfach über eine Funktion befüllen kann - aber ich bin auf keine Lösung gekommen.

Hast du eine?

PS:
Wie man das ohne Ellipsen machen kann habe ich bereits gepostet.

ich bezog mich hierauf:

Ah, ich sehe was du meinst.
Ja, da muss man wohl auf eine init() Funktion zurueck greifen, da man die va_list nicht in der initliste definieren kann.
Oder eine globale Variable verwenden.

[ lange, ganz schlechte "lösung" mit globaler hilfs-variable ]