TODAY'S HEADLINES  |   ARTICLE ARCHIVE  |   FORUMS  |   TIP BANK
 Specialized Dev Zones Research Center eBook Library .NET Java C++ Web Dev Architecture Database Security Open Source Enterprise Mobile Special Reports 10-Minute Solutions DevXtra Blogs Slideshow

# Share Data Among Objects Using the Monostate Design Pattern-2 : Page 2

 by Danny Kalev, C++ Pro
 Jul 8, 2003
 Page 2 of 2

### WEBINAR:On-Demand

Building the Right Environment to Support AI, Machine Learning and Deep Learning

Step 3: Usage
Now that you've seen the code for the class, I'll step through how it works. Suppose a British tourist visits the cosmetics department and decides to purchase a perfume that costs \$99.95. She prefers to pay cash, in pounds. The attendant types the amount 99.95 in the "Exchange \$ to £" dialog box. Under the hood, the application does something like this:
``````
int main()
{
Exchange xcg;  //cosmetics dept.'s private object
double pounds=xcg.USD_to_GBP(99.95);//convert \$99.95 to GBP
cout<<"equivalent amount in British pounds: " <<; pounds << endl;
}
``````
The program's output is as follows:

You probably want to round the amount 60.1399 to 60.14 automatically. You can define a policies class that will write the user interface for the rounding. These policies may include rounding schemes, say up to the closest penny or in units of 5 or 10 pence. These policies should not be included in the Exchange class as it is responsible for representing the raw exchange rates only. Furthermore, while exchange rates change on a daily basis (or even by the hour), store policies are more stable. Keeping your Exchange class independent of fluctuating exchange rates will make it more stable and easier to maintain.

Monostate Muscle
I haven't shown the real strength of the monostate pattern yet. Suppose our store updates the exchange rates every hour, according to quote prices of a certain bank. To change the rate we add another class called Admin, which is a friend of class Exchange. The new exchange rate propagates swiftly to all instances of Exchange.
``````
class Exchange
{
//
};
{
public:
void set_EURO(double euros) const {Exchange::Euro = euros;}
void set_GBP(double pounds) const {Exchange::GBP = pounds;}
//
};
``````
Suppose the British pound exchange rate is now 0.62. The system administrator updates it like this:
```

```
``````
From this moment, every instance of the Exchange class is aware of the new exchange rate. If another British lady decides to buy the same perfume, she'll now have to pay 61.97 pounds:
``````
pounds=rates.USD_to_GBP(99.95);
cout<<"equivalent amount in British pounds: " << pounds << endl;
``````

Magnificent Monostate
The monostate pattern isn't included in the de-facto pattern catalog because it was developed later. In terms of its goals, monostate is similar to the singleton pattern, albeit much simpler in terms of implementation and usage.

The use of static data members and member functions ensures that the same state is shared by all objects of the same class, regardless of their creation time. Changing a static member's value enables you to update the objects' state immediately and automatically. The implementation of the monostate class shown here isn't thread safe. However, with slight modifications you can turn it into a thread-safe class.

Danny Kalev is a system analyst and software engineer with 15 years of experience, specializing in C++ and object-oriented analysis and design. He was a member of the ANSI C++ standardization committee between 1997-2001. Danny is the author of ANSI/ISO C++ Professional Programmer's Handbook and the C++ Section Leader for DevX He can be reached at dannykk@inter.net.il
Comment and Contribute

(Maximum characters: 1200). You have 1200 characters left.

Thanks for your registration, follow us on our social networks to keep up-to-date