Почему создаются новые объекты?

class data 
{
    char* str;
public:
    data(): str("Hi")
    {}
    data(char* ch): str(ch)
    {}
    void setData(char* ch)
    {
        str = ch;
    }
    void printData()
    {
        cout << str << endl;
    }
    virtual ~data ()
    {
        cout << "data deleted\n";
    }
    data& operator= (data& v)
    {
        str = v.str;
        return *this;
    }
};

    data operator= (data& v)
    {
        str = v.str;
        return *this;
    }

    data operator= (data& v)
    {
        str = v.str;
        return data(str);
    }

 
 data operator= (data& v)
{
        str = v.str;
        return *this;
}

* * * * data operator= (data& v)
* * * * {
* * * * * * * * str = v.str;
* * * * * * * * return data(str);
* * * * }

#include <cstdio>
#include <cstring>
 
class Data {
 public:
  Data() : string_(NULL) {}
  explicit Data(const char *string) : string_(NULL) {
    SetData(string);
  }
  ~Data() {
    printf("Debug: Calling destructor %d, '%s'.\n", (int)this, string_);
    delete string_;
  }
  void SetData(const char *string) {
    delete string_;
    string_ = strcpy(new char[strlen(string) + 1], string);
  }
  char *GetData() const { return string_; }
  Data &operator=(const Data &other) {
    if (this != &other)
      SetData(other.GetData());
    return *this;
  }
 private:
  char *string_;
};
 
int main(int argc, char *argv[]) {
  Data a("world!"), b("Hello"), c;
  c = a;
  a = b;
  b = c; // Меняем местами a и b;
  printf("%s %s\n", a.GetData(), b.GetData());
  return 0;
}

data operator= (data& v)
{
        str = v.str;
        return *this; // возвращаем по значению, то бишь копию *this
}

  
void SetData(const char *string) {
    delete string_;
    string_ = strcpy(new char[strlen(string) + 1], string);
 }

        data operator= (data& v)
        {
                str = v.str;
                return data(str);
        }

data operator= (data& v)
{
        str = v.str;
        return *this;
}

data operator= (data& v)
{
        str = v.str;
        return data (str);
}

data operator= (data& v)
{
    str = v.str;
    data temporary_object(str);
    return temporary_object;
}

  // предположим, есть char  *string, содержащий "123\0";
  char *a = string;
  // варианты выстрелить себе в ногу:
  srting[0] = '\0'; // изменив строку
  delete [] string; // или даже освободив память
  printf("%s\n", a); // ?????????

#include <iostream>
 
using namespace std;
 
class data 
{
    char* str;
public:
    data(): str("Hi")
    {
    }
 
    data(char* ch): str(ch)
    {
    }
    
    data(const data &original):
    str(original.str)
    {
    }
 
    void setData(char* ch)
    {
        str = ch;
    }
    
    void printData()
    {
        cout << str << endl;
    }
    
    virtual ~data ()
    {
        cout << "data deleted\n";
    }
    
    data operator=(data& v)
    {
        str = v.str;
 
        data temporary_object(str);
 
        return temporary_object;
    }
};
 
int main()
{
    data d1("Hello");
    data d2("World");
 
    d1.printData();
    d2.printData();
 
    d1 = d2;
 
    d1.printData();
    d2.printData();
 
    return 0;
}