View difference between Paste ID: jKp7t1aT and 5tfNUTu6

 	class Shape;
 
 	typedef std::unique_ptr<Shape> shape_ptr;
 
 	class Shape{
 
 		public:
 			Shape(){};
 			virtual ~Shape(){};
 
 			virtual void draw() const = 0;
 			virtual float area() const = 0;
 
 			virtual shape_ptr clone() const = 0;
 			virtual shape_ptr create() const = 0;
 	};
 
 	class Rectangle:public Shape{
 		public:
 
 			Rectangle(int height=0, int width=0):m_Height(height),m_Width(width){};
 			~Rectangle(){};
 
 			virtual void draw() const;
 			virtual float area() const;
 
 			virtual shape_ptr clone() const{ return shape_ptr(new Rectangle(*this)); };
 			virtual shape_ptr create() const{ return shape_ptr(new Rectangle()); };
 
 		private:
 			int m_Height;
 			int m_Width;
 	};
 
 
 	class Circle:public Shape{
 		public:
 
 			Circle(float radius=0):m_Radius(radius){};
 			~Circle(){};
 
 			virtual void draw() const;
 			virtual float area() const;
 
 			virtual shape_ptr clone() const{ return shape_ptr(new Circle(*this)); };
 			virtual shape_ptr create() const{ return shape_ptr(new Circle()); };
 
 		private:
 			float m_Radius;
 	};
 
 	class ShapeContainer{
 
 		public:
 
 			typedef std::unique_ptr<Shape> ShapePtr;
 			typedef std::vector<ShapePtr> ShapePtrContainer;
 
 			ShapeContainer(){};
 			ShapeContainer( ShapeContainer && );
 			ShapeContainer( const ShapeContainer & );
 			~ShapeContainer(){};
 
 			const ShapePtr & at(int ) const;
 
 			ShapeContainer & operator = (ShapeContainer&&);
 			int size() const{ return static_cast<int>(m_vect.size()); };
 
 			friend ShapeContainer createBasicShapes();
 			friend ShapeContainer createComplexShapes();
 
 			friend void swap(ShapeContainer& x, ShapeContainer& y) {x.m_vect.swap(y.m_vect);}
 
 		private:
 
 			ShapePtrContainer m_vect;
 	};
 
-	class Foo{
+	class FooObj{
 
 		public:
 
-			Foo(){};
+			FooObj(){};
-			Foo( const ShapeContainer & );
+			FooObj ( FooObj && );
-			~Foo(){};
+			FooObj( const ShapeContainer & );
 			FooObj ( const FooObj & );
 			~FooObj(){};
 
 			FooObj & operator = (FooObj && );
 
 			void drawShapes() const;
 
 
 		private:
 			ShapeContainer m_container;
 	};
-		std::cout << "draw rectangle!\n";
+
 	class FooRef{
 
 		public:
 
-		std::cout << "this is the Rectangle's area: " << area << "\n";
+			typedef std::unique_ptr<ShapeContainer> uptr;
 
 			FooRef(){};
 			FooRef( const ShapeContainer & );
 			FooRef( const FooRef & );
-		std::cout << "draw circle!\n";
+			~FooRef(){};
 
 			FooRef & operator = (const FooRef & );
 
 			void drawShapes() const;
-		std::cout << "this is the Circle's area: " << area << "\n";
+
 		private:
 			uptr m_container;
 
 	};
 
 	void Rectangle::draw() const{
 		std::cout << "draw rectangle at address: " << this << std::endl;
 	}
 
 	float Rectangle::area() const{
 		float area = static_cast<float>(m_Height*m_Width);
 		std::cout << "this is the Rectangle's area: " << area << std::endl;
 		return area;
 	}
 
 	void Circle::draw() const{
 		std::cout << "draw circle at address: " << this << std::endl;
 	}
 
 	float Circle::area() const{
 		float area = static_cast<float>(m_Radius*2*3.1415);
 		std::cout << "this is the Circle's area: " << area << std::endl;
 		return area;
 	}
 
 	ShapeContainer::ShapeContainer(ShapeContainer && other)
 		:m_vect(std::move(other.m_vect))
 	{
 
 	}
 
 	ShapeContainer & ShapeContainer::operator = (ShapeContainer&& other){
 		m_vect = std::move(other.m_vect);
 		return (*this);
 	}
 
 	ShapeContainer::ShapeContainer( const ShapeContainer & other ){
-	Foo::Foo( const ShapeContainer & cont )
+
 			m_vect.push_back(other.m_vect[i]->clone());
 		}
 	}
 
 	ShapeContainer createBasicShapes(){
-	void Foo::drawShapes() const{
+
 		cont.m_vect.push_back(ShapeContainer::ShapePtr(new Circle()));
 		cont.m_vect.push_back(ShapeContainer::ShapePtr(new Rectangle()));
 		return cont;
 	}
 
 	ShapeContainer createComplexShapes(){
 		ShapeContainer cont;
-		Foo myfoo(createBasicShapes());
+
 		return cont;
 	}
 
-
+
-
+
 	}
 
 	FooObj::FooObj( const ShapeContainer & cont )
 		:m_container(cont)
 	{
 
 	}
 
 	FooObj::FooObj( const FooObj & other)
 		:m_container(other.m_container)
 	{
 
 	}
 
 	FooObj & FooObj::operator = ( FooObj && other ){
 		m_container = std::move(other.m_container);
 		return (*this);
 	}
 
 	void FooObj::drawShapes() const{
 
 		for(int i=0; i < m_container.size(); i++){
 			m_container.at(i)->draw();
 		}
 	}
 
 	FooRef::FooRef( const ShapeContainer & shapec )
 		:m_container( uptr(new ShapeContainer(shapec)))
 	{
 
 	}
 
 	void FooRef::drawShapes() const{
 
 		for(int i=0; i < m_container->size(); i++){
 			m_container->at(i)->draw();
 		}
 	}
 
 	int main(int argc, char ** argv){
 
 		ShapeContainer mycontainer = createBasicShapes();
 		cout << "hi" << endl;
 
 		FooObj myfoo(createBasicShapes());
 		myfoo.drawShapes();
 
 		FooObj myfoo2 = myfoo;
 		myfoo2.drawShapes();
 
 		return (EXIT_SUCCESS);
 
 	}