dom / PRZEZ/ Programowanie w C (C) w Ubuntu (Linux). Wstęp

Programowanie w C (C) w Ubuntu (Linux). Wstęp

Wszystkie działania w systemie operacyjnym są wykonywane za pomocą programów, więc wielu początkujących jest zainteresowanych nie tylko korzystaniem z programów innych osób, ale także pisaniem własnych. Wielu chce współtworzyć bazę kodu OpenSource.

To jest artykuł przeglądowy na temat programowania w Linuksie. Zastanowimy się, które języki są najczęściej używane, rozważymy podstawowe pojęcia, a także możliwości, przeanalizujemy, jak pisać najprostszy program w jednym z najpopularniejszych języków programowania, jak go zbudować i uruchomić ręcznie.

Historycznie rzecz biorąc, jądro Uniksa zostało napisane w C. Co więcej, ten język został stworzony do pisania jądra Uniksa. Ponieważ jądro Linuksa było oparte na jądrze Minix (wersja Uniksa), zostało również napisane w C. Dlatego możemy powiedzieć, że głównym językiem programowania dla Linuksa jest C i C ++. Tendencja ta utrzymywała się przez długi czas.

Ogólnie rzecz biorąc, możesz pisać programy dla Linuksa w prawie każdym języku, od Javy i Pythona po C#, a nawet Pascal. Wszystkie języki mają kompilatory i tłumacze. Pisanie programów w C++ jest trudne, a C jest już przez wielu uważany za przestarzały, dlatego wielu programistów używa innych języków do pisania programów. Na przykład wiele narzędzi systemowych jest napisanych w języku Python lub Perl. Większość programów z Komendy Linuksa Mint, instalator Ubuntu i niektóre skrypty apt są napisane w Pythonie. Wiele skryptów, w tym proste skrypty optymalizacyjne, jest napisanych w Perlu. Czasami Ruby jest używany do pisania skryptów. Są to skrypty OpenShift lub np. framework Metasploit. Niektórzy programiści wieloplatformowi używają języka Java. Ale główne komponenty systemu są nadal napisane w C.

W tym artykule nie będziemy omawiać podstaw języka C. C jest złożonym językiem i będziesz musiał przeczytać co najmniej jedną książkę i dużo ćwiczyć, aby go opanować. Przyjrzymy się, jak pisać programy w C w systemie Linux, jak je budować i uruchamiać.

Dlaczego warto uczyć się C:

2. Biblioteki

Oczywiście, jeśli chcesz wyświetlić ciąg znaków lub obraz na ekranie, nie uzyskasz bezpośredniego dostępu do karty graficznej. Po prostu wywołujesz kilka funkcji, które są już zaimplementowane w systemie i przekazujesz im dane, które chcesz wyświetlić. Takie funkcje są umieszczane w bibliotekach. W rzeczywistości biblioteki są zbiorami funkcji używanych przez inne programy. Zawierają ten sam kod, co w innych programach, jedyną różnicą jest to, że niekoniecznie musi istnieć funkcja inicjalizacji.

Biblioteki dzielą się na dwa rodzaje:

Statyczny- są łączone z programem na etapie kompilacji, są łączone i po tym czasie wszystkie funkcje biblioteki są dostępne w programie jako natywne. Takie biblioteki mają rozszerzenie .a;
Dynamiczny- takie biblioteki są znacznie bardziej powszechne, są ładowane do pamięci RAM i są dynamicznie łączone z programem. Kiedy program potrzebuje biblioteki, po prostu wywołuje ją pod znanym adresem w pamięć o swobodnym dostępie. Oszczędza to pamięć. Rozszerzeniem tych bibliotek jest .so, które jest podobne do Shared Object.

Tak więc, dla każdego programu C, musisz dołączyć biblioteki, a wszystkie programy używają jakiejś biblioteki. Należy również zauważyć, że bez względu na to, w jakim języku zdecydujesz się pisać, ostatecznie wszystko zostanie zredukowane do bibliotek systemowych C. Na przykład piszesz program w Pythonie, używasz standardowych funkcji tego języka, a sam interpreter jest już programem C/C++, który korzysta z bibliotek systemowych, aby uzyskać dostęp do głównych funkcji. Dlatego ważne jest, aby zrozumieć, jak działają programy C. Oczywiście są takie języki jak Go, które są od razu tłumaczone na asembler, ale zasady są takie same jak tutaj. Ponadto programowanie systemu Linux to głównie C lub C++.

