"&operator=" 校正

玉鹿

抱著一點點希望看看有沒有人可以幫我><問題一:
&operator= 有沒有寫錯
問題二:
要怎麼把&operator=分到newBag.cpp裡面?

1. //newBag.h
   
2. #ifndef bag_H
   
3. #define bag_H
   
4. 
   
5. #include <iostream>
   
6. #include <string>
   
7. 
   
8. typedef std::string ItemType;
   
9. 
   
10. class Bag
    
11.     {
    
12.       public:
    
13.         Bag();
    
14.                 ~Bag();
    
15.                 Bag &operator=(const Bag &old)
    
16.                 {
    
17.                         if(&old == this)
    
18.                                 return (*this);
    
19.                         delete [] m_container;
    
20.                         m_number = old.m_number;
    
21.                         m_container = new ItemType[m_number];
    
22.                         for (int i = 0; i < m_number; i++)
    
23.                         {
    
24.                                 m_container[i] = old.m_container[i];
    
25.                         }
    
26.                         return (*this);
    
27.                 }
    
28.         bool empty() const;
    
29.         int size();
    
30.         int uniqueSize();
    
31.         bool insert(const ItemType& value);
    
32.         int erase(const ItemType& value);
    
33.         int eraseAll(const ItemType& value);
    
34.         bool contains(const ItemType& value) const;
    
35.         int count(const ItemType& value) const;
    
36.         void swap(Bag& other);
    
37.         void start();
    
38.         void next();
    
39.         bool ended() const;
    
40.         const ItemType& currentValue() const;
    
41.         int currentCount() const;
    
42.                 void display(); //delete this
    
43.          private:
    
44.                 ItemType* m_container;
    
45.                 ItemType* m_distinct;
    
46.                 int m_number;
    
47.      };
    
48. #endif

複製代碼

1. //newbag.cpp
   
2. #include "newBag.h"
   
3. using namespace std;
   
4. Bag::Bag(): m_distinct(NULL), m_container(NULL), m_number(0) {}          // Create an empty bag.
   
5. Bag::~Bag()
   
6. {
   
7.         delete [] m_container;
   
8. }
   
9. bool Bag::empty() const // Return true if the bag is empty, otherwise false.
   
10. {
    
11.         if (m_number == 0)
    
12.                 return true;
    
13.         return false;
    
14. }
    
15. int Bag::size()
    
16. {
    
17. // Return the number of items in the bag.  For example, the size
    
18. // of a bag containing "cumin", "cumin", "cumin", "turmeric" is 4.
    
19.         return m_number;
    
20. }
    
21. int Bag::uniqueSize()
    
22. {
    
23. // Return the number of distinct items in the bag.  For example,
    
24. // the uniqueSize of a bag containing "cumin", "cumin", "cumin",
    
25. // "turmeric" is 2.
    
26.         int u = 0;
    
27.         ItemType* pointer = new ItemType[m_number];
    
28.         for (int x = 0;x < m_number; x++)
    
29.         {
    
30.                 pointer[x] = m_container[x];
    
31.         }
    
32.         ItemType unique;
    
33.         bool next = true;
    
34.         for (int x = 0; x < m_number; x++)
    
35.         {
    
36.                 next = true;
    
37.                 unique = pointer[x];
    
38.                 for( int y = 0; y < m_number; y++)
    
39.                 {
    
40.                         if (unique == "")
    
41.                         {
    
42.                                 u++;
    
43.                         }
    
44.                         else if (unique == pointer[y])// && unique != ""
    
45.                         {
    
46.                                 pointer[y] = "";
    
47.                         }
    
48.                         else if(next == true)//unique != pointer[y] && unique != "" &&
    
49.                         {
    
50.                                 next = false;
    
51.                                 x = y-1;
    
52.                                 u++;
    
53.                         }
    
54.                 }
    
55.         }
    
56.         delete [] pointer;
    
57.         return u;
    
58. }
    
59. bool Bag::insert(const ItemType& value)
    
60. {
    
61. // Insert value into the bag.  Return true if the value was
    
62. // actually inserted.  Return false if the value was not inserted
    
63. // (perhaps because the bag has a fixed capacity and is full).
    
64.         int i = m_number;
    
65.         if ( ++i < 200)
    
66.         {
    
67.                 m_number++;
    
68.                 ItemType* pointer = new ItemType[m_number];
    
69.                 pointer [0] = value;
    
70.                 for( int x = 0; x < m_number -1; x++)
    
71.                 {
    
72.                         pointer[x+1] = m_container[x];
    
73.                 }
    
74.                 delete [] m_container;
    
75.                 m_container = pointer;
    
76.                 return true;
    
77.         }
    
78.         return false;
    
79. }
    
