Ich da mal eine Frage. Ich würde gerne per Call by Reference einen Pointer auf aufgerufen Instanz selbst zurück geben:

class DemoClass
{
public:
    DemoClass();
    int x;
    void setParam(const DemoClass &param){
           param=this;
    }
};

int main(int argc, char *argv[])
{
    DemoClass *test1,*test2;
    test1->x=1;
    test2->x=2;
    test1->setParam(*test2);
    qDebug() << test1->x;
    qDebug() << test2->x;
};

Geht das? Ich bekomme z.B. folgende Fehlermeldung:
`F:\Programmieren\Detection\main.cpp:28: Fehler: C2678: Bin„rer Operator '=': Es konnte kein Operator gefunden werden, der einen linksseitigen Operanden vom Typ 'const DemoClass' akzeptiert (oder keine geeignete Konvertierung m”glich)

....\Detection\main.cpp(30): kann 'DemoClass &DemoClass::operator =(const DemoClass &)' sein

bei Anpassung der Argumentliste '(const DemoClass, DemoClass *)'`

param ist const, daher kannst du ihm nichts zuweisen.
this is ein Pointer, mit *this kriegst du eine Referenz auf das aktuelle Objekt.

class DemoClass
{
public:
    DemoClass();
    int x;
    void setParam(DemoClass &param){
           param=*this;
    }
};

int main(int argc, char *argv[])
{
    DemoClass *test1,*test2;
    test1->x=1;
    test2->x=2;
    test1->setParam(*test2);
    qDebug() << test1->x;
    test1->x=99;
    qDebug() << test2->x;
};

Ich würde erwarten (hoffen), dass bei der zweiten Ausgabe "99" ausgegeben wird. Wird so klarer was ich meine?

class DemoClass
{
public:
    DemoClass();
    int x;
    void setParam(DemoClass &param);
};

DemoClass::DemoClass()
{

}

void DemoClass::setParam(DemoClass &param)
{
    param=*this;
}

int main(int argc, char *argv[])
{
    DemoClass *test1 = new DemoClass();
    DemoClass *test2 = new DemoClass();
    test1->x=1;
    test2->x=2;
    test1->setParam(*test2);
    qDebug() << test1->x;
    test1->x=99;
    qDebug() << test2->x;
}

Aber könntest du mir das mit den

dazu musst du wirklich Zeiger verwenden

etwas näher erklären. Ich bin äußerst Schwach auf der Brust was Pointer betrifft.

Vielen Dank im Vorraus (und auch für die bisherigen Antworten).

O.k. Das mit den unitialisierten Zeigern ist sicher schon mal ein Fehler:-)

class DemoClass
{
public:
    DemoClass();
    int x;
    void setParam(DemoClass &param);
};

DemoClass::DemoClass()
{

}

void DemoClass::setParam(DemoClass &param)
{
    param=*this;
}

int main(int argc, char *argv[])
{
    DemoClass *test1 = new DemoClass();
    DemoClass *test2 = new DemoClass();
    test1->x=1;
    test2->x=2;
    test1->setParam(*test2);
    qDebug() << test1->x;
    test1->x=99;
    qDebug() << test2->x;
}

Aber könntest du mir das mit den

dazu musst du wirklich Zeiger verwenden

etwas näher erklären. Ich bin äußerst Schwach auf der Brust was Pointer betrifft.

Wieso verwendest du dann Pointer, wenns unnötig ist (für die beiden Objekte)?
Hier, ich zeigs dir:

class DemoClass
{
public:
    DemoClass();
    int x;
    void setParam(DemoClass* &param); // wir nehmen einen Pointer by Reference
};

DemoClass::DemoClass()
{

}

void DemoClass::setParam(DemoClass* &param)
{
    param=this; // und lassen den auf this zeigen
}

int main(int argc, char *argv[])
{
    //DemoClass *test1 = new DemoClass();
    DemoClass test1; // kein new!
    test1->x=1;
    DemoClass *test2; // Pointer auf DemoClass
    test1.setParam(test2); // lassen wir auf test1 zeigen
    qDebug() << test1->x;
    test1->x=99;
    qDebug() << test2->x;
}

Wobei dafür eine Memberfunktion überflüssig ist, schließlich kann man auch direkt

DemoClass* test2 = &test1;

schreiben.

Vielen Dank im v****** (und auch für die bisherigen Antworten).

Es heißt Voraus. Ein R.

Wobei dafür eine Memberfunktion überflüssig ist

Ist nur ein minimal Beispiel. In meinem Programm durchsuche ich einen Suchbaum und würde das Ergebnis (nach ein paar hundert Zweigen) eben gerne auf diese Weise zurück geben.

Herzlichsten Dank!