Passing ownership of stack object without duplication

Question

A third-party library has the API Huge computeHuge(). It returns the object itself, not a reference/pointer. I have no control over the object or the API.

I've got two classes:

class Bar {
  Huge h;
  Bar(Huge &huge): h(huge);
}

class Foo {
  Bar b;

  Foo() {
    Huge h = computeHuge();
    b = Bar(h);
  }

Unfortunately, this design results (temporarily) in two copies of a huge object: one copy exists in the Foo constructor, and another exists inside the Bar object. Once the Foo constructor exits, there is only one copy, but I need double the memory inside the constructor. Since h could be hundreds of GB, this matters.

One solution to this problem is to make Foo the owner of h:

class Bar {
  Huge &h;
  Bar(Huge &huge): h(huge);
}

class Foo {
  Bar b;
  Huge h;

  Foo() {
    h = computeHuge();
    b = Bar(h);
  }

This does successfully eliminate having two copies of h, but it doesn't really make sense in my application: Baris the Right Thing to hold h. How can I:

1. Call computeHuge() in the Foo constructor
2. Let Bar retain ownership of h
3. All without ever needing two copies of h in memory?

Answer 1

If Huge is moveable, this does not make any copies:

class Bar {
  Huge h;
  Bar(Huge huge): h(std::move(huge)) {}   // move huge into its final place, h
};

class Foo {
  Bar b;

  Foo() {
    Huge h = computeHuge();
    b = Bar(std::move(h));   // move h into constructor argument
    // h cannot be used here anymore
  }
};

For debugging purposes, this is a (tiny) Huge which can not be copied, but only moved. Every attempt to copy is a compiler error:

struct Huge {
    Huge() = default;
    Huge(Huge&& other) { std::cout << "move "; }
    Huge(const Huge& other) = delete;
    Huge& operator=(Huge&& other) { std::cout << "move= "; return *this; }
    Huge& operator=(const Huge& other) = delete;
};