第34课 数组操作符的重载

问题：

string类对象还具备C方式字符串的灵活性吗？还能访问单个字符吗？

字符串类的兼容性：

程序示例：

bcc编译器的运行结果如下：

vc编译器的结果：

 这意味着这三款编译器都是支持以数组访问的方式来使用字符串对象的。

 

类的对象怎么支持数组的下标访问？

重载数组访问操作符：

[]操作符是C++内置操作符，它的地位和+ - * /是一致的。

我们可以重载这个数组操作符。

示例：

 1 #include <iostream>
 2 #include <string>
 3 
 4 using namespace std;
 5 
 6 class Test
 7 {
 8     int a[5];
 9 public:
10     int& operator [] (int i)
11     {
12         return a[i];
13     }
14     
15     int& operator [] (const string& s)
16     {
17         if( s == "1st" )
18         {
19             return a[0];
20         }
21         else if( s == "2nd" )
22         {
23             return a[1];
24         }
25         else if( s == "3rd" )
26         {
27             return a[2];
28         }
29         else if( s == "4th" )
30         {
31             return a[3];
32         }
33         else if( s == "5th" )
34         {
35             return a[4];
36         }
37         
38         return a[0];
39     }
40     
41     int length()
42     {
43         return 5;
44     }
45 };
46 
47 int main()
48 {
49     Test t;
50     
51     for(int i=0; i<t.length(); i++)
52     {
53         t[i] = i;
54     }
55     
56     for(int i=0; i<t.length(); i++)
57     {
58         cout << t[i] << endl;
59     }
60     
61     cout << t["5th"] << endl;
62     cout << t["4th"] << endl;
63     cout << t["3rd"] << endl;
64     cout << t["2nd"] << endl;
65     cout << t["1st"] << endl;
66     
67     return 0;
68 }

运行结果如下：

数组类的完善：

 1 #ifndef _INTARRAY_H_
 2 #define _INTARRAY_H_
 3 
 4 class IntArray
 5 {
 6 private:
 7     int m_length;
 8     int* m_pointer;
 9     
10     IntArray(int len);
11     IntArray(const IntArray& obj);
12     bool construct();
13 public:
14     static IntArray* NewInstance(int length); 
15     int length();
16     bool get(int index, int& value);
17     bool set(int index ,int value);
18     int& operator [] (int index);
19     IntArray& self();
20     ~IntArray();
21 };
22 
23 #endif

 1 #include "IntArray.h"
 2 
 3 IntArray::IntArray(int len)
 4 {
 5     m_length = len;
 6 }
 7 
 8 bool IntArray::construct()
 9 {
10     bool ret = true;
11     
12     m_pointer = new int[m_length];
13     
14     if( m_pointer )
15     {
16         for(int i=0; i<m_length; i++)
17         {
18             m_pointer[i] = 0;
19         }
20     }
21     else
22     {
23         ret = false;
24     }
25     
26     return ret;
27 }
28 
29 IntArray* IntArray::NewInstance(int length) 
30 {
31     IntArray* ret = new IntArray(length);
32     
33     if( !(ret && ret->construct()) ) 
34     {
35         delete ret;
36         ret = 0;
37     }
38         
39     return ret;
40 }
41 
42 int IntArray::length()
43 {
44     return m_length;
45 }
46 
47 bool IntArray::get(int index, int& value)
48 {
49     bool ret = (0 <= index) && (index < length());
50     
51     if( ret )
52     {
53         value = m_pointer[index];
54     }
55     
56     return ret;
57 }
58 
59 bool IntArray::set(int index, int value)
60 {
61     bool ret = (0 <= index) && (index < length());
62     
63     if( ret )
64     {
65         m_pointer[index] = value;
66     }
67     
68     return ret;
69 }
70 
71 int& IntArray::operator [] (int index)
72 {
73     return m_pointer[index];
74 }
75 
76 IntArray& IntArray::self()
77 {
78     return *this;
79 }
80 
81 IntArray::~IntArray()
82 {
83     delete[]m_pointer;
84 }

 1 #include <iostream>
 2 #include <string>
 3 #include "IntArray.h"
 4 
 5 using namespace std;
 6 
 7 int main()
 8 {
 9     IntArray* a = IntArray::NewInstance(5);    
10     
11     if( a != NULL )
12     {
13         IntArray& array = a->self();
14         
15         cout << "array.length() = " << array.length() << endl;
16     
17         array[0] = 1;
18         
19         for(int i=0; i<array.length(); i++)
20         {  
21             cout << array[i] << endl;
22         }
23     }
24     
25     delete a;
26     
27     return 0;
28 }

C++中我们应该尽量避免使用指针，因此，提供了self函数，返回对象的引用，也就是别名。否则，我们在主函数中要使用(*a)[i]这样的方式来访问元素，这在C++中应该避免，应该不使用指针。

bcc运行结果：

 程序的第9行还是出现了指针，后面我们会通过智能指针来改造它。

小结：