22 grudnia 2013

Digital certificate

Rozglądam się w temacie certyfikatów cyfrowych podpisujących strony. Kilka linków i prost zabawa z OpenSSL.
Informacje o certyfikacie i sprawdzenie czy jest wystawiony przez zaufane źródło
# Informacje na temat certyfikatu wyeksportowanego z Firefox-a
$ openssl x509 -text -in A-Trust-nQual-03.pem

$ openssl verify A-Trust-nQual-03.pem 
A-Trust-nQual-03.pem: OK

21 grudnia 2013

[C++14] Hello world

Kompilacja z ficzerami dla C++14. Niestety dla clang-3.4 wymagało to trochę zachodu, ale w końcu się udało. Przed kompilacją trzeba było doinstalować "libc++-dev - LLVM C++ Standard library (development files)".
sudo apt-cache search libc
sudo apt-get install libc++-dev
Następnym krokiem była edycja pliku cstdio. Jak przeczytałem pod tym linkiem, ::gets najwyraźniej zostało usunięte ze standardu, a ja przy próbie kompilacje otrzymywałem następujący error:
/usr/include/c++/v1/cstdio:156:9: error: no member named 'gets' in the global namespace
using ::gets;
      ~~^
1 error generated.
Sama poprawka jaką należy wprowadzić do /usr/include/c++/v1/cstdio, czyli otoczyć gets defajnsem:
#if !_ISOC11_SOURCE
using ::gets;
#endif
Kompilacja wygląda następująco:
$ clang++ -std=c++1y -stdlib=libc++ main.cpp
I kod, na którym testowałem
#include <iostream>

using namespace std;

auto fun() {
    return "Hello world";
}

int main() {
    cout << fun() << endl;
    return 0;
}

11 grudnia 2013

[C++11] Dziedziczenie/unhide konstruktora

W nowym standardzie klasa pochodna może odziedziczyć (jest to właściwie mechanizm unhide, jaki był do tej pory dostępny tylko dla metod) swój konstruktor z jednej lub więcej klas bazowych. Jeżeli taki sam konstruktor (z takimi samymi parametrami) pojawi się w kilku klasach bazowych należy zdefiniować własną wersję w klasie pochodnej. Ciekaw linki:
Mechanizm pozwala na niejawne zadeklarowanie wszystkich konstruktorów, które nie są: domyślnymi, copy/move ani konstruktorami o takiej samej sygnaturze jak już istniejące konstruktory z klasy bazowej.

W poniższym przykładzie klasa Derived, dziedziczy z dwóch klas bazowych, dla których zachodzi konflikt dla Base1(int) i Base2(int), powodujący błąd kompilacji. Aby się go pozbyć w klasie pochodnej należało stworzyć własną wersję tego konstruktora. Ponieważ w Derived pojawił się już konstruktor, kompilator nie wygeneruje za nas konstruktora domyślnego (linia 32 - nie działa) - można stworzyć własną wersję.
#include <iostream>
#include <vector>
using namespace std;

struct Base1 {
    Base1() { cout << "Base1" << endl; }
    Base1(std::vector<int>) { cout << "Base1(vector)" << endl; }
    Base1(int) { cout << "Base1(int)" << endl; }
};

struct Base2 {
    Base2() { cout << "Base2" << endl; }
    Base2(int) { cout << "Base2(int)" << endl; }
};

struct Derived : public Base1, public Base2 {
    using Base1::Base1;
    using Base2::Base2;

    // Ta wersja konstruktora znajduje się w Base1 i Base2
    // należy zdefiniować jej własną wersję!
    Derived(int i) : Base1(i), Base2(i) {
        cout << "Derived(int)" << endl;
    }
};

struct SimpleDerived : public Base1 {
   using Base1::Base1;
};

int main() {
//  Derived d1;
    Derived d2(789);
    Derived d3({1, 2});

    SimpleDerived s1;
    SimpleDerived s2(42);
    SimpleDerived s3({1, 2});

    return 0;
}
Wynik:
Base1(int)
Base2(int)
Derived(int)

Base1(vector)

Base2
Base1

Base1(int)

Base1(vector)

7 grudnia 2013

Ubuntu 13.10 - konfiguracja

Kolejna przesiadka tym razem na Ubuntu 13.10.

Układ klawiatury