3. Proces montażu programu

Zanim przejdziemy do praktyki i stworzymy nasz pierwszy program, musimy zrozumieć, jak przebiega proces montażu, z jakich etapów się składa.

Każdy poważny program składa się z wielu plików, są to pliki źródłowe z rozszerzeniem .c oraz pliki nagłówkowe z rozszerzeniem .h. Te pliki nagłówkowe zawierają funkcje, które są importowane do programu z bibliotek lub innych plików.c. Zanim. jak kompilator może skompilować program i przygotować go do pracy, musi sprawdzić, czy wszystkie funkcje są rzeczywiście zaimplementowane, czy dostępne są wszystkie biblioteki statyczne i skompilować to w jeden plik. Dlatego najpierw wykonywany jest preprocesor, który buduje plik źródłowy, a instrukcje takie jak include są wykonywane w celu uwzględnienia kodu plików nagłówkowych.

W kolejnym etapie kompilator zaczyna działać, wykonuje wszystkie niezbędne akcje na kodzie, analizuje konstrukcje składniowe języka, zmienne i konwertuje to wszystko na kod pośredni, a następnie na kod instrukcji maszynowych, które możemy następnie spójrz na w asemblerze. Program na tym etapie nazywany jest modułem obiektowym i nie jest jeszcze gotowy do uruchomienia.

Następnie linker zaczyna działać. Jego zadaniem jest powiązanie modułu obiektowego z bibliotekami statycznymi i innymi modułami obiektowymi. Dla każdego pliku źródłowego tworzony jest osobny moduł obiektowy. Dopiero teraz można uruchomić program.

A teraz zobaczmy cały proces w praktyce przy użyciu kompilatora GCC.

4. Jak zbudować program

Istnieją dwa typy kompilatorów używanych do tworzenia programów w systemie Linux, są to . Jak dotąd GCC jest bardziej powszechny, więc rozważymy to. Zwykle program jest już zainstalowany w twoim systemie, jeśli nie, możesz uruchomić instalację w Ubuntu:

sudo apt zainstaluj gcc

Zanim przejdziemy do pisania i kompilowania programu, przyjrzyjmy się składni i opcjom kompilatora:

Opcje $ gcc plik_źródłowy_1.c -o plik_zakończony

Za pomocą opcji mówimy narzędziu, co ma robić, jakich bibliotek użyć, a następnie po prostu określamy pliki źródłowe programu. Przyjrzyjmy się opcjom, z których dziś skorzystamy:

-o- zapisz wynik do pliku wyjściowego;
-C- utworzyć plik obiektowy;
-X- określić typ pliku;
-l- załaduj bibliotekę statyczną.

Właściwie jest to najbardziej podstawowe, czego potrzebujemy. Teraz stwórzmy nasz pierwszy program. Wydrukuje linię tekstu na ekranie i, aby było ciekawiej, weźmie pierwiastek kwadratowy z 9. Oto kod źródłowy:

włączać
#włączać

int main()(
printf("strona\n");
printf("Root: %f\n", sqrt(9));
zwróć 0;
}

gcc -c program.c -o program.o

To jest etap kompilacji, jeśli w programie nie ma błędów, to się powiedzie. Jeśli istnieje kilka plików źródłowych, to takie polecenie jest wykonywane dla każdego z nich. Następnie wykonujemy linkowanie:

gcc -lm program.o -o program

Zwróć uwagę na opcję -l, za jej pomocą określamy, które biblioteki należy uwzględnić, na przykład tutaj dołączamy bibliotekę funkcji matematycznych, w przeciwnym razie linker po prostu nie znajdzie, gdzie jest ta lub inna funkcja. Dopiero potem możesz uruchomić program do wykonania:

Oczywiście wszystkie te czynności można wykonać przy użyciu różnych środowisk graficznych, ale robiąc wszystko ręcznie, można lepiej zrozumieć, jak to wszystko działa. Za pomocą polecenia ldd możesz zobaczyć, z jakich bibliotek korzysta nasz program:

Są to dwie biblioteki ładujące, standardowa libc i libm, które zawarliśmy.