80. int Bag::erase(const ItemType& value)
    
81. {
    
82. // Remove one instance of value from the bag if present.
    
83. // Return the number of instances removed, which will be 1 or 0.
    
84.         int z = 0;
    
85.         for (int i = 0; i < m_number; i++)
    
86.         {
    
87.                 if (m_container [i] != value)
    
88.                 {
    
89.                         z++;
    
90.                 }
    
91.         }
    
92.         if ((z+1) == m_number)
    
93.         {
    
94.                 return 0;
    
95.         }
    
96.         int number_erased = 0;
    
97.         bool deleted = false;
    
98.         m_number --;
    
99.         ItemType * pointer = new ItemType [m_number -1];
    
100.         int y = 0;
     
101.         for (int x = 0; x < m_number; x++)
     
102.         {
     
103.                 if (m_container[x] == value && deleted == false)
     
104.                 {
     
105.                         deleted = true;
     
106.                 }
     
107.                 else
     
108.                 {
     
109.                         pointer [y] = m_container [x];
     
110.                         y++;
     
111.                 }
     
112.         }
     
113.         delete [] m_container;
     
114.         m_container = pointer;
     
115.         return 1;
     
116. }
     
117. int Bag::eraseAll(const ItemType& value)
     
118. {
     
119. // Remove all instances of value from the bag if present.
     
120. // Return the number of instances removed.
     
121.         int z = 0;
     
122.         for (int i = 0; i < m_number; i++)
     
123.         {
     
124.                 if (m_container [i] == value)
     
125.                 {
     
126.                         z++;
     
127.                 }
     
128.         }
     
129.         z++;
     
130.         int y = 0;
     
131.         for( int x = 0; x < z; x++)
     
132.         {
     
133.                 erase(value);
     
134.         }
     
135.         z--;
     
136.         return z;
     
137. }
     
138. bool Bag::contains(const ItemType& value) const
     
139. {
     
140. // Return true if the value is in the bag, otherwise false.
     
141.         for (int x = 0; x < m_number; x++)
     
142.         {
     
143.                 if (m_container [x] == value)
     
144.                         return true;
     
145.         }
     
146.         return false;
     
147. }
     
148. int Bag::count(const ItemType& value) const
     
149. {
     
150. // Return the number of instances of value in the bag.
     
151.         int z = 0;
     
152.         for (int x = 0; x < m_number; x++)
     
153.         {
     
154.                 if (m_container [x] == value)
     
155.                         z++;
     
156.         }
     
157.         return z;
     
158. 
     
159. }
     
160. 
     
161. void Bag::swap(Bag& other)
     
162. {
     
163. // Exchange the contents of this bag with the other one.
     
164.                 Bag temp(other);
     
165.                 other = *this;
     
166.                 *this = temp;
     
167. }
     
168. 
     
169. // Iteration functions (explained below)
     
170. void Bag::start()
     
171. {
     
172.         if (m_distinct != NULL)
     
173.                 m_distinct = m_container;
     
174.         else
     
175.                 m_distinct = NULL;
     
176. }
     
177. void Bag::next()
     
178. {
     
179.         ItemType old = *m_distinct;
     
180.         Bag a;
     
181.         if (m_distinct = NULL)
     
182.         {
     
183.                 m_distinct = NULL;
     
184.         }
     
185.         else
     
186.         {               
     
187.                 for (int x = 0; x < m_number; x++)
     
188.                 {
     
189.                         if (m_container [x] != *m_distinct && a.contains(m_container[x]) == false)
     
190.                         {
     
191.                                 a.insert(m_container[x]);
     
192.                                 m_distinct = &m_container[x];
     
193.                                 break;
     
194.                         }
     
195.                 }
     
196.         }
     
197.                           
     
198.         if (old == *m_distinct)
     
199.         {
     
200.                 m_distinct = NULL;
     
201.         }
     
202. }
     
203. bool Bag::ended() const
     
204. {
     
205.         if (m_distinct == NULL)
     
206.                 return true;
     
207.         return false;
     
208. }
     
209. const ItemType& Bag::currentValue() const
     
210. {
     
211.         return *m_distinct;
     
212. }
     
213. int Bag::currentCount() const
     
214. {        
     
215.         return count(*m_distinct);
     
216. }
     
217. void Bag::display()
     
218. {
     
219.         for(int x = 0; x < m_number; x++)
     
220.         {
     
221.                 std:: cout << m_container[x] << std::endl;
     
222.         }
     
223. }

複製代碼

1. //testnewbag.cpp
   
