Объектно ориентированное программирование

#include <iostream>
#include <cmath>
#include <exception>
 
template <typename Argument, typename RootType = float>
class LinearEquation {
 public:
  class ExceptionA0: public std::exception {
    virtual const char* what() const throw() {
      return "Both parameters are zero. Equation has infinit number of roots.";
    }
  };
  class ExceptionNoRoots: public std::exception {
    virtual const char* what() const throw() {
      return "First parameter is zero. Equation has no roots.";
    }
  };
  LinearEquation(const Argument &a, const Argument &b) : a_(a), b_(b) {}
  LinearEquation() : a_(Argument()), b_(Argument()) {}
  RootType Root() const {
    if (a_ == 0 && b_ == 0) throw(ExceptionA0());
    if (a_ == 0) throw(ExceptionNoRoots());
    return -(b_ / RootType(a_));
  }
  void A(const Argument &value) { a_ = value; }
  void B(const Argument &value) { b_ = value; }
  Argument A() const { return a_; }
  Argument B() const { return b_; }
  LinearEquation &operator++() {
    ++a_;
    ++b_;
    return *this;
  }
  LinearEquation operator++(int) {
    LinearEquation result(a_, b_);
    ++a_;
    ++b_;
    return result;
  }
  friend std::ostream &operator<<(std::ostream &stream,
                                  const LinearEquation &equation) {
    return stream << equation.A() << " * x "
                  << ((equation.B() < 0) ? "- " : "+ ")
                  << fabs(equation.B())
                  << " = 0";
  }
 private:
  Argument a_;
  Argument b_;
};
 
int main(int argc, char *argv[]) {
  LinearEquation<float> a(0, 0);
  std::cout << ++a;
  try {
    std::cout << "; x = " << std::fixed << a.Root() << std::endl;
  } catch(std::exception &e) {
    std::cout << "; " << e.what() << std::endl;
  }
  return 0;
}

#include <iostream>
#include <cmath>
 
class Square {
 public:
  Square() : side_(0), x_(0), y_(0) {}
  explicit Square(float side) : side_(side), x_(0), y_(0) {}
  Square(float side, float x, float y) : side_(side), x_(x), y_(y) {}
  void Side(float value) { side_ = value; }
  void X(float value) { x_ = value; }
  void Y(float value) { y_ = value; }
  float Side() const { return side_; }
  float X() const { return x_; }
  float Y() const { return y_; }
  Square &operator--() {
    --side_;
    return *this;
  }
  Square &operator+=(float value) {
    x_ += value;
    y_ += value;
    return *this;
  }
  bool operator!=(const Square &other) {
    return fabs(other.Side() - Side()) > 0.00001; // some 'epsilon' value
                                                  // for float comparision
  }
  friend std::ostream &operator<<(std::ostream &s, const Square &square) {
    return s << std::fixed << "(" << square.X() << ", " << square.Y()
             << ") side: " << square.Side();
  }
 private:
  float side_;
  float x_;
  float y_;
};
 
int main(int argc, char *argv[]) {
  Square a(10), b(5, 1, 1);
  --a;
  a += 1;
  std::cout << a << std::endl << b << std::endl
            << ((a != b) ? "a != b" : "a == b") << std::endl;
  return 0;
}