STL Bounding Algoritmaları

Giriş
STL algoritmalarını işlevlerine göre gruplamak anlamayı çok daha kolaylaştırıyor. Algoritmaları kullanmak için

#include <algorithm>

yapmak gerekir.

Tüm Bounding Algoritmaları
Tüm algoritmaların çalışmasını gösterin şekil şöyle

+- lb(2) == ub(2)       +- lb(6)        +- lb(8)
|        == begin()     |  == ub(6)     |   +- ub(8) == end()
V                       V               V   V
+---+---+---+---+---+---+---+---+---+---+---+
| 3 | 4 | 4 | 4 | 4 | 5 | 7 | 7 | 7 | 7 | 8 |
+---+---+---+---+---+---+---+---+---+---+---+
    ^               ^                       ^
    |               |                       |
    +- lb(4)        +- ub(4)                +- lb(9) == ub(9) == end()

    |- eq-range(4) -|

Tüm Bounding Algoritmaları Verinin Sıralı Olmuş Olmasını Bekler
STL'de şu algoritmalar dizinin sıralı olmasını bekler.

binary_search, lower_bound, upper_bound, equal_range, set_union, set_intersection, set_difference, set_symmetric_difference, inplace_merge, includes.

equal_range
std::equal_range yazısına taşıdım.

lower_bound
std::lower_bound yazısına taşıdım.

upper_bound

std::upper_bound yazısına taşıdım.

lower_bound ve  upper_bound beraber

Açıklaması şöyle

Think of lower_bound and upper_bound as returning the range of where that item would be placed in the sorted array. If the search item doesn't occur in the sequence, they will always return the same iterator.

lower_bound + upper_bound ve lexicographic karşılaştırma
Normalde lower_bound ve upperd_bound denince hep sayısal büyüklük küçüklük kullanılıyormuş gibi bir algı var. Büyüklük küçüklük karşılaştırması lexicographic yani sözlük sıralamasına ve hatta tarihlere göre bile yapılabilir. Elimizde şöyle bir yapı olsun.

struct value {
  string code;
  string date;
  string name;
};

date alanı YYYY-MM-DD HH:MM:SS formatında tarih olsun. Belirtilen iki tarih arasındaki nesneler şöyle bulunur. lower_bound başlangıç tarihinden >= olan ilk değeri, upper_bound ise bitiş tarihinden > olan ilk değeri döndürdüğü için [from - to ] kapalı aralığındaki tarihler bulunur.

std::vector<value> get_between(const std::vector<value>& v,
        const std::string& from, const std::string& to)
{
  value fromv { "", from, "" };
  auto begin = std::lower_bound(v.begin(), v.end(), fromv,
    [](const auto& lhs, const auto& rhs) {
        return lhs.date < rhs.date;
  });

  value tov { "", to, "" };
  auto end = std::upper_bound(v.begin, v.end(), tov,
    [](const auto& lhs, const auto& rhs) {
        return lhs.date < rhs.date;
  });

  return std::vector<value>(begin, end);
}

std::difftime

Giriş
Farkı saniye ve double cinsinden döner.

Örnek
Şöyle yaparız.

time_t start = time(NULL);
...
time_t now = time(NULL);

double diff = difftime(now, start);

unsigned long long seconds = diff;
unsigned long long h = seconds / 3600;
seconds %= 3600;
unsigned long long m = seconds / 60;
seconds %= 60;
unsigned long long s = seconds;

printf("\r%02llu:%02llu:%02llu", h, m, s);

Nested Class

Giriş
Nested Class bir sınıfın içinde başka bir sınıfın olmasıdır. Inner Class ise bir metodun içinde sınıfın olmasıdır.

Örnek
Şöyle yaparız.

class Outer{

public:
    class Inner{

    public:
        void display(){
             cout << "You are in inner class" << endl;
        }
     };
     void display(){
         cout << "You are in outer class" << endl;
     }
};

Erişmek için şöyle yaparız.

Outer::Inner* p = new Outer::Inner;
p->display();
delete p;

Inner Class

Giriş
Local class olarak ta adlandırılıyor. Local class bir metoda yardım etmek için kullanılır.

Inner Class bir metodun içinde sınıfın olmasıdır. Nested Class ise bir sınıfın içinde başka sınıfın olmasıdır.

Dıştaki Metodun Local Class'a Erişimi
Her zamanki C++ kuralları gereğince dıştaki metod içerdiği local class'ın private alanlarına erişemez.
Ancak dıştaki metod friend yapılarak bu kural aşılabilir. Dıştaki metod haricinde bir başka metod friend yapılamaz!

"Enclosing function cannot access the private members of a local class. However, we can achieve this by declaring the enclosing function as a friend."

Örnek
Örnekte pqr metodu abc local sınıfını yaratıyor ve private x alanına erişiyor. pqr metodunun local class tarafından friend olarak tanındığına dikkat etmek lazım.

int pqr() {
    class abc {
        int x;
    public:
        abc() : x(4) { }
        friend int pqr();
    };
    return abc().x;
}

int main() {
    cout << "Return " << pqr() << endl;
}

Local Class'ın Dıştaki Metoda Erişimi
Aşağıda local class bir metod içinde tanımlı içteki sınıfın dıştaki metodun hangi alanlarına erişebileceği gösteriliyor. Local class'ın metodlar inline olmalı ve static attribute içermemeli.

void f() // function definition
{
  static int y; // static variable y can be used by local class
  int x; // auto variable x cannot be used by local class
  extern int g(); // extern function g can be used by local class

  class local
  {
    int g() {return x;} // error local variable x cannot be used by g
 
    int h () {return y;} // valid static variable y 
    int k () {return ::x;} // valid global x
    int l() {return g();} // valid extern function g
  }
}

Local Class'ın Dışa Verilmesi
Açıklaması şöyle.

name visibility doesn't hide the type. It just hides the name of the type.

Örnek
Şöyle yapabiliriz. a yapısıs func() içinde tanımlı olmasına rağmen döndürülebilir.

auto fun()
{
  struct a
  {
    int num = 10;
    a()
    {

      cout << "a made\n";
    }
    ~a()
    {
      cout << "a destroyed\n";
    }
  };
  static a a_obj;
  return a_obj;
}


int main()
{
  auto x = fun();
  cout << x.num << endl;

}

Örnek
Şöyle yapabiliriz. Hidden yapısı fun() içinde tanımlı olmasına rağmen döndürülebilir ve başka metoda parametre olarak geçilebilir.

auto fun()
{
  struct Hidden { int a; };

  return Hidden{24};
}

template <class T> auto fun2(T param)
{
  cout << param.a << endl; // OK
} 

auto test()
{
  fun2(fun()); // OK
}