binops(3bobcat) 						 Binary Operators						   binops(3bobcat)

NAME

       binops - Template functions for class-type binary operators

SYNOPSIS

       #include <utility>
       #include <bobcat/typetrait>
       #include <bobcat/binops>

DESCRIPTION

       Classes	can  overload binary operators. A class named Class may overload these binary operators to suit its own needs, allowing, e.g., two
       Class type objects to be added after overloading operator+. Operators for the binary operators *, /, %, +, -, <<, >>, &, |, and ^ (in  this
       man-page they are generically indicated as the `@' operator) can be overloaded by defining the operator@ function.

       If  a  class supports copy construction and if it offers binary assignment operators (i.e., it offers members of the form operator@=), then
       the matching binary operators can all be implemented identically. The move-aware Class &operator@(Class &&lhs, Class const &rhs) is  easily
       implemented  in	terms  of  operator@= (note that the class itself doesn't have to be `move-aware' to define this function). The move-aware
       binary operator one requires a one line implementation, and as its implementation never changes it could safely be defined inline:

       Class operator@(Class &&lhs, Class const &rhs)
       {
	   return std::move(lhs @= rhs);
       }

       The traditional binary operator can be implemented using its standard form:

       Class operator@(Class const &lhs, Class const &rhs)
       {
	   Class tmp(lhs);
	   tmp @= rhs;
	   return tmp;
       }

       The implementation in bobcat/binops is slightly more complex as it allows from lhs or rhs promotions.

       As the binary operators can all be implemented alike their definitions are perfectly suited for templates: A class  offering  a	particular
       operator@=  then automatically also offers the matching binary operators after including bobcat/binops. Since the binary function templates
       are not instantiated until used their definitions can be processed by the compiler even if a class implements only a subset of  the  avail-
       able binary assignment operators.

NAMESPACE

       The binary operator functions templates in bobcat/binops are not implemented in a particular namespace. This allows sources to include bob-
       cat/binops in multiple namespaces.

       If bobcat/binops is to be used in multiple namespaces then the include safeguard (using the  identifier	INCLUDED_BOBCAT_BINOPS_)  must	be
       suppressed between inclusions of bobcat/binops in different namespaces.

       E.g.,  to  make	the  binary  operator function templates available in a source file using the namespace FBB and in a source file using the
       default namespace the following scheme can be used:

       #include <utility>	       // ensure std::move is available
       #include <bobcat/typetrait>     // required by binops

       namespace MY_NAMESPACE
       {
	   #include <bobcat/binops>    // binary operators available in MY_NAMESPACE
       }
       #undef INCLUDED_BOBCAT_BINOPS_  // suppress the include guard

       #include <bobcat/binops>        // read binops again so the binary
				       // operators can be used in the
				       // default namespace as well

INHERITS FROM

       -

OVERLOADED OPERATORS

       The function templates in bobcat/binops implement all arithmetic binary operators, both move-aware and the  traditional	binary	operators,
       expecting  constant  lvalue  references.  They  can be used if the matching binary assignment operators were implemented in the classes for
       which the templates must be instantiated. The following operators are available:

       Move-aware operators, using temporary objects for its left-hand side operands:

       o      Class operator*(Class &&lhs, Class const &rhs):

       o      Class operator/(Class &&lhs, Class const &rhs):

       o      Class operator%(Class &&lhs, Class const &rhs):

       o      Class operator+(Class &&lhs, Class const &rhs):

       o      Class operator-(Class &&lhs, Class const &rhs):

       o      Class operator<<(Class &&lhs, Class const &rhs):

       o      Class operator>>(Class &&lhs, Class const &rhs):

       o      Class operator&(Class &&lhs, Class const &rhs):

       o      Class operator|(Class &&lhs, Class const &rhs):

       o      Class operator^(Class &&lhs, Class const &rhs):

       `Traditional' operators, using lvalue references to constant objects for its left-hand side operands:

       o      Class operator*(Class const &lhs, Class const &rhs):

       o      Class operator/(Class const &lhs, Class const &rhs):

       o      Class operator%(Class const &lhs, Class const &rhs):

       o      Class operator+(Class const &lhs, Class const &rhs):

       o      Class operator-(Class const &lhs, Class const &rhs):

       o      Class operator<<(Class const &lhs, Class const &rhs):

       o      Class operator>>(Class const &lhs, Class const &rhs):

       o      Class operator&(Class const &lhs, Class const &rhs):

       o      Class operator|(Class const &lhs, Class const &rhs):

       o      Class operator^(Class const &lhs, Class const &rhs):
	      The latter group of operators also support promotions.

EXAMPLE

       #include <iostream>
       #include <utility>

       #include "../../typetrait/typetrait"
       #include "../binops"

       class Demo
       {
	   friend std::ostream &operator<<(std::ostream &out, Demo const &demo);
	   int d_value;

	   public:
	       Demo(int value = 0)
	       :
		   d_value(value)
	       {}

	       Demo(Demo const &other)
	       :
		   d_value(other.d_value)
	       {
		   std::cout << "Demo CC called
";
	       }

	       Demo &operator+=(Demo const &rhs)
	       {
		   d_value += rhs.d_value;
		   return *this;
	       }
       };
       std::ostream &operator<<(std::ostream &out, Demo const &demo)
       {
	   return out << demo.d_value;
       }

       using namespace std;

       int main()
       {
	   Demo four(4);
	   Demo five(5);

	   cout << four + five << '
' <<
		   four + 5 << '
' <<
		   4  + five << '
';
       }

FILES

       bobcat/binops - defines the binary operator function templates

SEE ALSO

       bobcat(7)

BUGS

       o      The header files utility, defining std::move, and bobcat/typetrait are required by, but are not included by bobcat/binops. This  was
	      a design decision, see the NAMESPACE section.

DISTRIBUTION FILES

       o      bobcat_3.01.00-x.dsc: detached signature;

       o      bobcat_3.01.00-x.tar.gz: source archive;

       o      bobcat_3.01.00-x_i386.changes: change log;

       o      libbobcat1_3.01.00-x_*.deb: debian package holding the libraries;

       o      libbobcat1-dev_3.01.00-x_*.deb: debian package holding the libraries, headers and manual pages;

       o      http://sourceforge.net/projects/bobcat: public archive location;

BOBCAT

       Bobcat is an acronym of `Brokken's Own Base Classes And Templates'.

COPYRIGHT

       This is free software, distributed under the terms of the GNU General Public License (GPL).

AUTHOR

       Frank B. Brokken (f.b.brokken@rug.nl).

libbobcat1-dev_3.01.00-x.tar.gz 				     2005-2012							   binops(3bobcat)