Basic Custom Types / Classes Basic Custom Types Classes

class monotonous_counter {
  int count_;  // ← data member
…
  void increment () {  // ← member function
    ++count_; 
  }
};

class ascending_sequence {
  std::vector<int> seq_;  // ← data member
…
  void insert (int x) {   // ← member function
    // insert x into nums    // at the right position
  }
};

class ascending_sequence {
private:
  std::vector<int> seq_;
public: …
  void insert (int x) { … }
  int operator [] (size_t index) const {    return seq_[index];  }
};
int main () {
  ascending_sequence s;  // s.seq_: 
 
  s.insert(9);           // s.seq_: 
9
  s.insert(2);           // s.seq_: 
2
9
  s.insert(4);           // s.seq_: 
2
4
9
  cout << s[0] << '\n';  // prints '2'
  cout << s[1] << '\n';  // prints '4'
}

class Range {
  int a_;
  int b_;
public:
  // 1) special constructor
  explicit   Range (int a, int b): a_{a}, b_{b} {
    if (b_ > a_) std::swap(a_,b_);
  }
  // 2) special [a,a] constructor - delegates to [a,b] ctor
  explicit Range (int a): Range{a,a} {}
  // 3) default constructor - delegates to [a,a] ctor
  Range (): Range{0} {}
  …
};
Range r1;        // 3) ⇒ r1.a_: 0  r1.b_: 0
Range r2 {3};    // 2) ⇒ r2.a_: 3  r2.b_: 3
Range r3 {4,9};  // 1) ⇒ r3.a_: 4  r3.b_: 9
Range r4 {8,2};  // 1) ⇒ r4.a_: 2  r4.b_: 8

class A { … };
A a ();  // declares function 'a' 
         // without parameters
         // and return type 'A'
A a;     // constructs an object of type A
A a {};  // constructs an object of type A

#include <cstdint>
#include <numeric_limits>
class monotonous_counter {
public:
  // public type alias
  using value_type = std::uint64_t;
private:
  value_type count_ = 0;
public:
  value_type reading () const { return count_; }
  …
};
const auto max = std::numeric_limits<monotonous_counter::value_type>::max();

// unambiguous interface:
double volume (Cuboid const&);
// input guarantee: angle is in radians
Square make_rotated (Square const&,                     Radians angle);
// input: only valid quantity (e.g. > 0)
Gadget duplicate (Gadget const& original,                   Quantity times);
// result guarantee: vector is normalized
UnitVector3d dominant_direction (WindField const&);
// avoid confusion with a good units library
si::kg mass (EllipsoidShell const&,               si::g_cm3 density);
bool has_cycles (DirectedGraph const&);
// understandable control flow & logic:
Taxon species1 = classify(image1);
Taxon species2 = classify(image2);
Taxon lca = taxonomy.lowest_common_ancestor(            species1, species2);

#include <iostream>   // std::cout
#include <cstdint>    // std::uint64_t

class monotonous_counter {
public:
  using value_type = std::uint64_t;
private:
  value_type count_ = 0;  // initial
public:
  monotonous_counter () = default;

  explicit   monotonous_counter (value_type init) noexcept:     count_{init} {}

  void increment () noexcept { ++count_; }

  [[nodiscard]] value_type   reading () const noexcept {     return count_; }
};

int main () {
  monotonous_counter c;
  c.increment();
  std::cout << c.reading() << '\n';  // prints 1
  c.increment();
  c.increment();
  std::cout << c.reading() << '\n';  // prints 3
}

#include <iostream>   // std::cout
#include <vector>     // std::vector
#include <algorithm>  // std::lower_bound

class ascending_sequence {
public:
  using value_type = int;
private:
  using storage_t = std::vector<value_type>;
  storage_t seq_;
public:
  using size_type = storage_t::size_type;

  void insert (value_type x) {
    // use binary search to find insert position
    seq_.insert(      std::lower_bound(        seq_.begin(), seq_.end(), x), x);
  }

  [[nodiscard]] value_type   operator [] (size_type idx) const noexcept { 
    return seq_[idx]; }

  [[nodiscard]] size_type   size () const noexcept {     return seq_.size(); }

  // enable range based iteration
  [[nodiscard]] auto   begin () const noexcept {     return seq_.begin(); }

  [[nodiscard]] auto   end ()   const noexcept {     return seq_.end(); }
};

int main () {
  ascending_sequence s;  // s.seq_: 
 
  s.insert(7);           // s.seq_: 
7
  s.insert(2);           // s.seq_: 
2
7
  s.insert(4);           // s.seq_: 
2
4
7
  s.insert(9);           // s.seq_: 
2
4
7
9
  s.insert(5);           // s.seq_: 
2
4
5
7
9
  std::cout << s[3] << '\n';     // prints 7
  for (auto x : s) {
    std::cout << x <<' ';  // 2 4 5 7 9
  }
std::cout << '\n';
  // use type aliases
  ascending_sequence::value_type x = 1;
  ascending_sequence::size_type  n = 2;
}