Niestety w tej wersji wyparowała opcja zmiany układu klawiatury, co w moim przypadku powoduje uciążliwy problem w korzystaniu z klawiszy Shift+Home i Shift+End, które mam na klawiaturze numerycznej. Można skorzystać z rozwiązania jakim jest gnome-tweak-tool.
Znalazłem jeszcze jedno rozwiązanie, które nadaje się do wykorzystanie z fluxbox-em.
Przez wpisanie do .bashrc
# Set numeric keypad behavour so that shift <numeric key> works the same
# as shift <cursor key> when numlock is off.
setxkbmap -option numpad:microsoft

Wyłączenie konta gościa

Trzeba dopisać na koniec pliku /etc/lightdm/lightdm.conf.d/50-unity-greeter.conf
allow-guest=false

Zwalnianie miejsca na dysku

Doszło do tego, że zaczęło mi brakować miejsca, na partycji. Pomocne okazało się kilka opcji dla apt-get
# Czyści lokalne repozytorium, ze ściągniętymi paczkami. Usuwa paczki, 
# których już nie można ściągnąć i są w zasadzie bezużyteczne.
sudo apt-get autoclean

# Usuwa pliki które są cache-owane, kiedy program jest instalowany 
# albo uaktualniany.
sudo apt-get clean

# Usuwa paczki, które zostały zainstalowane w celu nasycenia 
# zależności dla innych  paczek i nie są już potrzebne.
sudo apt-get autoremove

1 grudnia 2013

[C++11] Wyjątki i noexcept

Jeżeli wyjątek wystąpi w konstruktorze, nawet jeżeli obiekt jest tylko częściowo stworzony standard gwarantuje, że stworzone już dotąd obiekty zostaną poprawnie zniszczone. Tak samo w przypadku gdy wyjątek wystąpi w momencie inicjalizacji tablicy albo kontenera.

Jeżeli destruktor działa na operacji, która może zniszczyć obiekt, powinien on z-wrapować taką operację w blok try i obsłużyć wyjątek lokalnie. Destruktory nie powinny rzucać wyjątków! Jeżeli podczas zwijania stosu destruktor rzuci wyjątkiem którego sam nie złapał program zostanie zterminowany.
#include <iostream>
using namespace std;

struct MyClass {
    ~MyClass() /* noexcept */ {
        throw std::exception();
    }
};

int main() {
    MyClass a;
    return 0;
}
Wynik:
terminate called after throwing an instance of 'std::exception'
  what():  std::exception
The program has unexpectedly finished.
Kilka zasad dotyczących tworzenia, rzucania i łapania wyjątków:
  • Obiekty wyjątków, które są rzucane, muszą mieć dostępny destruktor, a także konstruktor kopiujący lub konstruktor move.
  • Najbardziej wyspecjalizowany catch musi pojawić się jako pierwszy.
  • Aby wyrzucić wyjątek wyżej, trzeba podać throw bez wyrażenia (throw;).
  • Aby złapać wyjątek każdego typu trzeba skorzystać z catch(...), który powinien zawsze pojawiać się jako ostatni.
#include <iostream>
#include <typeinfo>
#include <stdexcept>
using namespace std;

void old() {
    throw std::runtime_error("old()");
}

void young() {
    try {
        old();
    } catch(const std::bad_cast& e) {
        cout << e.what() << endl;
    } catch(...) {
        cout << "unknown, rethrow" << endl;
        throw;
    }
}

int main() {
    try {
        young();
    } catch(const std::runtime_error& e) {
        cout << "in main: " << e.what() << endl;
    }

    return 0;
}
Wynik:
unknown, rethrow
in main: old()

Lista inicjalizacyjna konstruktora

Konstruktor nie może złapać wyjątków rzuconych z listy inicjalizacyjnej. Aby się przed tym ustrzec, blok try musi znajdować się przed dwukropkiem. Zachowanie jest podobne w działaniu do zwykłych try-catch, z tą różnicą że złapany wyjątek zostanie ponownie wyrzucony z bloku.
#include <iostream>
#include <stdexcept>
using namespace std;

struct Member {
    Member() { }
    Member(Member& m) {
        throw std::runtime_error("Constructor");
    }
};

struct BadCalss {
    Member member;
    BadCalss(Member& m) try : member(m) {
        // body
    } catch(...) {
        cout << "some bug" << endl;
    }
};

int main() {
    Member m;
    BadCalss bc(m);
    return 0;
}
Wynik:
some bug
terminate called after throwing an instance of 'std::runtime_error'
  what():  Constructor
The program has unexpectedly finished.

noexcept

W nowym standardzie pojawił się specjalny specyfikator noexcept. Jeżeli wiemy, że funkcja nie będzie rzucać wyjątku, może z tej informacji skorzystać i programista i kompilator. Wspominał o tym również Scott Meyers w swoim wykładzie na Going Native 2013. Kompilator w takim przypadku wygeneruje znacznie mniej kodu, który będzie bardziej optymalny w działaniu.
#include <iostream>
#include <stdexcept>
using namespace std;

