C / C++ / MFC

<br />
string s1 = "the truth is out there";<br />

<br />
string s1("the truth is out there";<br />

string()
{
  data = NULL;
}

string()
{
  delete[] data;
  data = NULL;
}

string(const string& rhs)
{
  //C: Verify that the rhs string exists.
  if (rhs.data)
  {
  //C: Get the length of the string.
    UINT nLen = strlen(rhs.data);
  //C: Allocate space for the data element.
    data = new char[nLen+1];
  //C: copy rhs into data.
    strcpy(data, rhs.data);
  }
  else
  {
  //C: rhs.data does not exist, therefore the string will go uninitialized.
    data = NULL;
  }
}

string &operator=(const string& rhs)
{
  //C: Check if rhs, is actually this object, ie. s1 = s1;
  if (this == &rhs)
  {
  //C: return a reference to this object.
  //   This will perpetuate things in C++ like a = b = c;
    return *this;
  }
  //C: Delete the old data associated with this object.
  //   Note, the code in this section is the same as the code in the destructor.
  delete[] data;

  //C: Note, the code in this section is the same as the code in the copy constructor.
  //   I usually put this common code in a private member function and share it between
  //   the two functions.
  //C: Verify that the rhs string exists.
  if (rhs.data)
  {
  //C: Get the length of the string.
    UINT nLen = strlen(rhs.data);
  //C: Allocate space for the data element.
    data = new char[nLen+1];
  //C: copy rhs into data.
    strcpy(data, rhs.data);
  }
  else
  {
  //C: rhs.data does not exist, therefore the string will go uninitialized.
    data = NULL;
  }

  //C: Finally, return a reference to this object.
  //   This will perpetuate things in C++ like a = b = c;
  return *this;
}

string s1 = "the truth is out there";

1. A temporary object is constructed from "the truth is out there" using string::string(const char *).
   
2. s1 is constructed from this temporary object using the copy ctor.

string s1 = "the truth is out there";
string s1 ("the truth is out there");

class A
{
  public:
    A(const char *)
    {
    }
  private:
    A(const A&);
};
 
int main()
{
  A a="hello";
  return 0;
}

string s1 = "the truth is out there";
string s1 ("the truth is out there");

template<class T>  
void ptrErase(T * type)
{	
    delete type;
};

template<class T> 
struct ptrErase : public unary_function<T, void>
{
  void operator() (T type) 
  { 
    delete type;
  }
};