binops(3bobcat)

📦
version 6.15.01 · 7 versions
, in ubuntu stonking

💖 NAME 💖

okay so bestie, meet binops — it's from the binops(3bobcat) page, aka the Binary Operators girlie 🎀. template functions for class-type binary operators. that's the whole vibe. no cap.

✨ SYNOPSIS ✨

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

three includes, that's the whole entrance. slay 💅

🦋 DESCRIPTION 🦋

so here's the tea, bestie. classes can overload binary operators. like, a class named Class can overload these binary operators to suit its own needs — which means, for example, two Class type objects can literally be added once you've overloaded operator+. 💖

the binary operators you can overload are *, /, %, +, -, <<, >>, &, |, and ^ — and in this man page they're all generically referred to as the @ operator. you overload one by defining the operator@ function. periodt.

now here's where it gets iconic: if a class supports copy construction and it offers binary assignment operators (i.e., it offers members of the form operator@=), then all the matching binary operators can be implemented identically. like, the exact same way every single time. 😭

the move-aware Class &operator@(Class &&lhs, Class const &rhs) is easily implemented in terms of operator@= (and note that the class itself doesn't have to be "move-aware" to define this function, iykyk). the move-aware binary operator just needs a one line implementation, and since its implementation never changes it could safely be defined inline:

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

and 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, because it allows from lhs or rhs promotions. that's the little extra spice 🌶️

and because the binary operators can all be implemented alike, their definitions are perfectly suited for templates — chef's kiss 👑. so a class offering a particular operator@= automatically also offers the matching binary operators after including bobcat/binops. and since the binary function templates are not instantiated until they're used, their definitions can be processed by the compiler even if a class implements only a subset of the available binary assignment operators. no crash, no drama, it just works. 💜

🌸 NAMESPACE 🌸

plot twist: the binary operator function templates in bobcat/binops are not implemented in a particular namespace. that's on purpose, bestie — it allows sources to include bobcat/binops in multiple namespaces.

heads up though: if bobcat/binops is going 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. don't skip this step, fr fr. 🙈

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

see how it works? undef, re-include, boom — both namespaces get the goods. 💅

🧚 INHERITS FROM 🧚

-

(yep, nothing. it inherits from nobody. independent queen energy. 👑)

🔥 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. you can use them if the matching binary assignment operators were implemented in the classes for which the templates must be instantiated. here's the full roster: ⭐

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

  • Class operator*(Class &&lhs, Class const &rhs)
  • Class operator/(Class &&lhs, Class const &rhs)
  • Class operator%(Class &&lhs, Class const &rhs)
  • Class operator+(Class &&lhs, Class const &rhs)
  • Class operator-(Class &&lhs, Class const &rhs)
  • Class operator<<(Class &&lhs, Class const &rhs)
  • Class operator>>(Class &&lhs, Class const &rhs)
  • Class operator&(Class &&lhs, Class const &rhs)
  • Class operator|(Class &&lhs, Class const &rhs)
  • Class operator^(Class &&lhs, Class const &rhs)

and the "traditional" operators, using lvalue references to constant objects for its left-hand side operands:

  • Class operator*(Class const &lhs, Class const &rhs)
  • Class operator/(Class const &lhs, Class const &rhs)
  • Class operator%(Class const &lhs, Class const &rhs)
  • Class operator+(Class const &lhs, Class const &rhs)
  • Class operator-(Class const &lhs, Class const &rhs)
  • Class operator<<(Class const &lhs, Class const &rhs)
  • Class operator>>(Class const &lhs, Class const &rhs)
  • Class operator&(Class const &lhs, Class const &rhs)
  • Class operator|(Class const &lhs, Class const &rhs)
  • Class operator^(Class const &lhs, Class const &rhs)
    • this latter group of operators also supports promotions. 🫶

🌈 EXAMPLE 🌈

okay bestie, actual working code, look at her go:

#include <iostream>
#include <utility>

#include <bobcat//typetrait>
#include <bobcat/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\n";
        }

        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 << ’\n’ <<
            four + 5 << ’\n’ <<
            4  + five << ’\n’;
}

see? only operator+= was hand-written and yet four + five, four + 5 and 4 + five all just work. promotions said yes. the template ate. 🔥

🎀 FILES 🎀

  • bobcat/binops — defines the binary operator function templates

💜 SEE ALSO 💜

💀 BUGS 💀

  • the header files utility, defining std::move, and bobcat/typetrait are required by, but are not included by bobcat/binops. (not a mistake, bestie — this was a design decision, see the NAMESPACE section above. 🙈)

⭐ BOBCAT PROJECT FILES ⭐

Debian Bobcat project files:

  • libbobcat6 — debian package containing the shared library, changelog and copyright note
  • libbobcat-dev — debian package containing the static library, headers, manual pages, and developer info

👑 BOBCAT 👑

Bobcat is an acronym of "Brokken's Own Base Classes And Templates". 🐱 iconic name, honestly.

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

✨ AUTHOR ✨

Frank B. Brokken (f.b.brokken@rug.nl). thank you legend 🫡

and that's the whole page, bestie!! this was binops(3bobcat), shipped out of libbobcat-dev_6.15.01, dated 2005-2026 — yes she's been serving since 2005 and she's still going. 🌈 periodt. 💅✨

📦 where this page comes from