2. 
   
3. #include "newBag.h"
   
4. #include <iostream>
   
5. #include <assert.h>
   
6. using namespace std;
   
7. 
   
8. int main()
   
9. {
   
10.         cout << "b1:" << endl;
    
11.         Bag b1;
    
12.     b1.insert("cumin");
    
13.     b1.insert("cumin");
    
14.     b1.insert("turmeric");
    
15.         b1.display();
    
16.         cout << "b2" << endl;
    
17.     Bag b2;
    
18.     b2.insert("saffron");
    
19.     b2.insert("cumin");
    
20.     b2.insert("cinnamon");
    
21.         b2.display();
    
22.     b1.swap(b2);  // exchange contents of b1 and b2
    
23.         cout << "b1:" << endl;
    
24.         b1.display();
    
25.         cout << "b2:" << endl;
    
26.         b2.display();
    
27. }

複製代碼

...

瀏覽完整內容，請先 註冊 或 登入會員

kaworucloud

回復  kaworucloud

一定要先做好copy constructor才可以做assignment operator吧?
玉鹿 發表於 2011-1-23 06:31 PM

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

不
copy constructor 與 assignment operator 是兩個完全不同的東西，彼此沒有絕對的關係
...

瀏覽完整內容，請先 註冊 或 登入會員

玉鹿

回復

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

kaworucloud

一定要先做好copy constructor才可以做assignment operator吧?

玉鹿

公布答案:

1. // newBag.h
   
2. 
   
3. #ifndef NEWBAG_INCLUDED
   
4. #define NEWBAG_INCLUDED
   
5. 
   
6.   // Later in the course, we'll see that templates provide a much nicer
   
7.   // way of enabling us to have Bags of different types.  For now, we'll
   
8.   // use a typedef.
   
9. 
   
10. typedef unsigned long ItemType;
    
11. 
    
12. const int DEFAULT_MAX_ITEMS = 200;
    
13. 
    
14. class Bag
    
15. {
    
16.   public:
    
17.     Bag(int capacity = DEFAULT_MAX_ITEMS);
    
18.       // Create an empty bag with the given capacity.
    
19. 
    
20.     bool empty() const;  // Return true if the bag is empty, otherwise false.
    
21. 
    
22.     int size() const;
    
23.       // Return the number of items in the bag.  For example, the size
    
24.       // of a bag containing "cumin", "cumin", "cumin", "turmeric" is 4.
    
25. 
    
26.     int uniqueSize() const;
    
27.       // Return the number of distinct items in the bag.  For example,
    
28.       // the uniqueSize of a bag containing "cumin", "cumin", "cumin",
    
29.       // "turmeric" is 2.
    
30. 
    
31.     bool insert(const ItemType& value);
    
32.       // Insert value into the bag.  Return true if the value was
    
33.       // actually inserted.  Return false if the value was not inserted
    
34.       // (perhaps because the bag has a fixed capacity and is full).
    
35. 
    
36.     int erase(const ItemType& value);
    
37.       // Remove one instance of value from the bag if present.
    
38.       // Return the number of instances removed, which will be 1 or 0.
    
39. 
    
40.     int eraseAll(const ItemType& value);
    
41.       // Remove all instances of value from the bag if present.
    
42.       // Return the number of instances removed.
    
43. 
    
44.     bool contains(const ItemType& value) const;
    
45.       // Return true if the value is in the bag, otherwise false.
    
46. 
    
47.     int count(const ItemType& value) const;
    
48.       // Return the number of instances of value in the bag.
    
49. 
    
50.     void swap(Bag& other);
    
51.       // Exchange the contents of this bag with the other one.
    
52. 
    
53.       // Iteration functions
    
54.     void start();                          // start an iteration
    
55.     void next();                           // advance to next item
    
56.     bool ended() const;                    // iteration has passed end
    
57.     const ItemType& currentValue() const;  // item at current position
    
58.     int currentCount() const;              // count of current item
    
59. 
    
60.       // Housekeeping functions
    
61.     ~Bag();
    
62.     Bag(const Bag& other);
    
63.     Bag& operator=(const Bag& rhs);
    
64. 
    
65.   private:
    
66. 
    
67.       // Since this structure is used only by the implementation of the
    
68.       // Bag class, we'll make it private to Bag.  Alternatively,
    
69.       // we could have declared it outside the Bag class, but then
    
70.       // clients could use it, and there's no need for them to.
    
71. 
    
72.     struct Node
    
73.     {
    
74.         ItemType m_value;
    
75.         int      m_count;
    
76.     };
    
77.     Node* m_data;       // dynamic array of the items in the bag, with counts
    
78.     int   m_uniqueSize; // how many distinct items in the bag
    
79.     int   m_size;       // total number of items in the bag
    
80.     int   m_capacity;   // the maximum number of items
    
81.     int   m_current;    // index of current node during iteration
    
82. 
    
83.       // At any time, the elements of m_data indexed from 0 to m_uniqueSize-1
    
84.       // are in use.  m_size is the sum of the m_counts of those elements.
    
85. 
    
86.     int find(const ItemType& value) const;
    
87.       // Return index of the node in m_data whose m_value == value if there is
    
88.       // one, else -1
    
89. 
    
90.     int doErase(const ItemType& value, bool all);
    
91.       // Remove one or all instances of value from the bag if present,
    
92.       // depending on the second parameter.  Return the number of instances
    
93.       // removed.
    
94. };
    
