Was this page helpful?
Your feedback about this content is important. Let us know what you think.
Additional feedback?
1500 characters remaining
Basic Math Functions
abs
Collapse the table of content
Expand the table of content

Basic Math Functions 

Illustrates how to use some basic math functions in the Standard Template Library (STL) in Visual C++.


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); }
   };

NoteNote

The class/parameter names in the prototype do not match the version in the header file. Some have been modified to improve readability.

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

// mathfunc.cpp
// compile with: /EHsc
// 
// Structures: plus<A>    - Adds data type A object to
//                          a class object derived from plus.
//             minus<A>   - Subtracts data type A.
//             multiplies<A>   - Multiplies object by data type A.
//             divides<A> - Divides object by data type A.
//             modulus<A> - Returns object modulo A.

#include <functional>
#include <iostream>

using namespace std ;

class MathOps : public plus<int>, public minus<int>,
                 public multiplies<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;}
  friend ostream& operator<<(ostream& os, const MathOps& obj ) ;
};

ostream& operator<<(ostream& os, const MathOps& obj )
{
       os << obj.value ;
       return os ;
}

int 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 ;
}

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

Header: <functional>

Community Additions

ADD
Show:
© 2015 Microsoft