5. Automatyzacja montażu

Rozważając programowanie pod Linuksem, nie sposób nie zauważyć systemu do automatyzacji montażu programów. Faktem jest, że gdy istnieje wiele plików źródłowych programu, nie będziesz ręcznie wprowadzać poleceń, aby je skompilować. Możesz je nagrać raz, a następnie używać ich wszędzie. Jest do tego narzędzie make i pliki Makefile. Ten plik składa się z elementów docelowych i ma następującą składnię:

cel: zależności
zespół

Zależność celu może być plikiem lub innym celem, głównym celem jest wszystko, a polecenie wykonuje niezbędne działania kompilacji. Na przykład dla naszego programu Makefile może wyglądać tak:

program:program.o
gcc -lm program.o -o program

program.o: program.c
gcc -c program.c -o program.o

Następnie wystarczy uruchomić polecenie make, aby rozpocząć kompilację, pamiętaj tylko, aby usunąć poprzednie pliki tymczasowe i zbudowany program:

Program jest ponownie gotowy i możesz go uruchomić.

wnioski

kreacja programy linuksowe bardzo ciekawe i ekscytujące. Przekonacie się o tym sami, gdy trochę oswoicie się z tą sprawą. Trudno omówić wszystko w tak krótkim artykule, ale omówiliśmy podstawy, które powinny dać ci podstawę. W tym artykule omówiliśmy podstawy programowania w systemie Linux, jeśli masz jakieś pytania, zadaj je w komentarzach!

Kurs programowania C dla systemu Linux:

Narzędziami tradycyjnie używanymi do pisania programów dla otwartych systemów operacyjnych są narzędzia deweloperskie GNU. Zróbmy małe tło historyczne. Projekt GNU został założony w 1984 roku przez Richarda Stallmana. Jego konieczność spowodowana była faktem, że w tamtym czasie współpraca między programistami była utrudniona, ponieważ właściciele reklamy oprogramowanie stworzyło wiele przeszkód dla takiej współpracy. Celem projektu GNU było stworzenie zestawu oprogramowania w ramach jednej licencji, która nie pozwalałaby nikomu na przypisywanie wyłącznych praw do tego oprogramowania. Częścią tego zestawu jest zestaw narzędzi programistycznych, którego będziemy używać, który powinien być dołączony do wszystkich dystrybucji Linuksa.

Jednym z takich narzędzi jest kompilator GCC. Ten akronim pierwotnie oznaczał GNU C Compiler. Teraz to oznacza - Kolekcja kompilatorów GNU.

Stwórzmy pierwszy program używając GCC. Zgodnie z tradycją pierwszy program po prostu wypisze powitanie „Witaj, świecie!” - "Witaj świecie!".

Pliki z kodem źródłowym programów, które będziemy tworzyć, to zwykłe pliki tekstowe, które można utworzyć za pomocą dowolnego edytora tekstu (np. GEdit KWrite, Kate i bardziej tradycyjni użytkownicy Linuksa vi i emacs). Oprócz edytorów tekstu istnieją wyspecjalizowane środowiska programistyczne z własnymi wbudowanymi edytorami. Jednym z takich narzędzi jest KDevelop. Co ciekawe posiada wbudowany edytor oraz wbudowaną konsolę znajdującą się tuż pod edytorem. Możesz więc bezpośrednio w jednym programie, bez przełączania się między oknami, edytować kod i wydawać polecenia konsoli.

Utwórz osobny katalog hello. To będzie nasz pierwszy katalog projektów. W nim stwórz plik tekstowy hello.c z następującym tekstem:

#włączać

printf("Witaj świecie!\n");

Następnie w konsoli przejdź do katalogu projektu. Wybierz zespół

Przyjrzyj się teraz dokładnie temu, co się stało. W katalogu pojawił się nowy plik a.out. To jest plik wykonywalny. Uruchommy to. Wpisz w konsoli:

Program powinien się uruchomić, czyli powinien pojawić się tekst:

Kompilator gcc domyślnie przypisuje nazwę a.out do wszystkich generowanych plików wykonywalnych. Jeśli chcesz nazwać go inaczej, musisz dodać flagę -o i nazwę, którą chcesz nazwać, do polecenia kompilacji. Wpiszmy następujące polecenie:

gcc hello.c -o cześć

Widzimy, że w katalogu pojawił się plik wykonywalny o nazwie hello. Uruchommy to.

Jak widać, wynikiem jest dokładnie ten sam plik wykonywalny, tylko z dogodną dla nas nazwą.

Flaga -o jest tylko jedną z wielu flag kompilatora gcc. Niektóre inne flagi zostaną omówione później. Możesz użyć systemu pomocy man, aby zobaczyć wszystkie możliwe flagi. Wpisz w wierszu poleceń:

Zostanie wyświetlony system pomocy dla tego programu. Sprawdź, co oznacza każda flaga. Niektórych z nich poznamy wkrótce. Wyjście z systemu pomocy odbywa się za pomocą klawisza q.

Oczywiście zauważyłeś, że kiedy uruchamiamy program z naszego katalogu programistycznego, przed nazwą pliku wpisujemy kropkę i ukośnik. Dlaczego to robimy?

Faktem jest, że jeśli wpiszemy tylko nazwę Plik wykonywalny, system operacyjny będzie go szukał w katalogach /usr/bin i /usr/local/bin i oczywiście go nie znajdzie. Katalogi /usr/bin i /usr/local/bin to katalogi lokalizacji systemu programy wykonywalne. Pierwszy z nich jest przeznaczony do obsługi stabilnych wersji programów, zwykle zawartych w Dystrybucja Linuksa. Drugi dotyczy programów zainstalowanych przez samego użytkownika (za których stabilność nikt nie ręczy). Taki system jest potrzebny, aby je od siebie oddzielić. Domyślnie programy są instalowane w katalogu /usr/local/bin podczas tworzenia. Jest wysoce niepożądane umieszczanie czegokolwiek dodatkowego w /usr/bin lub ręczne usuwanie czegokolwiek z tego miejsca, ponieważ może to doprowadzić do awarii systemu. Powinny tam być umieszczone programy, za których stabilność odpowiadają twórcy dystrybucji.

Aby uruchomić program znajdujący się w innym miejscu, musisz podać pełną ścieżkę do niego, na przykład:

/home/dima/projekty/cześć/cześć

Lub inna opcja: wpisz ścieżkę względną do bieżącego katalogu, w którym aktualnie znajdujesz się w konsoli. W tym przypadku jedna kropka oznacza bieżący katalog, dwie kropki - rodzica. Na przykład polecenie ./hello uruchamia program hello znajdujący się w bieżącym katalogu, polecenie ../hello uruchamia program hello znajdujący się w katalogu nadrzędnym, polecenie ./projects/hello/hello uruchamia program w podkatalogach znajdujących się wewnątrz bieżący katalog.

Możliwe jest dodanie dodatkowych katalogów do listy ścieżek systemowych do programów. W tym celu dodaj nową ścieżkę do zmiennej systemowej PATH. Ale nie odchodźmy na razie od głównego tematu. Zmienne środowiska to osobna rozmowa

Przyjrzyjmy się teraz, co robi program gcc. Jego praca obejmuje trzy etapy: wstępne przetwarzanie, kompilację i łączenie (lub łączenie).

Preprocesor dołącza zawartość wszystkich plików nagłówkowych określonych w dyrektywach #include do pliku głównego. Pliki nagłówkowe zwykle zawierają deklaracje funkcji używanych w programie, ale niezdefiniowanych w tekście programu. Ich definicje są gdzie indziej: albo w innych plikach źródłowych, albo w bibliotekach binarnych.

Drugim etapem jest kompilacja. Polega na zamianie tekstu programu w języku C/C++ na zestaw instrukcji maszynowych. Wynik jest przechowywany w pliku obiektowym. Oczywiście na maszynach z różnymi architekturami procesorów binaria uzyskuje się w różnych formatach, a na jednej maszynie nie da się uruchomić binaria zbudowanego na innej maszynie (chyba, że mają taką samą architekturę procesora i te same systemy operacyjne). Dlatego programy dla systemów typu UNIX są dystrybuowane jako kody źródłowe: powinny być dostępne dla wszystkich użytkowników, niezależnie od tego, kto ma jaki procesor i jaki system operacyjny.