95. 
    
96. // Inline implementations
    
97. 
    
98. inline
    
99. int Bag::size() const
    
100. {
     
101.     return m_size;
     
102. }
     
103. 
     
104. inline
     
105. int Bag::uniqueSize() const
     
106. {
     
107.     return m_uniqueSize;
     
108. }
     
109. 
     
110. inline
     
111. bool Bag::empty() const
     
112. {
     
113.     return size() == 0;
     
114. }
     
115. 
     
116. inline
     
117. int Bag::erase(const ItemType& value)
     
118. {
     
119.     return doErase(value, false);
     
120. }
     
121. 
     
122. inline
     
123. int Bag::eraseAll(const ItemType& value)
     
124. {
     
125.     return doErase(value, true);
     
126. }
     
127. 
     
128. inline
     
129. bool Bag::contains(const ItemType& value) const
     
130. {
     
131.     return find(value) != -1;
     
132. }
     
133. 
     
134. inline
     
135. void Bag::start()
     
136. {
     
137.     m_current = 0;
     
138. }
     
139. 
     
140. inline
     
141. void Bag::next()
     
142. {
     
143.     m_current++;
     
144. }
     
145. 
     
146. inline
     
147. bool Bag::ended() const
     
148. {
     
149.     return m_current >= m_uniqueSize;
     
150. }
     
151. 
     
152. inline
     
153. const ItemType& Bag::currentValue() const
     
154. {
     
155.     return m_data[m_current].m_value;
     
156. }
     
157. 
     
158. inline
     
159. int Bag::currentCount() const
     
160. {
     
161.     return m_data[m_current].m_count;
     
162. }
     
163. 
     
164. #endif // NEWBAG_INCLUDED

複製代碼

1. // newBag.cpp
   
2. 
   
3. #include "newBag.h"
   
4. #include <iostream>
   
5. #include <cstdlib>
   
6. using namespace std;
   
7. 
   
8. void exchange(int& a, int& b)
   
9. {
   
10.     int t = a;
    
11.     a = b;
    
12.     b = t;
    
13. }
    
14. 
    
15. Bag::Bag(int capacity)
    
16. : m_uniqueSize(0), m_size(0), m_capacity(capacity), m_current(0)
    
17. {
    
18.     if (capacity < 0)
    
19.     {
    
20.         cout << "A Bag capacity must not be negative." << endl;
    
21.         exit(1);
    
22.     }
    
23.     m_data = new Node[m_capacity];
    
24. }
    
25. 
    
26. Bag::Bag(const Bag& other)
    
27. : m_uniqueSize(other.m_uniqueSize), m_size(other.m_size),
    
28.    m_capacity(other.m_capacity), m_current(other.m_uniqueSize)
    
29. {
    
30.       // Iterator state in fresh copy is undefined.  Let's say it's ended.
    
31.       // Setting m_current above to other.uniqueSize does that.
    
32. 
    
33.     m_data = new Node[m_capacity];
    
34.     for (int k = 0; k < m_uniqueSize; k++)
    
35.         m_data[k] = other.m_data[k];
    
36. }
    
37. 
    
38. Bag::~Bag()
    
39. {
    
40.     delete [] m_data;
    
41. }
    
42. 
    
43. Bag& Bag::operator=(const Bag& rhs)
    
44. {
    
45.     if (this != &rhs)
    
46.     {
    
47.         Bag temp(rhs);
    
48.         swap(temp);
    
49.     }
    
50.     return *this;
    
51. }
    
52. 
    
53. bool Bag::insert(const ItemType& value)
    
