自己写的string类，不太成熟（可以用自己的iostream）

andalousie

我的iostream(ios.h)下面是我的string(str.h)

1. #ifndef STD_STRING
   
2. #define STD_STRING
   
3. 
   
4. #include "ios.h"
   
5. #include <string.h>
   
6. 
   
7. void memmove(char *dest, char *src, size_t n)
   
8. {
   
9.     /* No need to do that thing. */
   
10.     if (dest == src)
    
11.         return;
    
12. 
    
13.     /* Check for destructive overlap.  */
    
14.     if (src < dest && dest < src + n) {
    
15.         /* Destructive overlap ... have to copy backwards.  */
    
16.         src += n;
    
17.         dest += n;
    
18.         while (n-- > 0)
    
19.             *--dest = *--src;
    
20.     } else {
    
21.         /* Do an ascending copy.  */
    
22.         while (n-- > 0)
    
23.             *dest++ = *src++;
    
24.     }
    
25. }
    
26. 
    
27. class out_of_range{
    
28. public:
    
29.         out_of_range()
    
30.         {
    
31.                 std::cerr << "Error: Invalid access of element. " << std::endl;
    
32.         }
    
33. };
    
34. 
    
35. namespace std{
    
36.         class string{
    
37.         public:
    
38.                 typedef size_t        size_type;
    
39.                 typedef char          value_type;
    
40.                 typedef const string& const_reference;
    
41.                 typedef const char *  const_pointer;
    
42.                
    
43.             string(const_pointer str = "");                 //default constructor(value_type)
    
44.             string(value_type);
    
45.             string(const_reference);                  //assign constructor(string)
    
46.             
    
47.             string&    operator= (const_reference);         //operator=
    
48.             string     operator+ (const_reference) const;   //operator+
    
49.             string&    operator+=(const_reference);         //operator+=
    
50.             
    
51.             //bool operators
    
52.             bool       operator==(const_reference) const;    //operator==
    
53.             bool       operator==(const_pointer) const;
    
54.             bool       operator!=(const_reference) const;    //operator!=
    
55.             bool       operator!=(const_pointer) const;
    
56.             bool       operator< (const_reference) const;    //operator<
    
57.             bool       operator< (const_pointer) const;
    
58.             bool       operator> (const_reference) const;    //operator>
    
59.             bool       operator> (const_pointer) const;
    
60.             bool       operator<=(const_reference) const;    //operator<=
    
61.             bool       operator<=(const_pointer) const;
    
62.             bool       operator>=(const_reference) const;    //operator>=
    
63.             bool       operator>=(const_pointer) const;
    
64.             
    
65.             value_type&      operator[](const size_type) const;  //operator[]
    
66.             value_type&      at(const size_type n) const;
    
67.             
    
68.             size_type  size() const { return _len; }
    
69.             size_type  length() const { return _len; }
    
70.             string&    erase(size_type pos, size_type len);
    
71.             void       swap(string& str);
    
72.             void       clear();
    
73.             bool       empty()  { return !_len; }
    
74.             const_pointer c_str() const { return const_cast<char*>(m_data); }
    
75.             ~string(void);
    
76.         private:
    
77.             value_type *m_data;
    
78.             size_type  _len;
    
79.             mutable bool local;
    
80.         };
    
81.         
    
82.         inline string::string(const_pointer str)
    
83.         {
    
84.                 _len   = strlen(str);
    
85.         m_data = new value_type[_len+1];
    
86.         strcpy(m_data, str);
    
87.         local  = true;
    
88.         }
    
89.         
    
90.         inline string::string(value_type ch)
    
91.         {
    
92.             m_data = new value_type[1];
    
93.         m_data[0] = ch;
    
94.         _len   = 1;
    
95.         local  = true;
    
96.         }
    
97.         
    
98.         inline string::string(const_reference other)
    
99.         {
    
100.                 local  = false;
     
101.             m_data = other.m_data;
     
102.             _len   = other._len;
     
103.         }
     
104.         
     
105.         inline string::~string(void)
     
106.         {
     
107.                 if(local) delete [] m_data;
     
108.         }
     
109.         
     
110.         inline string& string::operator=(const_reference other)
     
111.         {
     
112.             if (this!=&other)
     
113.             {
     
114.                 string tmp(other);
     
115.                 swap(tmp);
     
116.             }
     
117.             return *this;
     
118.         }
     
119.         
     
120.         inline string string::operator+(const_reference other)const
     
121.         {
     
122.             string newstring;
     
123.             newstring.local = false;
     
124.                 newstring.m_data = new value_type[strlen(m_data)+strlen(other.m_data)+1];
     
125.              strcpy(newstring.m_data,m_data);
     
126.             strcat(newstring.m_data,other.m_data);
     
127.             newstring._len = _len + other._len;
     
128.              return newstring;
     
129.         }
     
130.         
     
131.         inline string& string::operator+=(const_reference other)
     
132.         {
     
133.             *this = *this + other;
     
134.             return *this;
     
135.         }
     
136.         
     
137.         inline bool string::operator==(const_reference s) const
     
138.         {
     
139.              return s._len == _len
     
140.                    && !strcmp(m_data,s.m_data);
     
141.         }
     
142.         
     
143.         inline bool string::operator==(const_pointer s) const
     
144.         {
     
145.              return strlen(s) == _len
     
146.                    && !strcmp(m_data,s);
     
147.         }
     
148.         
     
149.         inline bool string::operator!=(const_reference s) const
     
150.         {
     
151.              return !(*this == s);
     
152.         }
     
153.         
     
154.         inline bool string::operator!=(const_pointer s) const
     
155.         {
     
156.              return !(*this == s);
     
157.         }
     
158.         
     
159.         inline bool string::operator< (const_reference s) const
     
160.         {
     
161.              return strcmp(m_data,s.m_data) < 0;
     
162.         }
     
163.         
     
164.         inline bool string::operator< (const_pointer s) const
     
165.         {
     
166.              return strcmp(m_data,s) < 0;
     
167.         }
     
168.         
     
169.         inline bool string::operator> (const_reference s) const
     
170.         {
     
171.              return strcmp(m_data,s.m_data) > 0;
     
172.         }
     
173.         
     
174.         inline bool string::operator> (const_pointer s) const
     
175.         {
     
176.              return strcmp(m_data,s) > 0;
     
177.         }
     
178.         
     
179.         inline bool string::operator<=(const_reference s) const
     
180.         {
     
181.              return !(*this > s);
     
182.         }
     
183.         
     
184.         inline bool string::operator<=(const_pointer s) const
     
185.         {
     
186.              return !(*this > s);
     
187.         }
     
188.         
     
189.         inline bool string::operator>=(const_reference s) const
     
190.         {
     
191.              return !(*this < s);
     
192.         }
     
193.         
     
194.         inline bool string::operator>=(const_pointer s) const
     
195.         {
     
196.              return !(*this < s);
     
197.         }
     
198.                
     
199.         inline char& string::operator[](const size_type n) const
     
200.         {
     
201.              if (n<0 || n>=_len) throw out_of_range();
     
202.             return m_data[n];
     
203.         }
     
204.         
     
205.         inline char& string::at(const size_type n) const
     
206.         {
     
207.              if (n<0 || n>=_len) throw out_of_range();
     
208.             return m_data[n];
     
209.         }
     
210.         
     
211.         inline string& string::erase(size_type pos, size_type len)
     
212.         {
     
213.                 if (pos >= _len || 0 == len) return *this;
     
214.                 const size_type remainder = pos + len;
     
215.                 if (remainder >= _len || remainder < pos)
     
216.                 {
     
217.                 *(m_data + pos) = '\0';
     
218.                 _len = pos;
     
219.                 return *this;
     
220.             }
     
221.             size_type left = _len - remainder + 1;
     
222.             value_type *d  = m_data + pos;
     
223.             value_type *s  = m_data + remainder;
     
224.             memmove(d, s, left);
     
225.             _len -= len;
     
226.             return *this;
     
227.         }
     
228.         
     
229.         inline void string::swap(string& str)
     
230.         {
     
231.                 string tmp(str);
     
232.                
     
233.                 str.local  = local;
     
234.                 str.m_data = m_data;
     
235.                 str._len   = _len;
     
236.                
     
237.                 local  = tmp.local;
     
238.                 m_data = tmp.m_data;
     
239.                 _len   = tmp._len;
     
240.         }
     
241.         
     
242.         inline void string::clear()
     
243.         {
     
244.                 m_data = new value_type[1];
     
245.                 strcpy(m_data, "");
     
246.                 _len   = 0;
     
247.         }
     
248.         
     
249.         istream& operator>>(istream& is, string& str)
     
250.         {
     
251.             char buffer[1000];
     
252.             is >> buffer;
     
253.             str = buffer;
     
254.              return is;
     
255.         }
     
256.         
     
257.         istream & getline(istream & is, string & str)
     
258.         {
     
259.             char buffer[1000];
     
260.             is.getline(buffer, 1000);
     
261.             str = buffer;
     
262.             return is;
     
263.         }
     
264.         
     
265.         ostream& operator<<(ostream& os, string& str)
     
266.         {
     
267.             os << str.c_str();
     
268.             return os;
     
269.         }
     
270.         
     
271. } //namespace std
     
272. 
     
273. #endif

复制代码

测试文件test_string.cpp

1. #include "str.h"
   
2. using namespace std;
   
3. 
   
4. int main()
   
5. {
   
6.         string s1;
   
7.         string s2("23345sghehst");
   
8.         cout << s1.size();
   
9.         cout << s2.size() << endl;
   
10.         s2.erase(4, 3);
    
11.         string s3 = s1 + s2;
    
12.         cout << s3 << endl;
    
13.         if(s1 >= s2) cout << 1;
    
14. }

复制代码

未闻丶花名

路过看看= =！

andalousie

路过请帮我检查一下代码好吗？我刚刚增添了几个成员函数。这是我写的最长的头文件了。