C++第十二章_关于复制构造函数(解释了StringBad sailor = sports;会出现的问题以及解决方法)__复习new和delete以及学习静态类成员变量__关于赋值运算符(重构)__进一步重载赋值运算符(解析了name=temp两个对象的具体执行步骤)__比较重载运算符(使用友元函数重载)__静态成员函数__无缺陷的String类方法总结__在构造函数中使用new时应该注意的问题(

 1 //stringBad.h
 2 //设计一个stringBad类，类似于C++库中的string类
 3 #include <iostream>
 4 #ifndef STRINGBAD_H_
 5 #define STRINGBAD_H_
 6 
 7 class StringBad
 8 {
 9 private:
10     char* str;
11     int len;
12     static int num_strings;  //新建一个静态类成员变量
13 public:
14     StringBad(const char* s);  //声明构造函数
15     StringBad();  //声明默认构造函数
16     ~StringBad();  //声明析构函数
17     friend std::ostream & operator<<(std::ostream & os, const StringBad & st);  //声明友元函数
18 };
19 
20 #endif
21 
22 /* 复习new和delete以及学习静态类成员变量 */
23 /*
24 01)char* str = "Hello world";
25    int num_strings = strlen(str);  //这些是正确的,num_strings=11,strlen()并不计算字符串中的空字符
26    num_strings = 11
27 02)对于静态类成员变量：
28    假如有StringBad类对象s1,s2,s3。则s1,s2,s3都有自己的str和len私有成员变量
29    但是s1,s2,s3共用静态类成员变量num_strings
30    需要注意的是：
31    A 静态类成员变量可以在h文件中(类中)声明，也可以在头文件中声明，但是如果多个cpp文件都声明了该h文件,
32      那么该静态类成员变量就会被初始化好多次。
33    B 静态类成员变量可以在cpp文件中定义具体的数值
34 03)子函数的形参如果是一个类对象的话，最好是将该形参设置为引用，一旦设置成一般的类对象，会出现一些问题
35    比如user_main.cpp中callme2()子函数中的问题
36 04)StringBad sports("Spinish Leaves Bowl fot Dollars");
37    StringBad sailor = sports;
38    //上面的这一句实际等价于StringBad sailor = (StringBad)sports;
39   //调用的构造函数是StringBad(const StringBad &)
40   //由于原函数中没有该构造函数，所以编译器会自动创建该构造函数，而编译器自动创建的构造函数是没有将
41   //num_strings自动加1的，所以就导致了构造函数和析构函数中的num_strings++和num_strings--不一致，导致
42  //程序运行的结果中，最后析构函数删除的对象的个数出现不对的现象。
43 */

 1 //stringbad.cpp
 2 #include <cstring>
 3 #include "stringbad.h"
 4 
 5 //静态类成员变量的定义,注意要使用类成员限定符StringBad::,但是没有使用关键字static
 6 int StringBad::num_strings = 0;  
 7 
 8 //定义一个参数的构造函数
 9 //主要注意的是，对于StringBad boston("Boston");boston对象中并没有保存字符串"Boston",而是仅仅保存了该字符串的地址信息
10 StringBad::StringBad(const char* s)  //创建对象时，可以这样创建StringBad boston("Boston");
11 {
12     len = std::strlen(s);  //这一句很明显是在说strlen()在名称空间std中,
13     //同时也说明了strlen()可以接受一个字符串指针作为参数
14     str = new char[len + 1];  //加1是为了给空字符'\0'留出位置,new返回的是一个地址,所以str也是一个指针
15     std::strcpy(str, s);  //将指针字符串s复制给指针字符串str
16     //str=s; 这样做是不可以的，因为这样做只是复制了地址，而没有创建字符串副本
17     num_strings++;  //统计新建的对象的个数
18     std::cout << num_strings << ": \"" << str << "\"object created\n";//显式多少个对象已创建
19 }
20 
21 //默认构造函数的定义
22 StringBad::StringBad()
23 {
24     len = 4;
25     str = new char[len + 1];
26     std::strcpy(str, "C++");
27     num_strings++;//统计新建的对象的个数
28     std::cout << num_strings << ": \"" << str << "\"object created\n";//显式多少个对象已创建
29 }
30 
31 //析构函数的定义
32 //当StrngBad对象过期时，str指针也将过期，但str指向的内存仍然被分配，除非是有delete将其释放
33 //析构函数执行时，先删除最后创建的对象，后删除最先创建的对象
34 StringBad::~StringBad()
35 {
36     std::cout << "\"" << str << "\" object deleted, ";
37     --num_strings;  //对象的数据减1
38     std::cout << num_strings << " left\n";
39     delete[] str;   //释放由new创建的内存
40 }
41 
42 //友元函数的定义
43 std::ostream & operator<<(std::ostream & os, const StringBad & st)
44 {
45     os << st.str;
46     return os;
47 }

 1 //user_main.cpp
 2 #include <iostream>
 3 #include "stringbad.h"
 4 
 5 using std::cout;
 6 using std::endl;
 7 
 8 void callme1(StringBad &rsb);
 9 void callme2(StringBad sb);
10 
11 int main()
12 {
13     {
14         cout << "开始创建内部函数快" << endl;
15         StringBad headline1("Celery Stalks at midnight");
16         StringBad headline2("Lettuce Preey");
17         StringBad sports("Spinish Leaves Bowl fot Dollars");
18         cout << "headline1: " << headline1 << endl;
19         cout << "headline2: " << headline1 << endl;
20         cout << "sports: " << sports << endl;
21 
22         callme1(headline1);
23         //callme2(headline2);  //callme2()的形参为非引用，会出问题
24         /*
25         callme2()会出错误的原因：
26         01)headline2作为参数传递给cellme2(),在callme2()函数执行完毕后，会调用析构函数
27         02)虽然函数按值传递可以防止原始参数被修改，但实际上函数已使原始字符串无法识别，导致显示一些非标准字符
28         */
29 
30         StringBad sailor = sports;
31         cout << "sailor: " << sailor << endl;
32         //上面的这一句实际等价于StringBad sailor = (StringBad)sports;
33         //调用的构造函数是StringBad(const StringBad &)
34         //由于原函数中没有该构造函数，所以编译器会自动创建该构造函数，而编译器自动创建的构造函数是没有将
35         //num_strings自动加1的，所以就导致了构造函数和析构函数中的num_strings++和num_strings--不一致，导致
36         //程序运行的结果中，最后析构函数删除的对象的个数出现不对的现象。
37     }
38 
39     system("pause");
40     return 0;
41 }
42 
43 void callme1(StringBad & rsb)
44 {
45     cout << "String passed by reference: " << endl;
46     cout << "\"" << rsb << "\"" << endl;
47 }
48 void callme2(StringBad sb)
49 {
50     cout << "String passed by value: " << endl;
51     cout << "\"" << sb << "\"" << endl;
52 }

 1 #ifndef STRING1_H_
 2 #define STRING_H_
 3 
 4 #include <iostream>
 5 using std::ostream;  //刚刚这里写成cout了，导致下面对<<友元重载出错
 6 using std::istream;
 7 
 8 class String
 9 {
10 private:
11     char* str;  //保存字符串的地址
12     int len;    //保存字符串的长度
13     static int num_strings;  //保存创建的对象的个数
14     static const int CINLIM = 80;  //和对>>的重载有关的一个静态常量
15 public:
16     /* 构造函数和析构函数 */
17     String(const char* s);  //声明构造函数
18     String();  //声明默认构造函数
19     String(const String & st);  //声明复制构造函数
20     ~String();  //声明析构函数
21     int length() const { return len; }  //声明并定义内联函数,对象因此可以使用私有数据len
22 
23     /* 重构函数 */
24     String & operator=(const String & st);  //对等号(赋值运算符的重构)
25     String & operator=(const char* pt);  //对等号(赋值运算符的重构) 上下参数不一样
26     char & operator[](int i);  //对[]的重构,举例：String str("Hello"); 那么str[1]就等于e,注意此时str是一个对象
27     const char & operator[](int i) const;  //上边的那个允许对对象的第二个字符进行修改,即str[1]=E; 但是这个版本不允许，因为使用了const常量关键字
28     //上边最后的那个const表示不会修改调用该方法对象中的数据
29 
30     /*友元函数*/
31     friend bool operator<(const String & st1, const String & st2);  //小于号运算符重载+友元函数
32     friend bool operator>(const String & st1, const String & st2);
33     friend bool operator==(const String & st1, const String & st2);
34     friend ostream & operator<<(ostream & os, const String & st);  //输出运算符的重载+友元函数
35     friend istream & operator>>(istream & is, String & st);
36 
37     /* 静态方法(对象是不能调用的,只能通过类解析运算符(String::)使用) */
38     static int HowMany();  //声明要加上关键字static，定义时就不用加关键字static了
39 };
40 
41 #endif
42 
43 /* 无缺陷的String类方法总结 */
44 /*
45 本例子涉及到的类方法有：
46 01)复制重构函数的声明、定义和调用
47 02)静态变量、静态类方法的声明、定义和调用方法
48 03)对=号的重构函数
49 04)对<、>、和==的重构函数
50 05)对输入(>>)和输出(<<)的重构函数
51 */

  1 //string1.cpp
  2 #include <cstring>  //for strlen()、strcmp()等
  3 #include "string1.h"
  4 
  5 using std::cout;
  6 using std::cin;
  7 
  8 //静态变量的定义
  9 int String::num_strings = 0;  //注意要加类解析运算符
 10 //静态函数的定义
 11 int String::HowMany()  //注意要加类解析运算符
 12 {
 13     return num_strings;
 14 }
 15 
 16 /* 含一个参数的构造函数的定义*/
 17 String::String(const char* s)
 18 {
 19     len = std::strlen(s);  //去掉字符串最后的空字符后，总的字符数
 20     str = new char[len + 1];  //len+1是加上最后的空字符
 21     std::strcpy(str, s);
 22     num_strings++;  //对象数目加1
 23 }
 24 
 25 //默认构造函数定义
 26 String::String()
 27 {
 28     len = 1;
 29     str = new char[1];
 30     str = '\0';
 31     num_strings++;  //对象数目加1
 32 }
 33 
 34 //复制构造函数定义 例如String name = sports; 
 35 //sports为一个String对象,在这个过程中会创建一个临时对象,复制构造函数就负责将该临时对象复制给name
 36 String::String(const String & st)
 37 {
 38     len = st.len;
 39     str = new char[len + 1];
 40     std::strcpy(str, st.str);
 41     num_strings++;  //对象数目加1
 42 }
 43 
 44 //析构函数定义
 45 String::~String()
 46 {
 47     num_strings--;
 48     delete[] str;  //释放内存
 49 }
 50 
 51 //赋值运算符重构函数定义
 52 //调用方法为：String name = sports;  (name和sports都是String类对象)
 53 //实际调用方法为：name.operator=(sports);
 54 String & String::operator=(const String & st)  //刚刚类解析运算符的位置放错了，放在最先前边导致出错
 55 {
 56     if (this == &st)  //首先判断一下name对象和sports是不是同一个对象，如果是，那么该方法结束
 57         return *this;
 58     delete[] str;  //要首先删除name.str原来指向的内存，防止内存浪费
 59     len = st.len;
 60     str = new char[len + 1];
 61     std::strcpy(str, st.str);
 62     num_strings++;  //对象数目加1
 63     return *this;  //返回调用该方法的指针
 64 }
 65 
 66 //赋值运算符重构函数定义
 67 //调用方法为String name = "Hello world!"
 68 String & String::operator=(const char* pt)
 69 {
 70     delete[] str;  //释放name.str原来就有的内存
 71     len = std::strlen(pt);
 72     str = new char[len + 1];
 73     std::strcpy(str, pt);
 74     num_strings++;  //对象数目加1
 75     return *this;  //返回调用该方法的指针
 76 }
 77 
 78 //对[]的重构函数定义
 79 //调用方法为: 假如有String name("Hello");
 80 //那么可以使用 name[1],name[1]就等价于字符串中的第二个元素
 81 char & String::operator[](int i)
 82 {
 83     return str[i];  //直接返回字符串指针中的第i+1个元素就好了
 84 }
 85 
 86 //用法和上边的是一样的，只不过该方法不允许修改值
 87 //比如修改name.str中第二个元素： name[1]='M'; 在此方法下是不合法的
 88 const char & String::operator[](int i) const
 89 {
 90     return str[i];  //直接返回字符串指针中的第i+1个元素就好了
 91 }
 92 
 93 /* 以下为友元函数定义 */
 94 //strcmp(a,b); 如果a参数位于第二个参数b之前，则返回一个负值
 95 //如果第一个参数位于第二个参数之后，则返回一个正值
 96 //如果两个参数相等，则返回0
 97 
 98 //对小于号的重载
 99 bool operator<(const String & st1, const String & st2)
100 {
101     return (std::strcmp(st1.str, st2.str) < 0);
102     //如果std::strcmp(st1.str, st2.str) < 0 这个表达式成立则返回ture，否则返回false
103 }
104 
105 //对大于号的重载
106 bool operator>(const String & st1, const String & st2)
107 {
108     return st1 < st2;  //调用上面的operator<()函数
109 }
110 
111 //对恒等于号的重载
112 bool operator==(const String & st1, const String & st2)
113 {
114     return (std::strcmp(st1.str, st2.str) == 0);
115 }
116 
117 //对输出运算符的重载函数的定义
118 ostream & operator<<(ostream & os, const String & st)
119 {
120     os << st.str;
121     return os;
122 }
123 
124 //对输入运算符的重载函数的定义
125 //调用方法为：String name;  cin>>name;
126 istream & operator>>(istream & is, String & st)
127 {
128     char temp[String::CINLIM];
129     is.get(temp, String::CINLIM);
130     if (is)  //判断上一句是否输入成功
131         st = temp;
132     while (is && is.get() != '\n') //过滤掉输入流中的换行符
133         continue;
134     return is;
135 }

 1 //usret_main.cpp
 2 #include <iostream>
 3 #include "string1.h"
 4 
 5 const int Arsize = 10;
 6 const int MaxLen = 81;
 7 
 8 int main()
 9 {
10     using std::cout;
11     using std::cin;
12     using std::endl;
13 
14     String name;  //使用默认构造函数创建一个对象name
15     cout << "Hi,what's your name?" << endl;
16     cin >> name;  //使用对>>的重构函数输入到对象name中的str中去
17     cout << name << ", please enter up to " << Arsize << " short sayings <empty line to quit>" << endl;
18     String sayings[Arsize];  //创建一个数组，该数组内包含了Arsize个String类对象
19     char temp[MaxLen];  //新建一个字符串数组，用来存储从键盘输入的字符串
20     int i;
21     for (i = 0; i < Arsize; i++)
22     {
23         cout << i + 1 << " :";
24         cin.get(temp, MaxLen);  //输入字符串到字符串数组temp中去，最多可输入MaxLen个字符
25         while (cin && cin.get() != '\n')  //过滤掉最后输入的换行符
26             continue;
27         if (!cin || temp[0] == '\0')  //结束最外层while循环的条件，输入为空,则temp的第一个字符为空字符,且cin输入失败，返回值为0
28             break;
29         else
30             sayings[i] = temp;  //调用String & String::operator=(const char* pt)函数，调用方法为sayings[i].operator=(temp);
31     }
32     int total = i;  //保存输入的字符串的总个数
33     if (total > 0)
34     {
35         cout << "Here are your sayings:" << endl;
36         for (i = 0; i < total; i++)
37             cout << sayings[i][0] << ": " << sayings[i] << endl;
38         //sayings[i][0]表示调用char & String::operator[](int i)函数，调用方法为sayings[i].operator[](0),取出对象sayings[i].str中的第一个字符
39         //cout<<sayings[i][0]首先调用对<<的重载函数，返回一个cout，之后再调用对[]的重载函数，
40         //cout<<sayings[i]则直接调用对<<的重载函数了
41 
42         /* 接下来找到字符串最短的和字符串首字母拍在最前的字符串 */
43         int shortest = 0;
44         int first = 0;
45         for (i = 0; i < total; i++)
46         {
47             if (sayings[i].length() < sayings[shortest].length())  //仅仅是比较对象中的字符串长度
48                 shortest = i;
49             if (sayings[i] < sayings[first])  //调用对<的重载函数
50                 first = i;
51         }
52         cout << "Shortest saying:\n" << sayings[shortest] << endl;
53         cout << "First alphabetically:\n" << sayings[first] << endl;
54         cout << "The program used " << String::HowMany() << " String objects. Bye.\n";
55     }
56     else
57         cout << "No input! bye.\n";
58 
59     system("pause");
60     return 0;
61 }

 1 //使用new定位运算符为指针对象分配内存空间，但是此版本有问题
 2 //第九章介绍了有关new定位运算符的相关知识
 3 #include <iostream>
 4 #include <string>
 5 #include <new>  //在#include <iostream>中就已经包含了new头文件，这里不加该句也可以
 6 
 7 using namespace std;
 8 
 9 const int BUF = 512;
10 
11 class JustTesting
12 {
13 private:
14     string words;
15     int number;
16 public:
17     /* 带默认参数构造函数的定义 */
18     JustTesting(const string & s = "Just Testing", int n = 0)
19     {
20         words = s;
21         number = n;
22         cout << words << " was constructed\n";
23     }
24     /* 析构函数定义 */
25     ~JustTesting()
26     {
27         cout << words << " was destroyed\n";
28     }
29     /* 普通类方法定义 */
30     void Show() const   //最后的const表明调用该类方法的对象中的数据不可更改
31     {
32         cout << words << ", " << number << endl;
33     }
34 };
35 
36 int main()
37 {
38     char* buffer = new char[BUF];  //创建一个512字节的缓冲区，由于是用new创建的，所以是动态存储，该存储区位于堆中
39                                    //一个char型变量占用一个字节
40 
41     JustTesting *pc1, *pc2;  //创建两个指向JustTesting对象的指针
42 
43     pc1 = new (buffer) JustTesting;  //使用定位new运算符返回buffer的(JustTesting对象的)地址给pc1,并使用默认构造函数的默认参数创建JustTesting对象
44     pc2 = new JustTesting("Heap1", 20);  //使用常规new运算符返回一个可以存储JustTesting对象中数据的首地址,并使用新的数据创建对象
45 
46     cout << "Memory bloak addresses:\n" << "buffer: " << (void *)buffer << "  heap: " << pc2 << endl;
47     cout << "Memory contents:\n";
48     cout << pc1 << ": ";  //此处打印(pc1的)地址
49     pc1->Show();
50     cout << pc2 << ": ";  //此处打印(pc2的)地址
51     pc2->Show();
52 
53     JustTesting *pc3, *pc4;  //创建两个指向JustTesting对象的指针
54     pc3 = new (buffer) JustTesting("Bad Idea",6);  //再次使用new定位运算符,但是此时新对象中的数据会覆盖掉pc1指向的对象中的数据
55     //解决方法:pc3 = new (buffer+sizeof(JustTesting)) JustTesting("Bad Idea",6);
56     pc4 = new JustTesting("Heap2", 10);  //再次使用new常规运算符为新的对象中的数据分配内存,此时不会覆盖掉任何数据
57     cout << "Memory contents:\n";
58     cout << pc3 << ": ";  //此处打印(pc3的)地址
59     pc3->Show();
60     cout << pc4 << ": ";  //此处打印(pc2的)地址
61     pc4->Show();
62 
63     //释放内存,由于delete只能释放由常规new运算符创建的内存,由定位new运算符是不能直接使用delete释放内存的
64     //且 delete pc1;和delete pc3;是会报错的，
65     //解决方法是显示的调用析构函数：pc3->~JustTesting();  pc1->~JustTesting(); 
66     delete pc2;  //先删除后创建的指向对象的指针
67     delete pc4;
68     delete[] buffer;
69 
70     cout << "Done\n";
71 
72     system("pause");
73     return 0;
74 
75 }

 1 //使用new定位运算符为指针对象分配内存空间，正确的版本
 2 //第九章介绍了有关new定位运算符的相关知识
 3 #include <iostream>
 4 #include <string>
 5 #include <new>  //在#include <iostream>中就已经包含了new头文件，这里不加该句也可以
 6 
 7 using namespace std;
 8 
 9 const int BUF = 512;
10 
11 class JustTesting
12 {
13 private:
14     string words;
15     int number;
16 public:
17     /* 带默认参数构造函数的定义 */
18     JustTesting(const string & s = "Just Testing", int n = 0)
19     {
20         words = s;
21         number = n;
22         cout << words << " was constructed\n";
23     }
24     /* 析构函数定义 */
25     ~JustTesting()
26     {
27         cout << words << " was destroyed\n";
28     }
29     /* 普通类方法定义 */
30     void Show() const   //最后的const表明调用该类方法的对象中的数据不可更改
31     {
32         cout << words << ", " << number << endl;
33     }
34 };
35 
36 int main()
37 {
38     char* buffer = new char[BUF];  //创建一个512字节的缓冲区，由于是用new创建的，所以是动态存储，该存储区位于堆中
39                                    //一个char型变量占用一个字节
40 
41     JustTesting *pc1, *pc2;  //创建两个指向JustTesting对象的指针
42 
43     pc1 = new (buffer) JustTesting;  //使用定位new运算符返回buffer的(JustTesting对象的)地址给pc1,并使用默认构造函数的默认参数创建JustTesting对象
44     pc2 = new JustTesting("Heap1", 20);  //使用常规new运算符返回一个可以存储JustTesting对象中数据的首地址,并使用新的数据创建对象
45 
46     cout << "Memory bloak addresses:\n" << "buffer: " << (void *)buffer << "  heap: " << pc2 << endl;
47     cout << "Memory contents:\n";
48     cout << pc1 << ": ";  //此处打印(pc1的)地址
49     pc1->Show();
50     cout << pc2 << ": ";  //此处打印(pc2的)地址
51     pc2->Show();
52 
53     JustTesting *pc3, *pc4;  //创建两个指向JustTesting对象的指针
54     pc3 = new (buffer + sizeof(JustTesting)) JustTesting("Bad Idea", 6); //再次使用new定位运算符这样就不会覆盖掉pc1指向的内存中的数据
55     pc4 = new JustTesting("Heap2", 10);  //再次使用new常规运算符为新的对象中的数据分配内存,此时不会覆盖掉任何数据
56     cout << "Memory contents:\n";
57     cout << pc3 << ": ";  //此处打印(pc3的)地址
58     pc3->Show();
59     cout << pc4 << ": ";  //此处打印(pc2的)地址
60     pc4->Show();
61 
62     delete pc2;  //先删除后创建的指向对象的指针,释放在堆中创建的内存
63     delete pc4;
64     pc3->~JustTesting();  //显示的调用析构函数,以删除pc3指向的对象
65     pc1->~JustTesting();  //显示的调用析构函数
66     delete[] buffer;
67 
68     cout << "Done\n";
69 
70     system("pause");
71     return 0;
72 
73 }