Variable Argumentliste im Vererbungskonstruktor weiterreichen?



  • Huhu!
    Ich habe folgende abstrakte Klasse:

    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?



  • Hast du es mit:

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

    Probiert?

    Nachtrag:
    Nein geht doch nicht.





  • Was spricht eigentlich dagegen einen Vector durchzureichen?





  • 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?!



  • 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...



  • Shade Of Mine schrieb:

    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.



  • Nun, mein Problem ist folgendes:

    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.



  • Stephan86 schrieb:

    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?





  • 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.

    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().



  • Shade Of Mine schrieb:

    @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?



  • Stephan86 schrieb:

    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



  • Stephan86 schrieb:

    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);
    


  • darkfate schrieb:

    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 ...



  • Shade Of Mine schrieb:

    ... 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));
    }
    


  • naja, prinzipiell:

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

    aber das ist alles mist mit diesen va_lists in konstruktoren.



  • darkfate schrieb:

    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.



  • Shade Of Mine schrieb:

    Oder eine globale Variable verwenden.

    nee voll nicht, lieber eine funktion.


Log in to reply