如何在C++中通过引用返回类对象？

Question

我有一个名为Object的类，它存储一些数据。

我想使用以下函数通过引用返回它：

    Object& return_Object();

然后，在我的代码中，我会这样调用它：

    Object myObject = return_Object();

我编写了以下代码并且它编译通过。但是，当我运行该代码时，我总是收到一个"seg fault"错误。正确的返回类对象的引用方式是什么？

- user788171

---

我的对象不应该是一个引用吗？ - Ivaylo Strandjev

你可以在这里找到答案： https://dev59.com/mnA75IYBdhLWcg3wVneI - MOHRE

你可以在这里找到返回对象的方法：https://dev59.com/mnA75IYBdhLWcg3wVneI - MOHRE

Answer 1

您可能正在返回一个在堆栈上的对象。也就是说，return_Object() 可能看起来像这样：

Object& return_Object()
{
    Object object_to_return;
    // ... do stuff ...

    return object_to_return;
}

如果您正在这样做，那么很遗憾 - object_to_return已经超出了作用域并在return_Object的结尾被破坏，因此myObject引用一个不存在的对象。您需要按值返回，或者返回一个在更宽的范围内声明的Object或在堆上new出来的Object。

- Chowlett

Answer 2

你只能使用

     Object& return_Object();

如果返回的对象具有比函数更大的作用域，例如，如果您有一个封装了该对象的类，则可以使用它。如果在函数中创建对象，请使用指针。如果想修改现有对象，请将其作为参数传递。

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

- UmNyobe

---

但是，如果在我的调用代码中我说：MyClass mc; Object outsideObj = mc.return_Object;，那会发生什么呢？ 如果我修改 outsideObj 的属性，是否会实际修改封装在 mc 中的 myObj？ - livefree75

对象 outsideObj = mc.return_Object(); 将引发实例 outsideObj 的复制构造。它现在是一个独立的实例，修改其中一个是否会影响另一个取决于复制构造函数的实现方式。 - UmNyobe

Answer 3

你只能通过引用返回非本地对象。析构函数可能已经使一些内部指针失效，或者其他情况。

不要害怕返回值 -- 这很快！

- spraff

Answer 4

我会给你展示一些例子：

第一个例子，不要返回局部作用域对象，例如：

const string &dontDoThis(const string &s)
{
    string local = s;
    return local;
}

你不能通过引用返回 local，因为 local 在 dontDoThis 函数体结束时被销毁。

第二个例子，可以通过引用返回：

const string &shorterString(const string &s1, const string &s2)
{
    return (s1.size() < s2.size()) ? s1 : s2;
}

在这里，你可以通过引用返回s1和s2，因为它们在调用shorterString之前已经定义。

第三个例子：

char &get_val(string &str, string::size_type ix)
{
    return str[ix];
}

使用代码如下：

string s("123456");
cout << s << endl;
char &ch = get_val(s, 0); 
ch = 'A';
cout << s << endl; // A23456

get_val 可以通过引用返回 s 的元素，因为调用之后 s 仍然存在。

第四个示例

class Student
{
public:
    string m_name;
    int age;    

    string &getName();
};

string &Student::getName()
{
    // you can return by reference
    return m_name;
}

string& Test(Student &student)
{
    // we can return `m_name` by reference here because `student` still exists after the call
    return stu.m_name;
}

用法示例：

Student student;
student.m_name = 'jack';
string name = student.getName();
// or
string name2 = Test(student);

第五个例子：

class String
{
private:
    char *str_;

public:
    String &operator=(const String &str);
};

String &String::operator=(const String &str)
{
    if (this == &str)
    {
        return *this;
    }
    delete [] str_;
    int length = strlen(str.str_);
    str_ = new char[length + 1];
    strcpy(str_, str.str_);
    return *this;
}

你可以像下面这样使用上面的 operator= ：

String a;
String b;
String c = b = a;

- Jayhello

Answer 5

嗯，这段代码可能不是非常漂亮的解决方案，但在你的功能界面上真的非常美丽，并且也非常有效率。如果第二个因素更重要（例如，您正在开发一个库），那么这非常理想。

诀窍在于：

1. 一行代码 A a = b.make(); 会被内部转换为 A 的构造函数，就好像你写了 A a(b.make())。
2. 现在 b.make() 应该返回一个带有回调函数的新类。
3. 整个过程可以只通过类很好地处理，没有任何模板。

这是我的最小示例。请只检查 main()，因为它很简单。内部不是。

从速度的角度来看：一个 Factory::Mediator 类的大小仅为 2 个指针，比 1 大但不超过 1。而这是整个过程中唯一按值传递的对象。

#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;
}

- peterh

Answer 6

将已初始化的对象作为返回值并不是一个好的实践，因为它会超出范围。有时候这是期望的选项，但这种情况很少见。如果类是引用计数智能指针或其他智能指针，则实际上可以这样做。 引用计数智能指针的引用计数是如何工作的？

- firefox256