[概念理解] MVC模式和C++的实现

  1 #include<iostream> 
  2 #include<vector>
  3 
  4 //get namespace related stuff 
  5 using std::cin; 
  6 using std::cout; 
  7 using std::endl; 
  8 using std::flush; 
  9 using std::string; 
 10 using std::vector; 
 11  
 12 //struct Observer, modeled after java.utils.Observer 
 13 struct Observer 
 14 /* 
 15  * AK: This could be a template (C++) or generic (Java 5), 
 16  * however the original Smalltalk MVC didn‘t do that. 
 17  */ 
 18 { 
 19    //update 
 20    virtual void update(void*)=0; 
 21 }; 
 22  
 23  //struct Observable, modeled after java.utils.Observable 
 24 struct Observable 
 25 { 
 26    //observers 
 27    vector<Observer*>observers; 
 28    
 29    //addObserver 
 30    void addObserver(Observer*a){observers.push_back(a);} 
 31    
 32    //notifyObservers 
 33    void notifyObservers() 
 34    { 
 35     for (vector<Observer*>::const_iterator observer_iterator=observers.begin();observer_iterator!=observers.end();observer_iterator++) 
 36      (*observer_iterator)->update(this); 
 37    } 
 38   
 39   /* 
 40   AK: If you had a method which takes an extra "ARG" argument like this 
 41   notifyObservers(void* ARG), you can pass that arg to each Observer via 
 42   the call (*observer_iterator)->update(this,ARG); 
 43   
 44   
 45   This can significantly increase your View‘s reusablity down the track. 
 46   I‘ll explain why below in the View. 
 47   */
 48 
 49 }; 
 50  
 51  
 52  //struct Model, contains string-data and methods to set and get the data 
 53 struct Model:Observable 
 54 { 
 55    //data members title_caption, version_caption, credits_caption 
 56    string title_caption; 
 57    string version_caption; 
 58    string credits_caption; 
 59    
 60    //data members title, version, credits 
 61    string title; 
 62    string version; 
 63    string credits; 
 64    
 65    //constructor 
 66    Model() : 
 67     title_caption("Title: "), 
 68     version_caption("Version: "), 
 69     credits_caption("Credits: "), 
 70     title("Simple Model-View-Controller Implementation"), 
 71     version("0.2"), 
 72     credits("(put your name here)") 
 73     { } 
 74    
 75    //getCredits_Caption, getTitle_Caption, getVersion_Caption 
 76    string getCredits_Caption(){return credits_caption;} 
 77    string getTitle_Caption(){return title_caption;} 
 78    string getVersion_Caption(){return version_caption;} 
 79    
 80    //getCredits, getTitle, getVersion 
 81    string getCredits(){return credits;} 
 82    string getTitle(){return title;} 
 83    string getVersion(){return version;} 
 84    
 85    //setCredits, setTitle, setVersion 
 86    void setCredits(string a){credits=a;notifyObservers();} 
 87    void setTitle(string a){title=a;notifyObservers();} 
 88    void setVersion(string a){version=a;notifyObservers();} 
 89   /* 
 90    * AK notifyObservers(a) for credit, title and version. 
 91    * All as per discussion in View and Observer *  
 92    */ 
 93 };
 94 
 95 
 96 /* 
 97 AK: 
 98 Great stuff ;-) This satisfies a major principle of the MVC 
 99 architecture, the separation of model and view.
100 
101 The model now has NO View material in it, this model can now be used in 
102 other applications. 
103 You can use it with command line apps (batch, testing, reports, ...), 
104 web, gui, etc.
105 
106 Mind you "MVC with Passive Model" is a variation of MVC where the model 
107 doesn‘t get even involved with the Observer pattern.
108 
109 In that case the Controller would trigger a model update *and it* could 
110 also supply the latest info do the Views. This is a fairly common MVC 
111 variation, especially with we apps. 
112 */
113 
114  
115 
116  //struct TitleView, specialized Observer 
117 struct TitleView:Observer 
118 { 
119 /* 
120  * AK: 
121  * I like to get a reference to the model via a constructor to avoid 
122  * a static_cast in update and to avoid creating zombie objects. 
123  * 
124  * A zombie object is instantiated but is unusable because it 
125  * is missing vital elements. Dangerous. Getting model via the 
126  * constructor solves this problem.
127 
128  Model model; 
129  // Cons. 
130  TitleView (Model* m) ....
131 
132 RE-USABILITY. 
133 Some views are better off working with the full Model, yet others are 
134 better off being dumber.
135 
136 I like to have two kinds of Views. Those that work with full Model (A) 
137 and those that only work with a limited more abstract data type (B).
138 
139 Type A. 
140 Complex application specific views are better off getting the full 
141 model, they can then just pick and choose what they need from the full 
142 model without missing something all the time. Convenient.
143 
144 Type B. 
145 These only require abstract or generic data types.
146 
147 Consider a PieChartView, it doesn‘t really need to know about the full 
148 Model of a particular application, it can get by with just float 
149 *values[] or vector<float>;
150 
151 By avoiding Model you can then reuse PieChartView in other applications 
152 with different models.
153 
154 For this to be possible you must use the 2 argument version of 
155 notifyObservers. See comments on Observer class.
156 
157 See my Java example NameView. That view only knows about a String, not 
158 the full Model. 
159 */
160 
161 
162    //update 
163    void update(void*a) 
164   /* 
165    *AK:void update(void*a, void*arg) is often better. As per discussion 
166   above. 
167    */ 
168    { 
169    cout<<static_cast<Model*>(a)->getTitle_Caption(); 
170    cout<<static_cast<Model*>(a)->getTitle(); 
171    cout<<endl; 
172    } 
173 }; 
174  
175  
176  //struct VersionView, specialized Observer 
177 struct VersionView:Observer 
178 { 
179  
180  //update 
181  void update(void*a) 
182  { 
183  cout<<static_cast<Model*>(a)->getVersion_Caption(); 
184  cout<<static_cast<Model*>(a)->getVersion(); 
185  cout<<endl; 
186  } 
187 }; 
188  
189  
190  //struct CreditsView, specialized Observer 
191 struct CreditsView:Observer 
192 { 
193  
194  //update 
195  void update(void*a) 
196  { 
197  cout<<static_cast<Model*>(a)->getCredits_Caption(); 
198  cout<<static_cast<Model*>(a)->getCredits(); 
199  cout<<endl; 
200  } 
201 }; 
202  
203  
204  //struct Views, pack all Observers together in yet another Observer 
205 struct Views:Observer 
206 { 
207  //data members titleview, versionview, creditsview 
208  TitleView titleview; 
209  VersionView versionview; 
210  CreditsView creditsview; 
211 /* 
212  * AK: 
213  * Views are often hierarchical and composed of other Views. See 
214 Composite pattern. 
215  * vector<View*> views; 
216  * 
217  * Views often manage (create and own) a Controller. 
218  * 
219  * Views may include their own Controller code (Delegate). 
220  * 
221 */ 
222  //setModel 
223  void setModel(Observable&a) 
224  { 
225  a.addObserver(&titleview); 
226  a.addObserver(&versionview); 
227  a.addObserver(&creditsview); 
228  a.addObserver(this); 
229  } 
230  
231  //update 
232  void update(void*a) 
233  { 
234  cout<<"_____________________________"; 
235  cout<<"\nType t to edit Title, "; 
236  cout<<"v to edit Version, "; 
237  cout<<"c to edit Credits. "; 
238  cout<<"Type q to quit./n>>"; 
239  } 
240 }; 
241  
242  
243  //struct Controller, wait for keystroke and change Model 
244  struct Controller 
245 /* 
246  * AK: Controller can also be an Observer. 
247  * 
248  * There is much to say about Controller but IMHO we should defer 
249  * that to another version. 
250  */ 
251 { 
252    //data member model 
253    Model*model; 
254    
255    //setModel 
256    void setModel(Model&a){model=&a;} 
257    
258    //MessageLoop 
259    void MessageLoop() 
260    { 
261     char c=‘ ‘; 
262     string s; 
263     while(c!=‘q‘) 
264     { 
265       cin>>c; 
266       cin.ignore(256,‘\n‘); 
267       cin.clear(); 
268       switch(c) 
269       { 
270        case ‘c‘: 
271        case ‘t‘: 
272        case ‘v‘: 
273        getline(cin,s); 
274        break; 
275       } 
276       switch(c) 
277       { 
278        case ‘c‘:model->setCredits(s);break; 
279        case ‘t‘:model->setTitle(s);break; 
280        case ‘v‘:model->setVersion(s);break; 
281       } 
282     } 
283    } 
284 }; 
285  
286  
287  //struct Application, get Model, Views and Controller together 
288 struct Application 
289 { 
290  
291    //data member model 
292    Model model; 
293    
294    //data member views 
295    Views views; 
296    
297    //data member controller 
298    Controller controller; 
299    
300    //constructor 
301    Application() 
302    { 
303    views.setModel(model); 
304    controller.setModel(model); 
305    model.notifyObservers(); 
306    } 
307    
308    //run 
309    void run(){controller.MessageLoop();} 
310 }; 
311  
312  
313  //main 
314 int main() 
315 { 
316   Application().run(); 
317   return 0; 
318 }