Must disable operator= for move to work right.

The issue: use C++0x std::move for containers to allow me to add
non-copyable objects to maps.

The problem: my attempt to use the insert syntax of
   myMap["two"] = foo(2);
didn't work and I had to use the syntax
   myMap.insert( std::pair<std::string, foo>( "two", foo(2) ));
to get the expected result.

The following compilable in Microsoft Express 2010 demonstrates the issue.
Compiled as is we get the output line
2 foo Destructor
twice instead of only once as desired.

Has it always been a rule that a non-copyable class is non assignable or is
this something that has just become a problem? Looking at the code,
however, I really don't know why in the heck the program is moving 0's
around insted of 2's.

#include <vector>
#include <iostream>
#include <map>
#include <string>

#define USEMOVE
//#define USEINSERT
//#define DISABLEASSIGNMENT

class foo {
public:
   foo(): i(0) {
      std::cout << i << " foo() DEFAULT Constructor\n";
   }
   virtual ~foo() {
      std::cout << i << " foo Destructor\n";
      i = -1;
   }
   foo( int i ): i(i) {
      std::cout << i << " foo( int ) Constructor\n";
   }
#ifdef USEMOVE
   foo( foo&& rhs ) {
      i = rhs.i;
      rhs.i = -1;
      std::cout << i << " foo( foo&& ) MOVE Constructor\n";
   }
#endif
   int i;
#ifdef DISABLEASSIGNMENT
private:
#endif
   foo& operator=( const foo& rhs ) {
      i = rhs.i;
      std::cout << i << " foo& operator=( const foo& ) ASSIGNMENT
Operator\n";
      return *this;
   }
private:
   foo( const foo& f ) {
      i = f.i;
      std::cout << i << " foo( const foo& ) COPY Constructor\n";
   }
};

std::map< std::string, foo > myMap;

int main() {

#ifdef USEINSERT
   myMap.insert( std::pair<std::string, foo>( "two", foo(2) ));
#else
   myMap["two"] = foo(2);
#endif

}

OUTPUT:

2 foo( int ) Constructor
0 foo() DEFAULT Constructor
0 foo( foo&& ) MOVE Constructor
0 foo( foo&& ) MOVE Constructor
-1 foo Destructor
-1 foo Destructor
2 foo& operator=( const foo& ) ASSIGNMENT Operator
2 foo Destructor
2 foo Destructor

When I change the flags to:
I get the desired output

2 foo( int ) Constructor
2 foo( foo&& ) MOVE Constructor
2 foo( foo&& ) MOVE Constructor
-1 foo Destructor
-1 foo Destructor
2 foo Destructor