Wie man ein Klassenobjekt durch Verweis in C ++ zurückgibt?

Können Sie nur verwenden,

     Object& return_Object();

wenn das zurückgegebene Objekt hat einen größeren Anwendungsbereich als die Funktion. Zum Beispiel, können Sie es verwenden, wenn Sie eine Klasse, wo es gekapselt ist. Wenn Sie ein Objekt erstellen in Ihrer Funktion, die Zeiger verwenden. Wenn Sie möchten, ändern Sie ein vorhandenes Objekt, übergeben es als argument.

  class  MyClass{
      private:
        Object myObj;

      public:
         Object& return_Object() {
            return myObj;
         }

         Object* return_created_Object() {
            return new Object();
         }

         bool modify_Object( Object& obj) {
            // obj = myObj; return true; both possible
            return obj.modifySomething() == true;
         }
   };

InformationsquelleAutor der Antwort UmNyobe

Gut, es ist vielleicht nicht eine wirklich schöne Lösung in den code, aber es ist wirklich schön in die Schnittstelle der Funktion. Und es ist auch sehr effizient. Ideal ist es, wenn die zweite ist noch wichtiger für Sie (zum Beispiel, der Entwicklung einer Bibliothek).

Der trick ist dieser:

1. Eine Linie A a = b.make(); ist intern in einen Konstruktor von A, d.h. als wenn du geschrieben hättest A a(b.make());.
2. Jetzt b.make() Ergebnis sollte eine neue Klasse, mit einer callback-Funktion.
3. Diese ganze Sache kann in Ordnung sein, behandelt nur von Klassen, ohne eine Vorlage.

Hier ist mein minimal-Beispiel. Aktivieren Sie nur die main(), wie Sie sehen können ist es einfach. Die Interna nicht.

Aus der Sicht der Geschwindigkeit: die Größe eines Factory::Mediator Klasse nur 2 Zeiger, die mehr als 1 aber nicht mehr. Und dies ist das einzige Objekt in der gesamten Sache, die übertragen wird, durch den Wert.

#include <stdio.h>

class Factory {
  public:
    class Mediator;

    class Result {
      public:
        Result() {
          printf ("Factory::Result::Result()\n");
        };

        Result(Mediator fm) {
          printf ("Factory::Result::Result(Mediator)\n");
          fm.call(this);
        };
    };

    typedef void (*MakeMethod)(Factory* factory, Result* result);

    class Mediator {
      private:
        Factory* factory;
        MakeMethod makeMethod;

      public:
        Mediator(Factory* factory, MakeMethod makeMethod) {
          printf ("Factory::Mediator::Mediator(Factory*, MakeMethod)\n");
          this->factory = factory;
          this->makeMethod = makeMethod;
        };

        void call(Result* result) {
          printf ("Factory::Mediator::call(Result*)\n");
          (*makeMethod)(factory, result);
        };
    };
};

class A;

class B : private Factory {
  private:
    int v;

  public:
    B(int v) {
      printf ("B::B()\n");
      this->v = v;
    };

    int getV() const {
      printf ("B::getV()\n");
      return v;
    };

    static void makeCb(Factory* f, Factory::Result* a);

    Factory::Mediator make() {
      printf ("Factory::Mediator B::make()\n");
      return Factory::Mediator(static_cast<Factory*>(this), &B::makeCb);
    };
};

class A : private Factory::Result {
  friend class B;

  private:
    int v;

  public:
    A() {
      printf ("A::A()\n");
      v = 0;
    };

    A(Factory::Mediator fm) : Factory::Result(fm) {
      printf ("A::A(Factory::Mediator)\n");
    };

    int getV() const {
      printf ("A::getV()\n");
      return v;
    };

    void setV(int v) {
      printf ("A::setV(%i)\n", v);
      this->v = v;
    };
};

void B::makeCb(Factory* f, Factory::Result* r) {
      printf ("B::makeCb(Factory*, Factory::Result*)\n");
      B* b = static_cast<B*>(f);
      A* a = static_cast<A*>(r);
      a->setV(b->getV()+1);
    };

int main(int argc, char **argv) {
  B b(42);
  A a = b.make();
  printf ("a.v = %i\n", a.getV());
  return 0;
}

InformationsquelleAutor der Antwort peterh