Ostatnim etapem jest układ. Polega na połączeniu wszystkich plików obiektowych w projekcie w jeden, powiązaniu wywołań funkcji z ich definicjami oraz dołączeniu plików bibliotek zawierających funkcje, które są wywoływane, ale nie są zdefiniowane w projekcie. W rezultacie powstaje plik wykonywalny - nasz ostateczny cel. Jeśli funkcja jest używana w programie, ale linker nie znajdzie miejsca, w którym ta funkcja jest zdefiniowana, wyświetli komunikat o błędzie i odmówi utworzenia pliku wykonywalnego.

Zobaczmy teraz, jak to wszystko wygląda w praktyce. Napiszmy inny program. Będzie to najbardziej prymitywny kalkulator zdolny do dodawania, odejmowania, mnożenia i dzielenia. Po uruchomieniu poprosi o kolejno dwie liczby do działania, a następnie poprosi o wprowadzenie znaku operacji arytmetycznej. Mogą to być cztery znaki: „+”, „-”, „*”, „/”. Następnie program wyświetla wynik i zatrzymuje się (powraca do system operacyjny, a raczej do interpretera poleceń, z którego wywołaliśmy program).

Stwórzmy dla projektu nowy folder kalkul, utworzymy w nim plik kalkul.c.

#włączać

printf("Pierwsza liczba: ");

scanf("%f",&num1);

printf("Druga liczba: ");

scanf("%f",&num2);

printf(" Operator (+ - * /): ");

while ((op = getchar()) != EOF)

printf("%6.2f\n",num1 + num2);

inaczej if(op == "-")

printf("%6.2f\n",num1 - num2);

inaczej if(op == "*")

printf("%6.2f\n",num1 * num2);

inaczej if(op == "/")

printf("Błąd: dzielenie przez zero!\n");

przerwa;

printf("%6.2f\n",num1 / num2);

Przede wszystkim, jak powiedziano, przeprowadzane jest przetwarzanie wstępne. Aby zobaczyć, co jest robione na tym etapie, użyjemy opcji -E. Opcja ta zatrzymuje wykonywanie programu na etapie przetwarzania przez preprocesor. Wynikiem jest plik kod źródłowy z zawartością zawartych w nim plików nagłówkowych.

W naszym przypadku zawarliśmy jeden plik nagłówkowy - stdio.h - kolekcję standardowe funkcje wejście wyjście. Funkcje te wyprowadzają żądany tekst do konsoli, a także odczytują słowa, które wprowadzamy z konsoli.

Wpisz następujące polecenie:

gcc -E kalkul.c -o kalkul.cpp

Powstały plik nazwaliśmy kalkul.cpp. Otwórz to. Proszę zauważyć, że jest dość długi. Dzieje się tak, ponieważ zawiera cały kod w pliku nagłówkowym stdio.h. Ponadto preprocesor dodał tutaj kilka znaczników, które informują kompilator, jak komunikować się z zadeklarowanymi funkcjami. Główny tekst naszego programu jest widoczny tylko na samym dole.

Możesz także zobaczyć, jakie inne funkcje są zadeklarowane w pliku nagłówkowym stdio.h. Jeśli chcesz uzyskać informacje na temat konkretnej funkcji, możesz o to zapytać we wbudowanym man. Na przykład, jeśli nagle chcesz wiedzieć, co robi tajemnicza funkcja fopen, możesz wpisać:

Wiele informacji znajduje się również w informacji o systemie pomocy.

Możesz zapytać każdego plik nagłówkowy od razu.

Spójrzmy teraz na następny krok. Stwórzmy plik obiektowy. Plik obiektowy jest „dosłownym” tłumaczeniem naszego kodu programu na język maszynowy, ale bez powiązania wywoływanych funkcji z ich definicjami. Opcja -c służy do generowania pliku obiektowego.

Nazwę pliku wynikowego można pominąć, ponieważ kompilator po prostu pobiera nazwę pliku źródłowego i zmienia rozszerzenie .c na .o (można określić, czy chcemy nadać mu inną nazwę).