54. {
    
55.     int pos = find(value);
    
56. 
    
57.     if (pos != -1)  // found
    
58.         m_data[pos].m_count++;
    
59.     else
    
60.     {
    
61.         if (uniqueSize() == m_capacity)  // no room to insert
    
62.             return false;
    
63.         m_data[m_uniqueSize].m_value = value;
    
64.         m_data[m_uniqueSize].m_count = 1;
    
65.         m_uniqueSize++;
    
66.     }
    
67. 
    
68.     m_size++;
    
69.     return true;
    
70. }
    
71. 
    
72. int Bag::count(const ItemType& value) const
    
73. {
    
74.     int pos = find(value);
    
75.     return pos == -1 ? 0 : m_data[pos].m_count;
    
76. }
    
77. 
    
78. void Bag::swap(Bag& other)
    
79. {
    
80.       // Swap the m_data pointers to dynamic arrays.
    
81. 
    
82.     Node* tempData = m_data;
    
83.     m_data = other.m_data;
    
84.     other.m_data = tempData;
    
85. 
    
86.       // Swap uniqueSize, size, and capacity.
    
87. 
    
88.     exchange(m_uniqueSize, other.m_uniqueSize);
    
89.     exchange(m_size, other.m_size);
    
90.     exchange(m_capacity, other.m_capacity);
    
91. 
    
92.       // Iterator state after swap is undefined.  Let's say it's ended.
    
93. 
    
94.     m_current = m_uniqueSize;
    
95.     other.m_current = other.m_uniqueSize;
    
96. }
    
97. 
    
98. int Bag::find(const ItemType& value) const
    
99. {
    
100.       // Do a linear search through the array.
     
101. 
     
102.     for (int pos = 0; pos < m_uniqueSize; pos++)
     
103.         if (m_data[pos].m_value == value)
     
104.             return pos;
     
105.     return -1;
     
106. }
     
107. 
     
108. int Bag::doErase(const ItemType& value, bool all)
     
109. {
     
110.     int pos = find(value);
     
111. 
     
112.     if (pos == -1)  // not found
     
113.         return 0;
     
114. 
     
115.       // If erasing one, and there are more than one, just decrement
     
116. 
     
117.     if (!all  &&  m_data[pos].m_count > 1)
     
118.     {
     
119.         m_data[pos].m_count--;
     
120.         m_size--;
     
121.         return 1;
     
122.     }
     
123. 
     
124.       // If erasing all, or erasing one whose count is 1, move last array
     
125.       // item to replace the one to be erased
     
126. 
     
127.     int nErased = m_data[pos].m_count;
     
128.     m_size -= nErased;
     
129.     m_uniqueSize--;
     
130.     m_data[pos] = m_data[m_uniqueSize];
     
131.     return nErased;
     
132. }

複製代碼

...

瀏覽完整內容，請先 註冊 或 登入會員

kaworucloud

會出錯是因為你的 swap 中用到了你沒定義的 copy constructor
解決方式有兩個
一是修改 sawp，別用 copy constructor，只用 assignment operator

1. void swap( Bag& other ){
   
2.    //Bag temp(other); 這會呼叫 copy constructor
   
3.    //Bag temp = other; 這也會呼叫 copy constructor
   
4.     Bag temp;
   
5.     temp = other; // 這會呼叫 =operator
   
6.     other = *this;
   
7.     *this = temp;
   
8. }

複製代碼

二是定義 copy constructor
.h

1. Bag( const Bag& other );

複製代碼

.cpp

1. Bag::Bag( const Bag& other ){
   
2.     m_number = other.m_number;
   
3.     m_container = new ItemType[m_number];
   
4.     for( int i=0; i<m_number; ++i ){
   
5.         m_container[i] = other.m_container[i];
   
6.     }
   
7. }

複製代碼

...

瀏覽完整內容，請先 註冊 或 登入會員

玉鹿

回復

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

kaworucloud

剛剛發現問題好像是因為pointer 複製上的問題,
請問大大知道嗎?

玉鹿

回復

下載: 訪客無法瀏覽下載點，請先 註冊 或 登入會員

kaworucloud

謝了, 不過這個程式好像是錯誤的,
swap還是沒辦法作業

kaworucloud

.h

1. Bag& operator=(const Bag &old);

複製代碼

.cpp

1. Bag& Bag::operator=(const Bag &old)
   
2. {
   
3.     if(&old == this)
   
4.         return (*this);
   
5.     delete [] m_container;
   
6.     m_number = old.m_number;
   
7.     m_container = new ItemType[m_number];
   
8.     for (int i = 0; i < m_number; i++)
   
9.     {
   
10.         m_container[i] = old.m_container[i];
    
11.     }
    
12.     return (*this);
    
13. }

複製代碼

...

瀏覽完整內容，請先 註冊 或 登入會員