Returning a Reference to a Stack Object

 #include <iostream.h>  class Point {  int x, y;  char* color; public:  Point(int = 0, int = 0, char* = ''Red'');  ~Point();  Point (const Point&);  void print();  const Point& operator=(const Point&);  const Point& operator+(const Point&); }; void Point::print() {  cout << ''I live at ('';  cout <<x<<'', ''<<y<<'') and '';  cout << ''I'm'' << color <<''.\n"; } const Point& Point::operator=(const Point& rhs) {  x = rhs.x; y = rhs.y;  delete color;  color = new char[strlen(rhs.color)+1];  strcpy(color, rhs.color); } // This function returns a hidden pointer // (i.e., a reference) to a temporary Point // object that will be destroyed upon return // from the function. const Point& Point::operator+(const Point& rhs) {  Point temp;  temp.x = x + rhs.x; temp.y = y + rhs.y;  delete temp. color; // Not exactly a good color-mixing scheme!  temp.color = new char[strlen(color)+strlen(rhs.color)+1];  sprintf(temp.color, ''%s%s'', color, rhs.color);  return(temp); main()} {  Point p1(10, 10, ''Blue'');  Point p2(20, 60, ''Green''); // The copy constructor is receiving a destroyed // Point object as an argument since the operator+ // function returns a hidden pointer to the // automatic variable temp. This variable had its // destructor called upon exit from operator+.  Point p3 = p1 + p2;  p3.print(); } 

Another attempt at a solution to this problem is to make the temporary Point object of internal static storage class. An internal static object is not created and destroyed upon entrance /exit from the function; it simply goes in and out of scope. This code will work fine, provided the operator is never used in a nested function call. Of course, one can imagine all sorts of uses for nesting addition operators. The C++ statement x+y+z is one of the more mundane yet valid examples. Because each call to operator+ uses exactly the same temporary Point object, the nested calls will stomp the memory of each other.