Jeśli tworzymy plik obiektowy ze źródła, które zostało już przetworzone przez preprocesor (takie jak to, które otrzymaliśmy powyżej), musimy wyraźnie wskazać, że kompilowany plik jest plikiem kodu źródłowego, który został przetworzony przez preprocesor i ma znaczniki preprocesora. W przeciwnym razie zostanie przetworzony jako zwykły plik C++, bez uwzględnienia znaczników preprocesora, co oznacza, że nie zostanie nawiązana relacja z zadeklarowanymi funkcjami. Opcja -x służy do jawnego wskazania języka i formatu przetwarzanego pliku. Plik C++ przetwarzany przez preprocesor jest oznaczony przez cpp-output.

gcc -x cpp-output -c kalkul.cpp

Wreszcie ostatnim krokiem jest układ. Otrzymujemy plik wykonywalny z pliku obiektowego.

gcc kalkul.o -o kalkul

Możesz to uruchomić.

Pytacie: „Po co to całe zamieszanie z etapami pośrednimi? Czy nie byłoby lepiej po prostu raz uruchomić gcc kalkul.c -o kalkul?"

Faktem jest, że prawdziwe programy bardzo rzadko składają się z jednego pliku. Z reguły istnieje kilka plików źródłowych, które są łączone w projekt. A w niektórych wyjątkowych przypadkach program musi być złożony z kilku części napisanych w różnych językach. W takim przypadku musisz uruchomić kompilatory różnych języków, aby każdy otrzymał plik obiektowy ze swojego źródła, a następnie połączyć te wynikowe pliki obiektowe w program wykonywalny.

Dmitry Panteleichev (dimanix2006 w rambler dot ru) - Wprowadzenie do kompilatora GCC

Nazwa: Programowanie w C++ w systemie Linux.

Książka „Programowanie w C++ w systemie Linux” jest poświęcona tworzeniu aplikacji C++ w środowisku programistycznym KDEvelop. Autor książki podaje szczegółowy opis interakcji komponentów aplikacji, obejmuje podstawy pracy z narzędziem Qt Designer oraz omawia kontrolki w oknach dialogowych i klasy, dla których są tworzone. Książka uczy koncepcji Document/View, tworzenia elementów interfejsu aplikacji. Poruszane są również takie tematy, jak zapisywanie i przywracanie różnych informacji wyświetlanych na ekranie, tworzenie edytorów tekstu, organizowanie wielozadaniowości w aplikacjach w oparciu o procesy interakcji oraz praca z szablonami klas i funkcji. W konkluzji autor podaje przydatna rada stworzenie systemu pomocy dla tworzonej aplikacji. Książka przeznaczona jest dla profesjonalnych programistów.

Książka jest poświęcona tworzeniu aplikacji napisanych w C++ w środowisku programistycznym KDevelop. Podano opis sposobów interakcji komponentów aplikacji. Omówiono pracę z narzędziem Qt Designer i opisano główne kontrolki używane w oknach dialogowych, a także klasy stworzone do pracy z nimi. Czytelnik zapoznaje się z koncepcją Dokument/Widok i uczy się tworzenia elementów interfejsu użytkownika aplikacji. Ponadto osobne rozdziały dotyczą zagadnień wyświetlania różnych informacji na ekranie, zapisywania i odtwarzania ich z pliku, tworzenia edytorów tekstu, pracy z szablonami klas i funkcji oraz organizowania wielozadaniowości w aplikacji w oparciu o współdziałające ze sobą procesy. Kończy się wytycznymi dotyczącymi tworzenia systemu pomocy aplikacji.

