小白求助 重载==操作符的疑问

琴长不过时光

1. bool MyString::operator==(const char* p)
   
2. {
   
3.         if (strcmp(this->m_space, p) == 0)
   
4.         {
   
5.                 return true;
   
6.         }
   
7.         else
   
8.         {
   
9.                 return false;
   
10.         }
    
11. }

复制代码

1.         if (s2 == "abcdefg")
   
2.         {
   
3.                 cout << "相同" << endl;
   
4.         }
   
5.         else
   
6.         {
   
7.                 cout << "不相同" << endl;
   
8. 
   
9.         }

复制代码

如题 重载== 操作符，判断一个存储字符串的变量s2，和另外一个字符串是否相同，直接用strcmp行吗 还是要
像下面这样判断

1. bool MyString::operator==(const char *p) const
   
2. {
   
3.         if (p == NULL)
   
4.         {
   
5.                 if (m_len == 0)
   
6.                 {
   
7.                         return true;
   
8.                 }
   
9.                 else
   
10.                 {
    
11.                         return false;
    
12.                 }
    
13.         }
    
14.         else
    
15.         {
    
16.                 if (m_len == strlen(p))
    
17.                 {
    
18.                         return !strcmp(m_p, p);
    
19.                 }
    
20.                 else
    
21.                 {
    
22.                         return false;
    
23.                 }
    
24.         }
    
25. }

复制代码

BngThea

看你的需求，还有类本身的设计

琴长不过时光

1. #include "MyString.h"
   
2. 
   
3. MyString::MyString()
   
4. {
   
5.         this->m_len = 0;
   
6.         this->m_space = new char[m_len + 1];
   
7.         strcpy(this->m_space, "");
   
8. }
   
9. 
   
10. MyString::MyString(const char* p)
    
11. {
    
12.         if (p == NULL)
    
13.         {
    
14.                 this->m_len = 0;
    
15.                 this->m_space = new char[m_len + 1];
    
16.                 strcpy(this->m_space, "");
    
17.         }
    
18.         else
    
19.         {
    
20.                 this->m_len = strlen(p);
    
21.                 this->m_space = new char[m_len + 1];
    
22.                 strcpy(this->m_space, p);
    
23.         }
    
24. }
    
25. 
    
26. MyString::MyString(const MyString& obj)
    
27. {
    
28.         this->m_len = obj.m_len;
    
29.         this->m_space = new char[m_len + 1];
    
30.         strcpy(this->m_space, obj.m_space);
    
31. }
    
32. 
    
33. MyString::~MyString()
    
34. {
    
35.         if (this->m_space != NULL)
    
36.         {
    
37.                 delete[] this->m_space;
    
38.                 this->m_space = NULL;
    
39.                 this->m_len = 0;
    
40.         }
    
41. }
    
42. 
    
43. MyString& MyString::operator=(MyString& s)
    
44. {
    
45.         if (this->m_space != NULL)
    
46.         {
    
47.                 delete[] this->m_space;
    
48.                 this->m_len = 0;
    
49.         }
    
50.         this->m_len = s.m_len;
    
51.         this->m_space = new char[m_len];
    
52.         strcpy(this->m_space, s.m_space);
    
53.         return *this;
    
54. }
    
55. 
    
56. MyString& MyString::operator=(const char* p)
    
57. {
    
58.         if (this->m_space != NULL)
    
59.         {
    
60.                 delete[] this->m_space;
    
61.                 this->m_len = 0;
    
62.         }
    
63.         if (p == NULL)
    
64.         {
    
65.                 this->m_len = 0;
    
66.                 this->m_space = new char[m_len + 1];
    
67.                 strcpy(this->m_space, "");
    
68.         }
    
69.         else
    
70.         {
    
71.                 this->m_len = strlen(p);
    
72.                 this->m_space = new char[m_len + 1];
    
73.                 strcpy(this->m_space, p);
    
74.         }
    
75.         return *this;
    
76. }
    
77. 
    
78. char& MyString::operator[](int index)
    
79. {
    
80.         return this->m_space[index];
    
81. }
    
82. 
    
83. bool MyString::operator==(MyString& s)
    
84. {
    
85.         if (this->m_len != s.m_len)
    
86.         {
    
87.                 return false;
    
88.         }
    
89. 
    
90.         if (strcmp(this->m_space, s.m_space) == 0)
    
91.         {
    
92.                 return true;
    
93.         }
    
94.         else
    
95.         {
    
96.                 return false;
    
97.         }
    
98. }
    
99. 
    
100. bool MyString::operator==(const char* p)
     
101. {
     
102.         if (strcmp(this->m_space, p) == 0)
     
103.         {
     
104.                 return true;
     
105.         }
     
106.         else
     
107.         {
     
108.                 return false;
     
109.         }
     
110. }
     
111. 
     
112. bool MyString::operator!=(MyString& s)
     
113. {
     
114.         if (!(*this == s))
     
115.         {
     
116.                 return true;
     
117.         }
     
118.         else
     
119.         {
     
120.                 return false;
     
121.         }
     
122. }
     
123. 
     
124. bool MyString::operator!=(const char* p)
     
125. {
     
126.         if (!(*this == p))
     
127.         {
     
128.                 return true;
     
129.         }
     
130.         else
     
131.         {
     
132.                 return false;
     
133.         }
     
134. 
     
135. }

复制代码

琴长不过时光

BngThea 发表于 2020-3-28 15:30
看你的需求，还有类本身的设计

下面发了 我的MyString.app 你给看下  能不能直接用strcmp  还是用手动的判断

BngThea

琴长不过时光 发表于 2020-3-28 15:33
下面发了 我的MyString.app 你给看下  能不能直接用strcmp  还是用手动的判断

没其他需求就可以

琴长不过时光

BngThea 发表于 2020-3-28 15:37
没其他需求就可以

哦哦 谢谢大佬