Krzysztof Wesołowski » C++

Zapisywanie ustawień aplikacji – QSettings w QT

Krzysiek Wesołowski — Sun, 09 May 2010 18:13:28 +0000

Kontynuując tradycję rzadkich wpisów o ciekawych rzeczach które warto poznać/wykorzystać chciałbym wam przybliżyć trochę klasę QSettings. Do tej pory większość moich aplikacji nie potrafiło sensownie obsługiwać pamiętania różnych drobiazgów między uruchomieniami. Często najważniejsze rzeczy zapisywano w jakimś "własnym" typie plików, podczas gdy cała reszta była resetowana po każdym uruchomieniu.

Klasa QSettings rozwiązywała część tych problemów - pozwalając skierować grupę ustawień do pliku/rejestru. Niestety, pierwszy wymyślony sposób ich użycia stał się bardzo szybko uciążliwy - zapisywanie setek ustawień w jednym miejscu, pilnowanie aby odczyt zgadzał się z zapisem - jak łatwo się domyślić szybko stało się to nie do opanowania.

Niedawno czytając dokumentację, i stając przed podobnym problemem znalazłem sensowniejsze podejście - wraz z dostarczonymi metodami pozwalające zminimalizować nakład pracy.

Zacznijmy od samego początku naszego programu, dostarczając parę istotnych informacji:

int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QApplication::setOrganizationName("RainLabs");
QApplication::setOrganizationDomain("rainlabs.pl");
QApplication::setApplicationName("Orbi Eye");
QApplication::setApplicationVersion("0.2 alpha");

AutoPhotoAdvanced b;
b.setWindowTitle(QApplication::applicationName()+" v"+QApplication::applicationVersion());
b.show();
return a.exec();

}

Po takim wywołaniu każda klasa potrzebująca skorzystać z ustawień może to zrobić niezwykle szybko i wygodnie - np. w konstruktorze/destruktorze, za pomocą:

QSettings settings;
settings.setValue(....) / settings.value(...)

dzięki takiemu podziałowi każde ustawienia są niezależne, zaś dokonane na początku ustawienia aplikacji pozwalają korzystać z domyślnego konstruktora, co ułatwia ich używanie w całym programie, nie uciekając się do kopiowania kawałka kodu tam i z powrotem lub co gorsza pamiętania jakie argumenty przekazać za każdym razem konstruktorowi.

Integracja Eclipse CDT z CodeSourcery dla ARM Cortex-M3

Krzysiek Wesołowski — Sat, 27 Feb 2010 01:28:49 +0000

Na blogu znajomego zamieściłem wpis na temat związany z nowoczesnymi mikrokontrolerami z którymi ostatnio miałem doczynienia - zapraszam do lektury.

Link: Integracja Eclipse CDT z CodeSourcery dla ARM Cortex-M3

OpenCV 2.0 + Windows

Krzysiek Wesołowski — Fri, 13 Nov 2009 19:51:34 +0000

Ze względu na kolejny projekt, w który się zaangażowałem, potrzebowałem działającej, sprawnej biblioteki do przetwarzania obrazu. Wybór padł na OpenCV, zaś strona projektu zaskoczyła nas wydaniem we wrześniu tego roku wersji 2.0. Niestety, próba kompilacji okazała się być podwójnie nieudana Zamieszczam więc krótki opis jak zmusić OpenCV do współpracy.

Linkowanie bibliotek - ustawienia linkera

Pierwszym problemem z jakim się zetknęliśmy było linkowanie bibliotek - rzut oka do katalogu z bibliotekami utwierdził nas w przekonaniu, że tutorial, którego używamy jest przeznaczony dla OpenCV1.0 lub 1.1. Tak czy inaczej w ustawieniach linkera należy dodać uzupełnione w stosunku do poprzedniej wersji wywołania:

-lopencv200 -lcxcore200 -lcvaux200 -lml200 -lcxts200 -lhighgui200

Zaś jako ścieżkę bibliotek (-L) domyślnie: C:\OpenCV2.0\lib