void fun() noexcept {
    throw std::runtime_error("fun()");
}

// gun() ma taki sam specyfikator rzucanych typów jak fun()
void gun() noexcept(noexcept(fun())) {
    cout << "gun()" << endl;
}

int main() {
    fun();
    return 0;
}
Wynik:
terminate called after throwing an instance of 'std::runtime_error'
  what():  fun()
The program has unexpectedly finished.
W rezultacie noexpect powinno być stosowane w dwóch przypadkach. Kiedy jesteśmy przekonani, że funkcja nie rzuci wyjątku albo/i gdy nie chcemy obsługiwać błędu. Jeżeli z funkcji (oznaczonej jako noexcept) zostanie jednak rzucony wyjątek, natychmiast zawołane zostanie std::terminate().

Inny przykład, w którym wyjątek przelatuje przez funkcję z noexcept, co powoduje zterminowanie programu.
#include <iostream>
#include <stdexcept>

using namespace std;


void fun_a() {
    throw std::runtime_error("bug");
}

void fun_b() noexcept {
    fun_a();
}

void fun_c() {
    try {
        fun_b();
    } catch(...) {
        cout << "Exception caught" << endl;
    }
}

int main() {
    fun_c();
}
Wynik:
terminate called after throwing an instance of 'std::runtime_error'
  what():  bug
The program has unexpectedly finished.
Niektóre kontenery jak np. std::vector, sprawdzają (podczas realokacji wektora), czy "move konstruktor" jest oznaczony jako noexcept. Jeżeli tak nie jest zostanie zwołany zwykły konstruktor kopiujący, co jest operacją dużo wolniejszą. Odpowiedni eksperyment stworzyłem w innym artykule.
Poza "move konstruktorem" noexcept standardowo powinno znaleźć się również w deklaracji destruktora.

Stare - throw()

W poprzedniej wersji standardu istniało słowo kluczowe throw(), które obecnie jest uznawane za przestarzałe. Można było za jego pomocą wyspecyfikować jakiego rodzaju wyjątki mogą być wyrzucone z funkcji, albo (odpowiednik noexpect) że funkcja nie rzuci żadnego wyjątku.
int fun(std::string& b) throw();

30 listopada 2013

[C++11] Wskaźniki na metody i pola klasy

Wskaźniki na funkcje, a co dopiero na metody klas zawsze sprawiały mi problemy. Nowy standard oferuje kilka narzędzi, dzięki którym praca z nimi staje się trochę łatwiejsza. Dużo fajnych opisów znalazłem pod poniższym linkiem.
Możemy stworzyć wskaźnik na pola lub metody, korzystając z auto bądź decltype, zamiast pisać skomplikowaną deklarację (w starym stylu). Analogicznie do operatorów odwołujących się do zmiennych obiektu (. oraz ->) istnieją dwa mechanizmy do odwołania się do pola (zmiennej lub metody) przez wskaźnik: .* oraz ->*.

Poniżej ptr_name, jest wskaźnikiem na pole MyClass::name. Dla ptr_name2 skorzystałem z auto dzięki czemu deklaracja znacznie się skróciła.
#include <iostream>
using namespace std;

struct MyClass {
    std::string name;
};

int main() {
    MyClass m;

    std::string MyClass::*ptr_name = &MyClass::name;

    m.name = "tekst";
    MyClass *d = &m;
    cout << d->*ptr_name << endl;
    cout << m.*ptr_name << endl;

    m.*ptr_name = "blow";
    cout << m.name << endl;

    auto ptr_name2 = &MyClass::name;
    m.*ptr_name2 = "blow up";
    cout << m.name << endl;

    return 0;
}
Wynik:
tekst
tekst
blow
blow up

Wskaźnik do metody w klasie

Na początek prosty przykład z wołaniem metody bezargumentowej. Standard wprowadza dodatkowe trzy mechanizmy pozwalające na odwołanie się to metody klasy. Są to std::function (klasa szablonowa), std::mem_fn oraz std::bind pozwalająca na wygenerowanie wołanego obiektu ze wskaźnika na funkcję. Ponieważ działam na metodach klasy spodziewam się, że std::mem_fn jest do tego najlepszym mechanizmem (z racji przeznaczenia), ale nie wiem, czy jest jakaś istotna różnica w porównaniu do dwóch pozostałych.
#include <algorithm>
#include <functional>
#include <iostream>