Treść:
Wstęp
Dla kogo jest ta książka?
struktura książki
Konwencje stosowane w tej książce
Wymagania sprzętowe i programowe
Rozdział 1 Interakcja komponentów aplikacji
Sygnały i odbiorniki
Wysyłanie sygnałów
Implementacja odbiornika
Implementacja połączenia
Obsługa zdarzeń
Praca z oknem
Praca z fokusem wejściowym
Obsługa myszy
Obsługa klawiatury
Przeciągnij i upuść implementację
Filtry zdarzeń
Zdarzenia syntetyczne
Sekwencja obsługi zdarzeń
Wniosek
Rozdział 2 Okna dialogowe i podstawowe elementy sterujące
kreacja aplikacja dialogowa
Utwórz kod pośredniczący aplikacji
Tworzenie ustawienia wstępnego okna dialogowego
Wypełnianie aplikacji dialogowej
Tworzenie niestandardowych okien dialogowych
Tworzenie okna dialogowego z kartami
Tworzenie kreatora
Rozdział 3 Klasy kontrolne
Lista klas
Klasy regulatorów liniowych i wskaźników liniowych
Praca z datą i godziną
Rozdział 4 Klasy aplikacji, dokumentów i widoków
Wielookienkowa aplikacja Qt
Klasa dokumentu
Zobacz zajęcia
Klasa aplikacji
Wielookienkowa aplikacja KDE
Klasa dokumentu
Zobacz zajęcia
Klasa aplikacji
Rozdział 5 Tworzenie elementów interfejsu użytkownika
Interfejs użytkownika Biblioteki Qt
Dokonywanie zmian w menu
Praca z paskiem stanu
Interfejs użytkownika aplikacji KDE
Dokonywanie zmian w menu
Dostosowanie paska narzędzi
Praca z paskiem stanu
Rozdział 6 Wyświetlanie informacji na ekranie
rysunek postaci
Praca z pędzlem
Przerysowanie okna
Synchronizacja obiektów widoku
Wyjście tekstowe
Praca z mapami bitowymi
Mapy bitowe zależne od algorytmu
Mapy bitowe niezależne od urządzenia
Rozdział 1 Praca z plikami dokumentów
Zapisywanie i przywracanie informacji w aplikacji
Dostosowywanie okien dialogowych
Dokonywanie zmian w menu
Ustawienie katalogu roboczego
Rozdział 8 Praca z dokumenty tekstowe
Budowanie prostego edytora tekstu
Tworzenie bardziej złożonego edytora
Tworzenie edytora KDE
Rozdział 9 Szablony kolekcji i klasy
Szablony
Koncepcja szablonu
Szablony funkcji
Szablony klas
Klasy kolekcji
Typy klas kolekcji
Tablice
Połączone listy
Wyświetl mapy
Inne klasy kolekcji
Rozdział 10 Implementacja wielozadaniowości w aplikacji
Interakcja procesu
Tworzenie klienta dla prostego serwera
Budowanie bardziej złożonego serwera
Utwórz klienta
Kilka uwag
Rozdział 11 Pomoc dotycząca aplikacji
Formularze prezentacji informacji referencyjnych
Jak uzyskać dostęp do systemu pomocy
Sposoby prezentacji informacji ogólnych
Formy prezentacji informacji
Programowanie pomocy kontekstowej
Wyjście podpowiedzi
Wyświetlanie informacji pomocy na pasku stanu
Uzyskiwanie informacji o konkretnym elemencie
interfejs użytkownika
Programowanie pomoc dowodzenia
Format pliku pomocy poleceń dla aplikacji Qt
Tworzenie aplikacji demonstracyjnej Qt
Dodatek 1 Zawartość płyty CD
Załącznik 2 Zasoby internetowe
Indeks tematyczny

Darmowe pobieranie e-book w wygodnym formacie obejrzyj i przeczytaj:
Pobierz książkę C++ Programming in Linux - Nikolay Sekunov - fileskachat.com, szybkie i bezpłatne pobieranie.

Ściągnij PDF
Poniżej możesz kupić tę książkę najlepsza cena ze zniżką z dostawą na terenie całej Rosji.

Stało się jasne, że temat jest bardzo aktualny. Wzięto pod uwagę pewne błędy i pytania, w wyniku czego zdecydowano o przeprowadzeniu drugiej klasy mistrzowskiej. Dodane i poprawione!

Programowanie w klasie mistrzowskiej w C pod Linuksem. Studiujemy główne API.

Ten samouczek jest przeznaczony dla osób, które chcą poznać interfejs API * nic jak OS, w szczególności pod Linuksem. Tutaj rozważymy funkcje programowania w systemie operacyjnym Linux, które obejmują:

Zapoznanie z procesem budowy oprogramowania oraz specyfiką kompilatora C firmy GCC

Tworzenie i korzystanie z bibliotek współdzielonych

Programy do debugowania

Eksplorowanie niskopoziomowych mechanizmów we/wy plików

Badanie mechanizmów zapewniających wielozadaniowość i komunikację międzyprocesową

Używanie gniazd plików i sieci

Badanie i zastosowanie mechanizmu sygnałów

Badanie procesów, wątków, ich różnic, wykorzystanie wielowątkowości, badanie mechanizmów synchronizacji wątków i ich problemów

