Re: std::pair, segmentation fault, why?

If Obj is a move-enabled type you don't have to do anything special in
your factory function. That's the beauty of it:

Obj factory_make_big_obj()
{
 ...
  Obj result...
  ...
  return result;
}

...
Obj b = factory_make_big_obj();

It's all taken care of automatically. No unnecessary copying will be
done here. That's guaranteed! You don't have to write your function to
return an rvalue reference. In fact you *should* not do so.

If you want polymorphism and/or deal with a type that is NOT
efficiently movable you can also write things like this in C++0x:

std::unique_ptr<Obj> factory_make_big_obj()
{
 ...
  unique_ptr<Obj> result...
  ...
  return result;
}

...
unique_ptr<Obj> up = factory_make_big_obj();

If you later decide to share ownership of the pointed-to object you
can use a conversion from unique_ptr to shared_ptr or directly create
a shared_ptr using std::make_shared.

Anyhow, there is no need here to explicitly use rvalue references or
even std::move here. In most cases, rvalue references are just needed
by class authors so they can provide a move constructor to make their
types efficiently movable. And I didn't use std::move here because
it's not necessary. If you return a function-local object like
'result' (see above) the compiler will try the following:
1. Elide the copy/move and be done.
2. If that's not possible, look for a move constructor and use it
for constructing the return value.
3. If there is no move constructor, use the copy constructor
for constructing the return value.

Cheers!
SG