Q158233: STL Sample for Basic Math Functions

Article: Q158233
Product(s): Microsoft C Compiler
Version(s): winnt:4.2
Operating System(s): 
Keyword(s): _IK
Last Modified: 06-MAY-2001

-------------------------------------------------------------------------------
The information in this article applies to:

- The Standard C++ Library 
- Microsoft Visual C++, 32-bit Enterprise Edition, version 4.2 
- Microsoft Visual C++, 32-bit Professional Edition, version 4.2 
-------------------------------------------------------------------------------

SUMMARY
=======

The sample code below illustrates how to use basic math STL functions plus,
minus, divides, times, and modulus in Visual C++.

MORE INFORMATION
================

Required Header
---------------

     <functional>

Prototype
---------

     template<class _TYPE>
     struct plus : binary_function<_TYPE, _TYPE, _TYPE>
     {
       _TYPE operator()(const _TYPE& _X, const _TYPE& _Y) const
                                           {return (_X + _Y); }
     };
     template<class _TYPE>
     struct minus : binary_function<_TYPE, _TYPE, _TYPE>
     {
       _TYPE operator()(const _TYPE& _X, const _TYPE& _Y) const
                                           {return (_X - _Y); }
     };
     template<class _TYPE>
     struct times : binary_function<_TYPE, _TYPE, _TYPE>
     {
       _TYPE operator()(const _TYPE& _X, const _TYPE& _Y) const
                                           {return (_X * _Y); }
     };
     template<class _TYPE>
     struct divides : binary_function<_TYPE, _TYPE, _TYPE>
     {
       _TYPE operator()(const _TYPE& _X, const _TYPE& _Y) const
                                           {return (_X / _Y); }
     };
     template<class _TYPE>
     struct modulus : binary_function<_TYPE, _TYPE, _TYPE>
     {
       _TYPE operator()(const _TYPE& _X, const _TYPE& _Y) const
                                           {return (_X % _Y); }
     };

NOTE: The class/parameter names in the prototype may not match the version in the
header file. Some have been modified to improve readability. Consult your
product documentation for information on the binary_function structure.

Description
-----------

This sample uses a class derived from all 5 basic math structures: plus, minus,
times, divides, and modulus, using an integer as the templated operand.

Sample Code
-----------

  //////////////////////////////////////////////////////////////// 
  // 
  // Compile options needed: none
  // 
  // mathfunc.cpp - Illustrating the basic STL math
  //                functions.
  // 
  // Structures: plus<A>    - Adds data type A object to
  //                          a class object derived from plus.
  //             minus<A>   - Subtracts data type A.
  //             times<A>   - Multiplies object by data type A.
  //             divides<A> - Divides object by data type A.
  //             modulus<A> - Returns object modulo A.
  // 
  // Written by Mark Hagen
  // of Microsoft Product Support Services,
  // Copyright (c) 1996 Microsoft Corporation.
  // All rights reserved.
  ///////////////////////////////////////////////////////////////// 

  #include <functional>
  using namespace std;

  class MathOps : public plus<int>, public minus<int>,
                   public times<int>, public divides<int>,
                   public modulus<int>
  {
  public:
    int value;
    MathOps(){value=0;}
    MathOps(int x){value=x;}
    result_type operator+(second_argument_type add2)
                              {return value + add2;}
    result_type operator-(second_argument_type sub2)
                              {return value - sub2;}
    result_type operator*(second_argument_type mult2)
                              {return value * mult2;}
    result_type operator/(second_argument_type div2)
                              {return value / div2;}
    result_type operator%(second_argument_type mod2)
                              {return value % mod2;}
  };

  void main(void)
  {
    MathOps one,two,three,four,five,six;

    cout << "Using MathOps class..." << endl ;

    one = 18;
    cout << "one = " << one << endl ;

    two = one + 1;
    cout << "two = one + 1 = " << two << endl ;

    three = two - 2;
    cout << "three = two - 2 = " << three << endl ;

    four = three * 3;
    cout << "four = three * 3 = " << four << endl ;

    five = four / 4;
    cout << "five = four / 4 = " << five << endl ;

    six = five % 5;
    cout << "six = five % 5 = " << six << endl ;
  }

Program Output is:

Using MathOps class...
one = 18
two = one + 1 = 19
three = two - 2 = 17
four = three * 3 = 51
five = four / 4 = 12
six = five % 5 = 2

REFERENCES
==========

Visual C++ Books On Line: Visual C++ Books:C/C++:Standard C++ Library Reference.

Additional query words: STL Sample plus minus divides times modulus

======================================================================
Keywords          : _IK 
Technology        : kbVCsearch kbAudDeveloper kbVC420 kbVC32bitSearch kbVCLibrary
Version           : winnt:4.2
Issue type        : kbhowto

=============================================================================

THE INFORMATION PROVIDED IN THE MICROSOFT KNOWLEDGE BASE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND. MICROSOFT DISCLAIMS ALL WARRANTIES, EITHER EXPRESS OR IMPLIED, INCLUDING THE WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL MICROSOFT CORPORATION OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER INCLUDING DIRECT, INDIRECT, INCIDENTAL, CONSEQUENTIAL, LOSS OF BUSINESS PROFITS OR SPECIAL DAMAGES, EVEN IF MICROSOFT CORPORATION OR ITS SUPPLIERS HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES SO THE FOREGOING LIMITATION MAY NOT APPLY.

Copyright Microsoft Corporation 1986-2002.