1.定义一个空的类，对其sizeof 其长度为1

2.定义一个还有纯虚函数的类，在32位机器上对其sizeof获得的值为4,在64位系统上获得的值为8。c++的纯虚函数会生成一个虚函数指针

3.定义c++的拷贝构造函数只能传递引用，不能传递其他类型，负责会导致循环调用，程序崩溃。

4.典型程序，代码如下：

  1 #include <iostream>
  2 #include <string>
  3 #include <string.h>
  4 #include <stdio.h>
  5 
  6 class CMyString
  7 {
  8 public:
  9     CMyString(char* pData = NULL);
 10     CMyString(const CMyString& str);
 11     ~CMyString(void);
 12 
 13     CMyString& operator = (const CMyString& str);
 14 
 15     void Print();
 16       
 17 private:
 18     char* m_pData;
 19 };
 20 
 21 CMyString::CMyString(char *pData)
 22 {
 23     if(pData == NULL)
 24     {
 25         m_pData = new char[1];
 26         m_pData[0] = '\0';
 27     }
 28     else
 29     {
 30         int length = strlen(pData);
 31         m_pData = new char[length + 1];
 32         strcpy(m_pData, pData);
 33     }
 34 }
 35 
 36 CMyString::CMyString(const CMyString &str)
 37 {
 38     int length = strlen(str.m_pData);
 39     m_pData = new char[length + 1];
 40     strcpy(m_pData, str.m_pData);
 41 }
 42 
 43 CMyString::~CMyString()
 44 {
 45     delete[] m_pData;
 46 }
 47 
 48 /*
 49 CMyString& CMyString::operator = (const CMyString& str)
 50 {
 51     if(this == &str)  //此处检查是否是其本身，如贵是直接返回
 52         return *this;
 53 
 54     delete []m_pData;
 55     m_pData = NULL;
 56 
 57     m_pData = new char[strlen(str.m_pData) + 1]; //此操作方式不安全，如果分配内存失败，会出现程序崩溃
 58     strcpy(m_pData, str.m_pData);
 59 
 60     return *this;
 61 }*/
 62 
 63 
 64 
 65 CMyString& CMyString::operator =(const CMyString& str)
 66 {
 67     if(this != &str)
 68     {
 69         CMyString str1(str);
 70 
 71         char *tmp = str1.m_pData;  //采用调用其拷贝构造函数的办法，规避其内存分配失败时的异常，应优先采用第二种办法
 72         str1.m_pData = m_pData;
 73         m_pData = tmp;
 74     }
 75 
 76     return *this;
 77 }
 78 
 79 void CMyString::Print()
 80 {
 81     printf("%s", m_pData);
 82 }
 83 
 84 void Test1()
 85 {
 86     printf("Test1 begins:\n");
 87 
 88     char* text = "Hello world";
 89 
 90     CMyString str1(text);
 91     CMyString str2;
 92     str2 = str1;
 93 
 94     printf("The expected result is: %s.\n", text);
 95 
 96     printf("The actual result is: ");
 97     str2.Print();
 98     printf(".\n");
 99 }
100 
101 void Test2()
102 {
103     printf("Test2 begins:\n");
104 
105     char* text = "Hello world";
106 
107     CMyString str1(text);
108     str1 = str1;
109 
110     printf("The expected result is: %s.\n", text);
111 
112     printf("The actual result is: ");
113     str1.Print();
114     printf(".\n");
115 }
116 
117 void Test3()
118 {
119     printf("Test3 begins:\n");
120 
121     char* text = "Hello world";
122 
123     CMyString str1(text);
124     CMyString str2, str3;
125     str3 = str2 = str1;
126 
127     printf("The expected result is: %s.\n", text);
128 
129     printf("The actual result is: ");
130     str2.Print();
131     printf(".\n");
132 
133     printf("The expected result is: %s.\n", text);
134 
135     printf("The actual result is: ");
136     str3.Print();
137     printf(".\n");
138 }
139 
140 int main(int argc, char* argv[])
141 {
142     Test1();
143     Test2();
144     Test3();
145 
146     return 0;
147 }

 5.字符数组与字符指针

 1  #include <iostream>
 2  
 3  using namespace std;
 4  
 5  int main()
 6  {
 7  
 8      char str1[] = "hello";
 9      char str2[] = "hello";
10  
11      if(str1 == str2)
12      {
13          cout<<"str1 == str2"<<endl;
14      }
15      else
16      {
17          cout<<"str1 != str2"<<endl;
18      }
19  
20  
21      char *str3 = "test";
22      char *str4 = "test";
23  
24      if(str3 == str4)
25      {
26          cout<<"str3 == str4"<<endl;
27      }
28      else
29      {
30          cout<<"str3 != str4"<<endl;
31      }
32  
33  
34  }

输出结果如下:

1 /tmp $ ./string 
2 str1 != str2
3 str3 == str4

在c/c++中，会为不同的字符数据开辟不同的内存空间，所以str1 和str2 位于不同的内存空间，所以它们不相等。但是str3 和str4 是声明的一个常量指针，编译器会将他们指向同一块内存地址，所以它们是相等的。