为什么在这种情况下不调用移动构造函数？

我一直在关注这篇文章《每个C++开发人员都应该使用的十个C++11特性》，并在Move语义示例的代码中添加了一些基本的跟踪，发现Move构造函数从未被调用，并想知道为什么。我试过GNU 4.6.3和英特尔15.0.0这两个编译器，结果是一样的。

我这样编译它：

# using Intel compiler
icpc -Wall -g -Wno-shadow -std=c++0x -o showcase ./showcase.cpp
# using gnu g++ compiler
g++ -Wall -g -Wno-shadow -std=gnu++0x -o showcase ./showcase.cpp

这是我在第133行得到的移动构造函数不被调用的输出：

instantiating b1 ...
Buffer() default constructor invoked 
my name is: 
instantiating b2 ...
Buffer(const std::string& name, size_t size) constructor invoked 
my name is: buf2
instantiating b3 ...
Buffer(const Buffer& copy) copy constructor invoked 
my name is: buf2
instantiating b4 ...
Buffer(const std::string& name, size_t size) constructor invoked 
my name is: buf64
moving getBuffer<int>("buf5") to b1 ...
Buffer(const std::string& name, size_t size) constructor invoked 
Buffer& operator=(Buffer&& temp) move assignment operator invoked
my name is: buf5

这是代码：

#include <assert.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <map>
#include <vector>
#include <memory>
#include <algorithm>
using namespace std;
//============================================================================
// Classes
//============================================================================
template <typename T>
class Buffer 
{
   std::string          _name;
   size_t               _size;
   std::unique_ptr<T[]> _buffer;
public:
   // default constructor
   Buffer():
      _size(16),
      _buffer(new T[16]) {
      cout << "Buffer() default constructor invoked " << endl;
   }
   // constructor
   Buffer(const std::string& name, size_t size):
      _name(name),
      _size(size),
      _buffer(new T[size]) {
      cout << "Buffer(const std::string& name, size_t size) constructor invoked " << endl;
   }
   // copy constructor
   Buffer(const Buffer& copy):
      _name(copy._name),
      _size(copy._size),
      _buffer(new T[copy._size])
   {
      cout << "Buffer(const Buffer& copy) copy constructor invoked " << endl;
      T* source = copy._buffer.get();
      T* dest = _buffer.get();
      std::copy(source, source + copy._size, dest);
   }
   void print_name() const {
        cout << "my name is: " << _name << endl;
   }
   // copy assignment operator
   Buffer& operator=(const Buffer& copy)
   {
      cout << "Buffer& operator=(const Buffer& copy) assignment operator invoked " << endl;
      if(this != &copy)
      {
         _name = copy._name;
         if(_size != copy._size)
         {
            _buffer = nullptr;
            _size = copy._size;
            _buffer = _size > 0 ? new T[_size] : nullptr;
         }
         T* source = copy._buffer.get();
         T* dest = _buffer.get();
         std::copy(source, source + copy._size, dest);
      }
      return *this;
   }
   // move constructor
   Buffer(Buffer&& temp):
      _name(std::move(temp._name)),
      _size(temp._size),
      _buffer(std::move(temp._buffer))
   {
      cout << "Buffer(Buffer&& temp) move constructor invoked" << endl;
      temp._buffer = nullptr;
      temp._size = 0;
   }
   // move assignment operator
   Buffer& operator=(Buffer&& temp)
   {
      cout << "Buffer& operator=(Buffer&& temp) move assignment operator invoked" << endl;
      assert(this != &temp); // assert if this is not a temporary
      _buffer = nullptr;
      _size = temp._size;
      _buffer = std::move(temp._buffer);
      _name = std::move(temp._name);
      temp._buffer = nullptr;
      temp._size = 0;
      return *this;
   }
};
template <typename T>
Buffer<T> getBuffer(const std::string& name) {
   Buffer<T> b(name, 128);
   return b;
}
//============================================================================
// Main
//============================================================================
int main(int argc, char** argv) {
    cout << "**************** move semantics" << endl;
    cout << "instantiating b1 ..." << endl;
    Buffer<int> b1;
    b1.print_name();
    cout << "instantiating b2 ..." << endl;
    Buffer<int> b2("buf2", 64);
    b2.print_name();
    cout << "instantiating b3 ..." << endl;
    Buffer<int> b3 = b2;
    b3.print_name();
    cout << "instantiating b4 by moving from a temp object ..." << endl;
    Buffer<int> b4 = getBuffer<int>("buf64"); // Buffer<int>("buf4", 64);
    b4.print_name();
    cout << "moving getBuffer<int>("buf5") to b1 ..." << endl;
    b1 = getBuffer<int>("buf5");
    b1.print_name();
    return EXIT_SUCCESS;
}