Taka modyfikacja wywołania pozwoli linkować nasze programy. Ważniejsze jest jednak rozwiązanie problemów związanych z samą kompilacją.

Używanie headerów

Kolejna rzecz, która przebiega sama w sobie bez niespodzianek, to dodanie katalogu z plikami *.h i *.hpp do wywołań kompilatora:

-IC:\OpenCV2.0\include\opencv

Rozwiązanie problemu z kompilacją

Niestety, pomimo iż biblioteka o tym jawnie nie wspomina, nie została ona dobrze przygotowana do pracy z obecną, stabilną wersją GCC. Aby uniknąć kłopotów przy kompilacji (kłopot==nie działa:)) Najlepiej wybrać nowszą wersję GCC. Pod systemem Windows jednym z lepszych wyborów jeśli chodzi o instalację kompilatora c++, narzędzi do budowania etc. jest pakiet MinGW. Do tej pory korzystałem z oficjalnego wydania MinGW, które "niestety" zawiera oficjalną wersję kompilatora GCC. Świetnie radził sobie on np. z kompilacją programów z biblioteką Qt. Będąc zmuszonym do rezygnacji z tego rozwiązania, a jednocześnie nie chcąc instalować ręcznie całej otoczki (make, binutils, etc.) skorzystałem z strony http://www.tdragon.net/recentgcc/. Najlepiej wybrać najnowszą wersję w wersji Bundled - nie ma wtedy ryzyka, że któraś z paczek zniknęła z serwera. Po instalacji nowego "pseudo" MinGW (która jest bardzo bezproblemowa) kompilacje z użyciem OpenCV rusza bez problemu.

Warto również zwrócić uwagę, iż Qt 4.5.3 również świetnie działa z GCC 4.4.1, zaś nowsze, "niestabilne" wersje GCC są coraz częściej używane (np pakiet GNU ARM używa GCC serii 4).

Program prezentujący działanie algorytmów działających na grafach

Krzysiek Wesołowski — Tue, 06 Oct 2009 22:01:06 +0000

Przy okazji podnoszenia jednej oceny powstał prosty program prezentujący 3 algorytmy operujące na grafach. Pozwala on wprowadzić dowolny graf, o rożnych wagach a następnie prezentuje jego rozwiązanie krok po kroku.

Program powstawał przy mniejszej lub większe niechęci przez wakacje. Pierwsza część programu to edycja i implementacja struktur grafowych. Klasy tam zaimplementowane pozwalają zaprojektować graf, zapisać go/wczytać i uruchomić fragment prezentujący dany algorytm. Drugą częścią jest abstrakcyjna klasa AbstractSolver, ułatwiająca pisanie klas rozwiązujących o spójnym wyglądzie i funkcjonalności. Właśnie te 3 przykładowe algorytmy stanowią drugą cześć, stworzoną już nie przeze mnie ale przez Jakuba Tutro i Pawła Górkę.

W tym projekcie najbardziej zadowala mnie rozplanowanie jego działania, i zaprojektowanie klas, które choć zapewne nie jest idealne, umożliwiło jasny podział pracy, zminimalizowało ilość kodu i zwiększyło elastyczność takiego rozwiązania.

Program powstawał przy równoczesnej pracy, dlatego do jej synchronizacji wykorzystałem darmowy serwis http://www.assembla.com/, a konkretnie udostępniony przez niego serwer SVN. Zainteresowani mogą pobrać projekt prosto z repozytorium: http://subversion.assembla.com/svn/graph-algorithms.

Dla nie potrafiących korzystać z SVN, lub tylko chcących zerknąć na efekt prac zamieszczam tutaj gotowy instalator z potrzebnymi plikami DLL (całość opiera się o biblioteki QT4.5).

Instalator: Instalator programu Grafy-Algorytmy

Pliki: Pliki wykonywalne i skrypt instalatora

Źródła: Źródła programu Grafy-Algorytmy

Używanie klasy QSyntaxHighlighter z bibliotek QT 4.4

Krzysiek Wesołowski — Sun, 04 Jan 2009 07:48:48 +0000

