## money_put

    money_putlocale::facet

- Summary
- Data Type and Member Function Indexes
- Synopsis
- Description
- Interface
- Types
- Constructors
- Destructors
- Static Members
- Public Member Functions
- Protected Member Functions
- Example
- See Also

### Summary

Monetary formatting facet for output.

### Data Type and Member Function Indexes
(exclusive of constructors and destructors)

Data Types
char_type id iter_type string_type |

Member Functions
do_put() put()

### Synopsis

    #include <locale>
    template <class charT,
             class OutputIterator = ostreambuf_iterator<charT> >
    class money_put;

### Description

The money_put facet takes a `long double` value, or generic sequence of digits and writes out a formatted representation of the monetary value.

### Interface

    template <class charT,
             class OutputIterator = ostreambuf_iterator<charT> >
    class money_put : public locale::facet {
    public:
      typedef charT               char_type;
      typedef OutputIterator      iter_type;
      typedef basic_string<charT> string_type;
      explicit money_put(size_t = 0);
      iter_type put(iter_type, bool, ios_base&, char_type,
                    long double) const;
      iter_type put(iter_type, bool, ios_base&, char_type,
                    const string_type&) const;
      static locale::id id;
    protected:
      ~money_put();  // virtual
      virtual iter_type  do_put(iter_type, bool, ios_base&,
                                char_type, long double) const;
      virtual iter_type do_put(iter_type, bool, ios_base&,
                               char_type, const string_type&)
                               const;
    };

### Types

    char_type

Type of the character upon which the facet is instantiated.

    iter_type

Type of iterator used to scan the character buffer.

    string_type

Type of character string passed to member functions.

### Constructors

    explicit money_put(size_t refs = 0)

Construct a money_put facet. If the `refs` argument is `0`, then destruction of the object is delegated to the locale, or locales, containing it. This allows the user to ignore lifetime management issues. On the other hand, if `refs` is `1`, then the object must be explicitly deleted; the locale does not do so.

### Destructors

    ~money_put();  // virtual and protected

Destroys the facet.

### Static Members

    static locale::id id;

Unique identifier for this type of facet.

### Public Member Functions

The public members of the money_put facet include an interface to protected members. Each public member `put` has a corresponding virtual protected member `do_put`.

    iter_type
    put(iter_type s, bool intl, ios_base& f, char_type fill,
        long double units) const;
    iter_type
    put(iter_type s, bool intl, ios_base& f, char_type fill,
        const string_type& digits) const;

Each of these two overloads of the public member function `put` simply calls the corresponding protected `do_put` function.

### Protected Member Functions

    virtual iter_type
    do_put(iter_type s, bool intl, ios_base& f, char_type fill,
           long double units) const;

Writes out a character string representation of the monetary value contained in `units`. Since `units` represents the monetary value in the smallest possible unit of currency, any fractional portions of the value are ignored. `f.flags()` and the `moneypunct<charT, intl>` facet from `f.getloc()` give the formatting information.

The `fill` argument is used for any padding.

Returns an iterator pointing one past the last character written.

    virtual iter_type
    do_put(iter_type s, bool intl, ios_base& f, char_type fill,
           const string_type& digits) const;

Writes out a character string representation of the monetary value contained in `digits`. `digits` represents the monetary value as a sequence of digits in the smallest possible unit of currency. `do_put` only looks at an optional `-` character and any immediately contiguous digits. `f.flags()` and the `moneypunct<charT, intl>` facet from `f.getloc()` give the formatting information.

The `fill` argument is used for any padding.

Returns an iterator pointing one past the last character written.

### Example

    //
    // moneyput.cpp
    //

    #include <string>
    #include <iostream>

    int main ()
    {
      using namespace std;

      typedef ostreambuf_iterator<char,char_traits<char> >
              iter_type;

      locale loc;
      string buffer("10002");
      long double ldval = 10002;

      // Construct a ostreambuf_iterator on cout
      iter_type begin(cout);

      // Get a money put facet
      const money_put<char,iter_type>& mp =
    #ifndef _RWSTD_NO_TEMPLATE_ON_RETURN_TYPE
      use_facet<money_put<char,iter_type> >(loc);
    #else
      use_facet(loc,(money_put<char,iter_type>*)0);
    #endif

      // Put out the string representation of the monetary value
      cout << buffer << " --> ";
      mp.put(begin,false,cout,' ',buffer);

      // Put out the long double representation
      // of the monetary value
      cout << endl << ldval << " --> ";
      mp.put(begin,false,cout,' ',ldval);

      cout <<  endl;

      return 0;
    }

### See Also

locale, facets, money_get, moneypunct

Copyright (c) 1998, Rogue Wave Software, Inc.
Send mail to report errors or comment on the documentation.
OEM Release, June 1998