Tworzenie demonów, poznanie różnicy między demonami a oprogramowaniem aplikacyjnym

Eksplorowanie funkcji wejścia/wyjścia konsoli

Pliki mapowane w pamięci i jak z nich korzystać

Ta klasa mistrzowska jest przeznaczona przede wszystkim dla programistów, inżynierów, programistów i po prostu amatorów, którzy są zainteresowani urządzeniem i specyfiką systemu operacyjnego Linux.

Wymagania dla uczestników kursu mistrzowskiego: Znajomość języka C na poziomie książkowym BV Kernighan, DM Ritchie „JĘZYK C”.

Koszt tej klasy mistrzowskiej wyniesie 6000 rubli.

Miejscem wydarzenia jest miasto Moskwa, na terenie Hackspace Neuron.
Daty: około 4 lipca (poniedziałek), do 7 lipca (czwartek) od 10:00 do 17:00 z przerwą na lunch i kawą/herbatą.

Transmisja online nie jest planowana.
Ilość osób w grupie: 8-10.

Nagrywanie jest włączone e-mail [e-mail chroniony] lub skomentuj ten post. Twoje pełne imię i nazwisko jest wymagane do rejestracji. (w całości) oraz dane kontaktowe (nr telefonu i e-mail). Pożądane jest opisanie celu uczęszczania na tę klasę mistrzowską, poziomu wyszkolenia i zawodu.

Szczegółowy program kursu:

Moduł 1: Wprowadzenie

Zapoznanie ze specyfiką budowy oprogramowania w systemie GNU/Linux

Wprowadzenie do konsoli edytory tekstu(vi, nano, mcedit)

Praca z debuggerem gdb

Ręczny i automatyczny montaż oprogramowania (Makefile)

Model klient-interfejs-serwer (CIS).

Statyczny budynek biblioteki

Biblioteki współdzielone

Praca ze zmiennymi środowiskowymi

Moduł 2: Niskopoziomowe operacje we/wy i operacje na plikach

Omówienie mechanizmów we/wy Linuksa (Ubuntu)

Deskryptory plików

Wywołania systemowe: open, close, write, read i lseek

Typy plików

I-węzły i twarde linki

Uprawnienia do plików

system plików proc

Dwa sposoby odczytywania zawartości katalogu

Pliki rzadkie i specyfika ich wykorzystania

Blokowanie obszarów pliku

Moduł 3

Mechanizmy komunikacji międzyprocesowej systemu Linux (Ubuntu)

Nienazwane rury (rury)

Nazwane rury

Wiadomości (kolejka wiadomości)

Pamięć współdzielona

Semafory

Moduł 4

Gniazda w przestrzeni nazw plików (gniazda UNIX)

Paruj gniazda

Gniazda sieciowe (gniazda)

Moduł 5. Sygnały

Wprowadzenie do sygnałów

Czym sygnały różnią się od innych mechanizmów komunikacji międzyprocesowej

Specyfika obsługi sygnału

Moduł 6

Klonowanie procesów - fork()

Zastępowanie wykonywanego procesu — exec()

Zombie (zombie) - przyczyny i sposoby ich eliminacji

Moduł 7

Wątki i procesy

Specyfika konstrukcji aplikacje wielowątkowe(wielowątkowość)

Wcześniejsze zakończenie wątku

Moduł 8 – Wątki (ciąg dalszy)

Utwórz program obsługi zakończenia wątku

Synchronizuj prymitywy

Atrybuty strumienia

Moduł 9: Demony (usługi)

Różnica między demonem a narzędziem konsoli

Specyfika rozwoju demonów

Tworzenie demona przy użyciu gniazd sieciowych

Moduł 10: We/wy konsoli

Specyfika tworzenia aplikacji konsolowych

Zapobieganie przekierowaniu danych wyjściowych

Zarządzanie terminalem

Ukrywanie hasła użytkownika podczas uwierzytelniania

Sterowanie terminalem z sekwencjami ESC

Moduł 11

Wyświetlanie normalnego pliku

Udostępnianie pliku

Prywatne wyświetlacze

Inne zastosowania mmap

Moduł 12

Specyfika tworzenia aplikacji 64-bitowych

Korzystanie z biblioteki ncurses