W ramach dodatkowego projektu z programowania w języku C++ wykonałem małą aplikację demonstrującą użycie klasy QSyntaxHighlighter z bibliotek Qt do kolorowania składni. Stworzona klasa HSyntaxHighlighter wykorzystuje przygotowane przez twórców Qt elementy co ułatwiło jej wykonanie. Program w prosty sposób koloruje składnie zgodnie z ustawieniami, umożliwia również dostosowanie kolorowania każdego rodzaju kodu do swoich potrzeb za pomocą:

wyboru czcionki odpowiedzialnej za daną część kodu
wyboru koloru czcionki
wyboru tła
oraz edycji wyrażeni/wyrażeń regularnych odpowiedzialnych za rozpoznawanie tekstu

Program obsługuje podstawowe bloki

Komentarz jednoliniowy
Komentarz wieloliniowy
Stałe znakowe
Stałe liczbowe
Dyrektywy preprocesora
Słowo kluczowe/zarezerwowane

ale jego struktura umożliwia łatwe dodawanie własnych bloków (poprzez edycje kilku stałych wartości przed kompilacją)

Ustawienia dotyczące kolorowania są przechowywane w plikach *.ini, za pomocą klasy QSettings.

Program został napisany w środowisku Eclipse CDT , z dodatkami QtEclipseIntegration do tworzenie interfejsu oraz Eclox w celu ułatwienia używania doxygen'a zaś kod został w całości udokumentowany (w j. angielskim) zgodnie z składnią Doxygen.

Zapraszam do przejrzenia i zgłaszania uwag.

Cały program objęty jest licencją GPL 3.0, źródła dostępne poniżej.

Syntax Highlighter 1.0 (wraz z plikami DLL od Qt)

Syntax Highlighter 1.0 (tylko plik exe)

Syntax Highlighter 1.0 (źródła)

Syntax Highlighter 1.0 (dokumentacja)

Licencja GPL 3.0

Wersja 1.1

Poprawiono:

dynamiczna edycja listy bloków, kilka poprawek estetycznych. Bloki podświetlają się niezależnie, po kolei.

Syntax Highlighter 1.1 (wraz z plikami DLL od Qt)

Syntax Highlighter 1.1 (tylko plik exe)

Syntax Highlighter 1.1 (źródła)

Syntax Highlighter 1.1 (dokumentacja)

Licencja GPL 3.0

Eclipse CDT – środowisko C/C++

Krzysiek Wesołowski — Tue, 14 Oct 2008 23:51:04 +0000

Instalacja Eclipse:

Najpierw zainstalujemy środowisko Eclipse CDT, czyli program Eclipse wzbogacony o dodatkowe wtyczki ułatwiające pracę w językach C/C++.

Pobieramy go ze strony:

http://www.eclipse.org/downloads/
wersja: Eclipse IDE for C/C++ Developers

Pobierzesz w ten sposób skompresowana wersje, która najlepiej sobie rozpakować w jakieś nieprzeszkadzające miejsce (przyjąłem ze to C:\Program Files).