struct MyClass {
    MyClass(std::string s) : name(s) { }
    std::string info() {
        std::cout << "info " << name << std::endl;
        return name;
    }
    int fun(char*) {
        std::cout << "fun " << name << std::endl;
        return 8;
    }

    std::string name;
};

int main() {
    using namespace std::placeholders;
    std::vector<MyClass> vec {MyClass("a"), MyClass("b"), MyClass("c")};

    std::function<std::string (MyClass&)> pinfo1 = &MyClass::info;
    std::for_each(begin(vec), end(vec), pinfo1);

    std::for_each(begin(vec), end(vec), std::mem_fn(&MyClass::info));

    auto pinfo2 = std::bind(&MyClass::info, _1);
    std::for_each(begin(vec), end(vec), pinfo2);

    return 0;
}
Następny przykład to wołanie metody (MyClass::fun) posiadającej jeden argument. Na początku deklaracja wskaźnika na funkcję w starym dobrym stylu (pfun1) i jej uproszczona wersja korzystająca z auto (pfun2). Korzystanie z std::function oraz std::mem_fn jest już trochę bardziej skomplikowane i wymaga zastosowania lambdy (nie jestem pewien, czy można sobie to jeszcze jakoś bardziej ułatwić).

Najbardziej przejrzyste rozwiązanie powstało z std::bind dzięki placeholder-om. Warto pamiętać, że korzystając ze wskaźników na funkcję (tak przy deklaracji jak i wywołaniu), należy użyć dodatkowych nawiasów, ponieważ operator nawiasowy ma wyższy priorytet niż operator wskaźnika-na-pole (.*). Ogólne postać:
(Class::*fun)(param) (obj.*fun)(arg)
Pełny przykład:
#include <algorithm>
#include <functional>
#include <iostream>

struct MyClass {
    MyClass(std::string s) : name(s) { }
    std::string info() {
        std::cout << "info " << name << std::endl;
        return name;
    }
    int fun(const char* arg) {
        std::cout << "obj " << name << ", fun " << arg << std::endl;
        return 8;
    }

    std::string name;
};

int main() {
    using namespace std::placeholders;
    std::vector<MyClass> vec {MyClass("a"), MyClass("b"), MyClass("c")};

    int (MyClass::*pfun1)(const char*) = &MyClass::fun;
    std::for_each(begin(vec), end(vec), [&](MyClass& c){ (c.*pfun1)("pfun1"); });

    auto pfun2 = &MyClass::fun;
    std::for_each(begin(vec), end(vec), [&](MyClass& c){ (c.*pfun2)("pfun2"); });

    std::function<int(MyClass&, const char*)> pfun3 = &MyClass::fun;
    std::for_each(begin(vec), end(vec), [&](MyClass& c){ pfun3(c, "pfun3"); });

    std::for_each(begin(vec), end(vec),
                  [&](MyClass& c){ std::mem_fn(&MyClass::fun)(c, "std::mem_fn"); });

    std::for_each(begin(vec), end(vec), 
                  std::bind(&MyClass::fun, _1, "std::bind"));

    return 0;
}
A teraz problem, który od dawna chodził mi po głowie, czyli stworzenie funkcji hash-ującej dla unordered_map, bez wrapera w postaci free function. Ponieważ getHash() jest metodą const-ową, std::function musi to uwzględniać w parametrze.
#include <functional>
#include <iostream>
#include <unordered_map>

struct Color {
    Color(size_t v) : value(v) {}
    size_t getHash() const {
        std::cout << "getHash() " << value << std::endl;
        return value;
    }
private:
    size_t value;
};

int main() {
    using namespace std::placeholders;
    constexpr size_t bucket_count = 42;

    auto equalOp = [] (const Color& l, const Color& r)
                    { return l.getHash() == r.getHash(); };

    std::function<size_t(const Color&)> hashFun1 = &Color::getHash;
    std::unordered_map<Color,
            std::string,
            decltype(hashFun1),
            decltype(equalOp)> m1(bucket_count, hashFun1, equalOp);

    m1[Color(1)] = "blue";

    auto hashFun2 = std::mem_fn(&Color::getHash);
    std::unordered_map<Color,
            std::string,
            decltype(hashFun2),
            decltype(equalOp)> m2(bucket_count, hashFun2, equalOp);

    m2[Color(2)] = "red";

    auto hashFun3 = std::bind(&Color::getHash, _1);
    std::unordered_map<Color,
            std::string,
            decltype(hashFun3),
            decltype(equalOp)> m3(bucket_count, hashFun3, equalOp);

    m3[Color(3)] = "green";

    return 0;
}