1. The example like that will not work, since GTAClient& worker is a non-const reference which can't take a temporary, but well, it might have been written pre-standard or a typo, whatever, that's not my point.
2. What makes me wonder is what he is going to do with the worker reference, even if Problem 1. is ignored.
   Obviously the intention is to have MyWorker used in the NVI of GenericTableAlgorithm accessed by GTAClient (polymorphic) interface; this rules out that the implementation owns a (value)member of type GTAClient, since that would cause slicing etc. value-semantics don't mix well with polymorphism.
   It cannot have a data member of type MyWorker either since that class is unknown to GenericTableAlgorithm.
   So I conclude it must have been meant to be used via pointer or reference, preserving the original object and polymorphic nature.
3. Since pointers to temporary objects (MyWorker()) are rarely a good idea, i assume the author's plan was to use the extended life-time of temporaries bound to (const) references, and store such a reference in the object pimpl_ points to and use it from there. (Note: there is also no clone-member function in GTAClient, which could have made this work; let's not assume there is a RTTI-typeinfo-based Factory lurking in the background.)
   And here (finally!) my question sets in:(How) can passing a temporary to to a class' reference member with extended life-time be done legally ?

The standard in §12.2.5(the C++0x version but it's the same in C++, don't know about the chapter number) makes the following exception from lifetime extension: "-A temporary bound to a reference member in a constructor’s ctor-initializer (12.6.2) persists until the constructor exits."

Therefore the object cannot be used in the call of the client code a.Process(); because the referenced temporary from MyWorker() is already dead!

Consider now an example of my own crafting that demonstrates the problem (tested on GCC4.2):

#include <iostream>
using std::cout; 
using std::endl;

struct oogie {
 ~oogie()
 {
  cout << "~oogie():" << this << ":" << m_i << endl;
 }
 oogie(int i_)
  : m_i(i_)
 {
  cout << "oogie():" << this << ":" << m_i << endl;
 }

 void call() const
 {
  cout << "call(): " << this << ":" << m_i << endl;
 }
 int m_i;
};

oogie func(int i_=100)
{
 return oogie(i_);
}

struct kangoo 
{
 kangoo(const oogie& o_)
 : m_o(o_)
 {
 }

 const oogie& m_o;
};

int main(int c_, char ** v_)
{

 //works as intended
 const oogie& ref = func(400);
 //kablewy machine
 kangoo s(func(1000));

 cout << ref.m_i << endl;

 //kangoo's referenced oogie is already gone
 cout << s.m_o.m_i << endl;

 //OK, ref still alive
 ref.call();
 //call on invalid object
 s.m_o.call();

 return 0;
}

产生输出

oogie():0x7fff5fbff780:400
oogie():0x7fff5fbff770:1000
~oogie():0x7fff5fbff770:1000
400
1000
call(): 0x7fff5fbff780:400
call(): 0x7fff5fbff770:1000
~oogie():0x7fff5fbff780:400

您可以看到，在 const oogie& ref 的情况下，func() 的立即绑定(bind)到引用的临时返回值具有延长的所述引用的生命周期(直到 main 结束)，所以没关系。
但是:1000-oogie 对象在 kangoo-s 构造完成后就已经被销毁了。代码有效，但我们在这里处理的是一个不死物体......

所以再次提出问题:
首先，我是否遗漏了什么代码是否正确/合法？。
其次，为什么 GCC 没有给我警告，即使指定了 -Wall？应该吗？可以吗？

谢谢你的时间，
马丁