Dodatkowo eclipse do działania może wymagać Javy (którą prawdopodobnie już dawno masz ją na swoim komputerze, jeśli nie, pobierzesz ją tutaj: http://java.com/pl/download/manual.jsp

Po pierwszym uruchomieniu Eclipse CDT, gdy mamy już Javę zostaniemy zapytani o domyślny katalog projektów etc, warto wybrać jakiś sensowny, na rzadko czyszczonym dysku, i zaznaczyć że nie chcemy więcej widzieć tego pytania. Niestety, uruchomione teraz środowisko wymaga jeszcze kompilatora.

Do naszych celów, że tak powiem edukacyjnych polecam MinGW. Najlepiej z TEJ STRONY pobrać "Automated MinGW Installer". Po jego uruchomieniu i zdecydowaniu że chcemy pobrać i zainstalować najlepiej wybrać wersję bieżącą (Current) a w liście programów do "MinGW base tools" dodać "g++ compiler" oraz "MinGW make". Pozostałe języki chętnie was uraczą swoimi kompilatorami gdy będziecie ich potrzebować . Po wybraniu ścieżki MinGW pobierze się i zainstaluje na twoim komputerze. Po jego instalacji można skasować ściągnięte instalki czy archiwa, oraz uruchomić system Windows ponownie.

Na dobry początek wykorzystajmy nasze nowe środowisko do stworzenia prostego programu, ot HelloWorlda wyświechtanego.

Klikamy (już w uruchomionym programie) na File->New->C++ Project. Wpisujemy jego nazwę oraz wybieramy "ToolChain" MinGW GCC, a jako "Project type" wybieramy Hello World C++ Project. Po wypełnienie podstawowych danych, które Eclipse umieści w komentarzach, projekt zostanie utworzony. Możemy przeglądać jego zawartość w drzewku po lewej, źródła domyślnie są w podkatalogu projektu o nazwie src. Projekt taki automatycznie się zbuduje (kompilacja i linkowanie), i możemy uruchomić go w małej dołączonej konsoli klikając zieloną strzałkę. Dodajmy do naszego projektu klasę, ot na przykład prymitywny 2 wymiarowy wektor. Niknięcie na File->New->Class włączy bardzo przyjemnego kreatora, który po podaniu nazwy i kilku własności wygeneruje potrzebne pliki wraz z domyślnymi zawartościami (konstrukcje warunkowego dołączania, konstruktor i destruktor etc).

Kod wygenerowany:

Listing:

//============================================================================
// Name : witaj.cpp
// Author : twoje imie
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include
using namespace std;
int main() {
cout << "Hello World!!!" << endl; // prints Hello World!!!
return 0;
}

Listing:

/*
* Vector.h
*
* Created on: 2008-10-15
* Author: twoje imie
*/
#ifndef VECTOR_H_
#define VECTOR_H_
class Vector {
public:
Vector();
~Vector();
};
#endif /* VECTOR_H_ */

Listing:

/*
* Vector.cpp
*
* Created on: 2008-10-15
* Author: twoje imie
*/
#include "Vector.h"
Vector::Vector() {
// TODO Auto-generated constructor stub
}
Vector::~Vector() {
// TODO Auto-generated destructor stub
}

Podsumowują: począwszy od pierwszego programu, Eclipse zmniejsza nakład pracy potrzebny aby napisać jakikolwiek program. Od kolorowania składni, poprzez wskazywanie linijek w których wystąpiły błędy i ostrzeżenia, jak i bogate możliwości konfiguracji, możliwość "podpowiadania" części kodu (możesz ją ręcznie wywoła za pomocą Ctrl+Spacja) a kończąc na obsłudze setek przydatnych wtyczek i wolności tego środowiska: przyda się ono każdemu piszącemu programy w C lub C++. Zachęcam do samodzielnego eksplorowania ustawień (Windows->Preferences) jak i sprawdzaniu rożnych funkcji dostępnych poprzez Menu programu czy menu kontekstowe.

Przeładowanie operatorów cześć 1.

Krzysiek Wesołowski — Mon, 14 Jul 2008 10:41:04 +0000

Słowem wstępu

Postaram się opisać na podstawie już wcześniej stworzonego programu (operacja na wektorach) jak przeładowywać w C++ podstawowe operatory.

Postaram się skupić na samym przeładowaniu, bez wchodzenia w szczegóły samego działania.

Operatory powinno się przeładowywać właśnie tam, gdzie ich działanie jest jednoznaczne na pierwszy rzut oka: działania arytmetyczne, operatory wejścia, wyjścia i inne, rzadziej używane o których wspomnę innym razem.

Ogólną ideą która powinna przyświecać przeładowywaniu to tworzenie przewidywalnych, zachowujących się analogicznie jak te wbudowane operatorów.

Przeładowany operator to po prostu funkcja o nazwie operator z dopisaną końcówką charakteryzującą operator, np operator+, operator*= etc. Samą funkcje można zdefiniować na dwa sposoby:

Jako funkcje składową klasy
wtedy napisanie obiekt1+obiekt2 oznacza wywołanie: obiekt1.operator+(obiekt2)
Jako funkcje globalną
wtedy napisanie obiekt1+obiekt2 oznacza wywołanie: operator+(obiekt1,obiekt2)

Operatory dodawania

Występuje w kilku wariacjach:

Zwykły operator dodawania:

Założenia:

Dodaje elementy tego samego/podobnego typu do siebie
Nie zmienia żadnego z elementów (żeby działało na obiektach stałych tak jak 2+5)
Wynik powinien być zwrócony przez wartość (gdyż obiekty wewnątrz funkcji utworzone mogą zostać zniszczone już po jej zakończeniu)

Przykład:

Listing:

class Vector {
...
public:
Vector operator+(const Vector& rhs) const;
...
}

Listing:

Vector operator+(const Vector& lhs,const Vector& rhs);

Obie metody działają, natomiast zdecydowanie elegantsza wydaje się dla mnie być ta pierwsza, gdyż w gruncie rzeczy operator ten jest tak silnie związany z klasa że powinien być jej funkcją składową.

Operator dodawania do lewej strony:

Założenia:

Dodaje elementy tego samego/podobnego typu do siebie
Zmienia element po lewej stronie (zwiększając go o wartość tego po prawej)
Wynik powinien być zwrócony przez referencje, tak aby wskazywał na właśnie przypisany obiekt. Zwracanie wyniku przez wartość byłoby nieefektywne z względu na pamięć (zbędne kopiowanie), natomiast ważne jest zwracanie w ogóle, aby poprawna była konstrukcja while( (i+=6)<20 )

Przykład, jako funkcja składowa (do takich będę się teraz ograniczał, ew zmiany są analogiczne jak powyżej)

Listing:

class Vector {
...
public:
Vector& operator+=(const Vector& rhs);
...
}

Operator odejmowania czyli operator- i operator -= są analogiczne, przejde więc do operatorów mnożenia. Wektory można mnożyć na 3 sposoby: wektor*liczba, liczba*wektor, wektor*liczba, oraz wektor*wektor (skalarne).

Mnożenie wektor*liczba

Założenia:

Mnoży wektor po lewej stronie razy liczbę
Zwraca nowy,przemnożony wektor
Zwraca oczywiście przez wartość

Przykład:

Listing:

class Vector {
...
public:
Vector operator*(const int& rhs) const;
...
}

Mnożenie wektor*=liczba

Założenia:

Mnoży wektor po lewej stronie razy liczbę
Zmienia lewą stronę wpisując wynik
Zwraca referencje do przemnożonego wektora (z tych samych przyczyn co operator+=)

Przykład:

Listing:

class Vector {
...
public:
Vector& operator*=(const int& rhs);
...
}

Nie miałoby natomiast sensu napisanie: liczba*=wektor, gdyż takie działanie, teoretycnzie powinno liczbe zmienic na wektor, co jest niemożliwe. Pozostaje nam operator liczba*wektor. Ponieważ operator jako skladowa swoja klase musi mieć po lewej stronie, jedynym wyjściem jest utworzenie funkcji globalnej, spełniającej praktycznie te same założenia co wektor*liczba.

Listing:

Vector operator* (const int& lhs,const Vector& rhs);

Często aby moc korzystać z zmiennych prywatnych klasy Vector, takie funkcje nie deklaruje się poza ich ciałem, tylko wewnątrz definicji klasy jako funkcje zaprzyjaźnione:

Listing:

class Vector {
...
friend Vector operator* (const int& lhs,const Vector& rhs);
...
public:
...
}

Ostatni operator wart wymienia to proste mnożenie skalarne wektorów, którego przykład poniżej:

Listing:

class Vector {
...
public:
int operator*(const Vector& rhs) const;
...
}

Często dużo więcej można odczytać i zrozumieć z przykładowego kodu, dlatego poniżej zamieszczam w miarę dopieszczona klasę Vector

Udokumentowane źródła klasy Vector