Facebook - konwersja
Pobierz fragment

C++17 STL. Receptury - ebook

Wydawnictwo:
Data wydania:
21 września 2018
Format ebooka:
PDF
Format PDF
czytaj
na laptopie
czytaj
na tablecie
Format e-booków, który możesz odczytywać na tablecie oraz laptopie. Pliki PDF są odczytywane również przez czytniki i smartfony, jednakze względu na komfort czytania i brak możliwości skalowania czcionki, czytanie plików PDF na tych urządzeniach może być męczące dla oczu. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
, EPUB
Format EPUB
czytaj
na czytniku
czytaj
na tablecie
czytaj
na smartfonie
Jeden z najpopularniejszych formatów e-booków na świecie. Niezwykle wygodny i przyjazny czytelnikom - w przeciwieństwie do formatu PDF umożliwia skalowanie czcionki, dzięki czemu możliwe jest dopasowanie jej wielkości do kroju i rozmiarów ekranu. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
, MOBI
Format MOBI
czytaj
na czytniku
czytaj
na tablecie
czytaj
na smartfonie
Jeden z najczęściej wybieranych formatów wśród czytelników e-booków. Możesz go odczytać na czytniku Kindle oraz na smartfonach i tabletach po zainstalowaniu specjalnej aplikacji. Więcej informacji znajdziesz w dziale Pomoc.
Multiformat
E-booki w Virtualo.pl dostępne są w opcji multiformatu. Oznacza to, że po dokonaniu zakupu, e-book pojawi się na Twoim koncie we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu.
(3w1)
Multiformat
E-booki sprzedawane w księgarni Virtualo.pl dostępne są w opcji multiformatu - kupujesz treść, nie format. Po dodaniu e-booka do koszyka i dokonaniu płatności, e-book pojawi się na Twoim koncie w Mojej Bibliotece we wszystkich formatach dostępnych aktualnie dla danego tytułu. Informacja o dostępności poszczególnych formatów znajduje się na karcie produktu przy okładce. Uwaga: audiobooki nie są objęte opcją multiformatu.
czytaj
na laptopie
Pliki PDF zabezpieczone watermarkiem możesz odczytać na dowolnym laptopie po zainstalowaniu czytnika dokumentów PDF. Najpowszechniejszym programem, który umożliwi odczytanie pliku PDF na laptopie, jest Adobe Reader. W zależności od potrzeb, możesz zainstalować również inny program - e-booki PDF pod względem sposobu odczytywania nie różnią niczym od powszechnie stosowanych dokumentów PDF, które odczytujemy każdego dnia.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na tablecie
Aby odczytywać e-booki na swoim tablecie musisz zainstalować specjalną aplikację. W zależności od formatu e-booka oraz systemu operacyjnego, który jest zainstalowany na Twoim urządzeniu może to być np. Bluefire dla EPUBa lub aplikacja Kindle dla formatu MOBI.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na czytniku
Czytanie na e-czytniku z ekranem e-ink jest bardzo wygodne i nie męczy wzroku. Pliki przystosowane do odczytywania na czytnikach to przede wszystkim EPUB (ten format możesz odczytać m.in. na czytnikach PocketBook) i MOBI (ten fromat możesz odczytać m.in. na czytnikach Kindle).
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
czytaj
na smartfonie
Aby odczytywać e-booki na swoim smartfonie musisz zainstalować specjalną aplikację. W zależności od formatu e-booka oraz systemu operacyjnego, który jest zainstalowany na Twoim urządzeniu może to być np. iBooks dla EPUBa lub aplikacja Kindle dla formatu MOBI.
Informacje na temat zabezpieczenia e-booka znajdziesz na karcie produktu w "Szczegółach na temat e-booka". Więcej informacji znajdziesz w dziale Pomoc.
Pobierz fragment
79,00

C++17 STL. Receptury - ebook

C++ pozwala zarówno na tworzenie interfejsów wysokiego poziomu, jak i na pisanie kodu działającego na niskim poziomie. Sprawdza się, gdy trzeba zapewnić wysoką wydajność i niskie obciążenie. Język ten jest konsekwentnie rozwijany: kolejne jego specyfikacje, C++14 i C++17, przyniosły wiele znakomitych udoskonaleń. Aby w pełni wykorzystać ten potencjał, należy korzystać z C++ łącznie z biblioteką STL. Jest to standardowa biblioteka języka, dzięki której C++ jest idealny do implementowania oprogramowania o wysokiej jakości i dużej wydajności. Zalety C++ sprawiają, że jest wykorzystywany niemal w każdej dziedzinie. Niestety, wielu programistów nie używa STL.

Dzięki tej książce poznasz użyteczność biblioteki standardowej (STL) w C++17 w praktyce, co pozwoli Ci na tworzenie efektywniejszego i w pełni przenośnego kodu źródłowego. Najpierw poznasz nowe funkcje języka, co pozwoli Ci na zrozumienie reguł rządzących C++, oraz funkcje biblioteki standardowej i sposób jej działania. Podczas pracy nad praktycznymi i łatwymi do wykorzystania recepturami poznasz podstawowe koncepcje STL, takie jak kontener, algorytm, klasa narzędziowa, wyrażenie lambda, iterator i wiele innych. Dowiesz się, jak działają najnowsze funkcje wprowadzone w standardzie C++17. Dzięki temu zaoszczędzisz czas i wysiłek podczas programowania, a Twój kod stanie się prostszy i zdecydowanie bardziej elegancki.

W książce między innymi:

  • Nowości w standardzie C++ 17
  • Kontenery STL i koncepcja iteratorów
  • Wyrażenia lambda i zaawansowane algorytmy biblioteki STL
  • Ciągi tekstowe, strumienie wejścia-wyjścia i wyrażenia regularne
  • Programowanie równoległe i współbieżność

C++17 i STL. Elegancka klasyka i potężne możliwości.

Spis treści

O autorze (13)

O redaktorze merytorycznym (14)

Wprowadzenie (15)

Rozdział 1. Nowe funkcje w C++17 (21)

  • Wprowadzenie (21)
  • Użycie strukturalnych wiązań do rozpakowania wartości zwrotnej (22)
    • Jak to zrobić? (22)
    • Jak to działa? (24)
    • Co dalej? (24)
  • Ograniczanie zasięgu zmiennej do konstrukcji if i switch (26)
    • Jak to zrobić? (26)
    • Jak to działa? (27)
    • Co dalej? (28)
  • Zalety stosowania nowych reguł inicjalizacji z użyciem składni opartej na nawiasach (29)
    • Jak to zrobić? (29)
    • Jak to działa? (30)
  • Umożliwienie konstruktorowi automatycznego określenia typu klasy szablonu (31)
    • Jak to zrobić? (31)
    • Jak to działa? (31)
    • Co dalej? (32)
  • Użycie wyrażenia constexpr-if do uproszczenia decyzji podejmowanych podczas kompilacji (33)
    • Jak to zrobić? (34)
    • Jak to działa? (35)
    • Co dalej? (36)
  • Włączenie bibliotek w postaci samych nagłówków z użyciem osadzonych zmiennych (37)
    • Jak to zrobić? (37)
    • Jak to działa? (38)
    • Co dalej? (39)
  • Implementowanie za pomocą wyrażeń fold przydatnych funkcji pomocniczych (40)
    • Jak to zrobić? (40)
    • Jak to działa? (41)
    • Co dalej? (41)

Rozdział 2. Kontenery STL (47)

  • Wprowadzenie (48)
    • Magazyn danych znajdujących się obok siebie (48)
    • Magazyn danych w postaci listy (49)
    • Drzewo wyszukiwania (49)
    • Tabela wartości hash (50)
    • Adapter kontenera (50)
  • Użycie stylu usuń - wymaż w kontenerze std::vector (50)
    • Jak to zrobić? (51)
    • Jak to działa? (52)
    • Co dalej? (54)
  • Usuwanie w czasie O(1) elementów z nieposortowanego kontenera std::vector (54)
    • Jak to zrobić? (55)
    • Jak to działa? (57)
  • Uzyskanie bezpiecznego dostępu do egzemplarzy std::vector (58)
    • Jak to zrobić? (58)
    • Jak to działa? (59)
    • Co dalej? (60)
  • Sortowanie egzemplarzy std::vector (60)
    • Jak to zrobić? (60)
    • Jak to działa? (62)
    • Co dalej? (62)
  • Efektywne i warunkowe wstawianie elementów do kontenera std::map (63)
    • Jak to zrobić? (63)
    • Jak to działa? (65)
    • Co dalej? (66)
  • Stosowanie nowej semantyki podpowiedzi podczas wstawiania elementów za pomocą std::map::insert (66)
    • Jak to zrobić? (66)
    • Jak to działa? (68)
    • Co dalej? (68)
  • Efektywne modyfikowanie kluczy elementów std::map (69)
    • Jak to zrobić? (70)
    • Jak to działa? (72)
    • Co dalej? (72)
  • Użycie kontenera std::unordered_map z niestandardowymi typami danych (73)
    • Jak to zrobić? (73)
    • Jak to działa? (75)
  • Filtrowanie duplikatów w danych wejściowych użytkownika iwyświetlanie ich w kolejności alfabetycznej za pomocą kontenerastd::set (76)
    • Jak to zrobić? (76)
    • Jak to działa? (77)
  • Implementowanie za pomocą kontenera std::stack prostego kalkulatora RPN (79)
    • Jak to zrobić? (80)
    • Jak to działa? (82)
    • Co dalej? (84)
  • Implementowanie za pomocą kontenera std::map licznika częstotliwości występowania słów (85)
    • Jak to zrobić? (85)
    • Jak to działa? (87)
  • Implementowanie za pomocą kontenera std::set narzędziapomocniczego przeznaczonego do wyszukiwania bardzo długich zdań wtekście (88)
    • Jak to zrobić? (89)
    • Jak to działa? (91)
    • Co dalej? (92)
  • Implementowanie za pomocą kontenera std::priority_queue listy rzeczy do zrobienia (93)
    • Jak to zrobić? (93)
    • Jak to działa? (95)

Rozdział 3. Iteratory (97)

  • Wprowadzenie (97)
    • Kategorie iteratorów (99)
  • Tworzenie własnego zakresu, który można iterować (101)
    • Jak to zrobić? (101)
    • Jak to działa? (103)
  • Tworzenie własnych iteratorów zgodnych z kategoriami iteratora STL (104)
    • Jak to zrobić? (104)
    • Jak to działa? (106)
    • Co dalej? (107)
  • Użycie adapterów iteratora do wypełniania ogólnych struktur danych (107)
    • Jak to zrobić? (107)
    • Jak to działa? (109)
  • Implementowanie algorytmów w kategoriach iteratorów (110)
    • Jak to zrobić? (111)
    • Co dalej? (113)
  • Iteracja w drugą stronę za pomocą adaptera iteratora odwrotnego (114)
    • Jak to zrobić? (114)
    • Jak to działa? (115)
  • Zakończenie działania iteratora w zakresie za pomocą wartownika iteratora (116)
    • Jak to zrobić? (117)
  • Automatyczne sprawdzanie kodu iteratora (119)
    • Jak to zrobić? (119)
    • Jak to działa? (122)
    • Co dalej? (123)
  • Tworzenie własnego adaptera iteratora łączenia na zakładkę (123)
    • Jak to zrobić? (125)
    • Co dalej? (128)

Rozdział 4. Wyrażenia lambda (131)

  • Wprowadzenie (131)
  • Definiowanie funkcji opartej na wyrażeniu lambda (133)
    • Jak to zrobić? (133)
    • Jak to działa? (136)
  • Dodawanie polimorfizmu poprzez opakowanie wyrażenia lambda egzemplarzem std::function (138)
    • Jak to zrobić? (138)
    • Jak to działa? (140)
  • Łączenie funkcji za pomocą konkatenacji (141)
    • Jak to zrobić? (142)
    • Jak to działa? (143)
  • Tworzenie skomplikowanych predykatów z logiczną koniunkcją (144)
    • Jak to zrobić? (145)
    • Co dalej? (146)
  • Wywoływanie wielu funkcji dla tych samych danych wejściowych (146)
    • Jak to zrobić? (147)
    • Jak to działa? (148)
  • Implementowanie funkcji transform_if() za pomocą algorytmu std::accumulate i wyrażeń lambda (150)
    • Jak to zrobić? (150)
    • Jak to działa? (152)
  • Generowanie w trakcie kompilacji iloczynu kartezjańskiego par dla dowolnych danych wejściowych (155)
    • Jak to zrobić? (156)
    • Jak to działa? (158)

Rozdział 5. Podstawy algorytmów biblioteki STL (161)

  • Wprowadzenie (161)
  • Kopiowanie elementów między kontenerami (163)
    • Jak to zrobić? (164)
    • Jak to działa? (166)
  • Sortowanie kontenera (167)
    • Jak to zrobić? (167)
    • Jak to działa? (170)
  • Usuwanie określonych elementów z kontenera (171)
    • Jak to zrobić? (171)
    • Jak to działa? (173)
  • Przekształcanie zawartości kontenera (174)
    • Jak to zrobić? (174)
    • Jak to działa? (176)
  • Wyszukiwanie elementów w uporządkowanych i nieuporządkowanych wektorach (176)
    • Jak to zrobić? (177)
    • Jak to działa? (180)
  • Ograniczanie za pomocą std::clamp wartości wektora do określonego zakresu liczbowego (182)
    • Jak to zrobić? (182)
    • Jak to działa? (185)
  • Wyszukiwanie za pomocą std::search wzorca w ciągu tekstowym i wybór optymalnej implementacji (186)
    • Jak to zrobić? (186)
    • Jak to działa? (188)
  • Próbkowanie ogromnego wektora (189)
    • Jak to zrobić? (190)
    • Jak to działa? (192)
  • Generowanie permutacji sekwencji danych wejściowych (193)
    • Jak to zrobić? (193)
    • Jak to działa? (194)
  • Implementowanie narzędzia łączenia słowników (195)
    • Jak to zrobić? (195)
    • Jak to działa? (197)

Rozdział 6. Zaawansowane przykłady użycia algorytmów biblioteki STL (199)

  • Wprowadzenie (200)
  • Implementowanie klasy drzewa trie za pomocą algorytmów STL (201)
    • Jak to zrobić? (201)
    • Jak to działa? (204)
  • Implementowanie za pomocą drzewa trie generatora sugestii danych wejściowych używanych podczas wyszukiwania (206)
    • Jak to zrobić? (206)
    • Jak to działa? (210)
    • Co dalej? (210)
  • Implementowanie wzoru przekształcenia Fouriera za pomocą algorytmów STL (211)
    • Jak to zrobić? (212)
    • Jak to działa? (217)
  • Obliczanie błędu sumy dwóch wektorów (218)
    • Jak to zrobić? (218)
    • Jak to działa? (220)
  • Implementowanie procedury generującej dane ASCII dla zbioru Mandelbrota (221)
    • Jak to zrobić? (223)
    • Jak to działa? (226)
  • Opracowanie własnego algorytmu - podział danych (227)
    • Jak to zrobić? (228)
    • Jak to działa? (229)
    • Co dalej? (230)
  • Połączenie użytecznych algorytmów biblioteki STL - zbieranie danych (231)
    • Jak to zrobić? (231)
    • Jak to działa? (233)
  • Usuwanie nadmiarowych białych znaków znajdujących się między słowami (235)
    • Jak to zrobić? (235)
    • Jak to działa? (237)
  • Kompresja i dekompresja ciągów tekstowych (238)
    • Jak to zrobić? (238)
    • Jak to działa? (240)
    • Co dalej? (241)

Rozdział 7. Ciągi tekstowe, klasy strumieni i wyrażenia regularne (243)

  • Wprowadzenie (244)
  • Tworzenie, konkatenacja i przekształcanie ciągów tekstowych (245)
    • Jak to zrobić? (246)
    • Jak to działa? (248)
  • Usuwanie białych znaków z początku i końca ciągu tekstowego (248)
    • Jak to zrobić? (249)
    • Jak to działa? (250)
  • Komfortowe użycie klasy std::string bez kosztów związanych z tworzeniem obiektów std::string (251)
    • Jak to zrobić? (252)
    • Jak to działa? (254)
  • Odczyt wartości z danych wejściowych dostarczonych przez użytkownika (254)
    • Jak to zrobić? (255)
    • Jak to działa? (257)
  • Zliczanie wszystkich słów w pliku (258)
    • Jak to zrobić? (258)
    • Jak to działa? (260)
  • Formatowanie danych wyjściowych za pomocą manipulatorów strumienia wejścia - wyjścia (260)
    • Jak to zrobić? (261)
    • Jak to działa? (264)
  • Inicjalizacja skomplikowanych obiektów na podstawie pliku źródłowego (266)
    • Jak to zrobić? (266)
    • Jak to działa? (268)
  • Wypełnianie kontenera za pomocą iteratorów std::istream (269)
    • Jak to zrobić? (269)
    • Jak to działa? (272)
  • Proste wyświetlanie danych za pomocą iteratorów std::ostream (273)
    • Jak to zrobić? (273)
    • Jak to działa? (276)
  • Przekierowywanie sekcji kodu do pliku danych wyjściowych (277)
    • Jak to zrobić? (278)
    • Jak to działa? (280)
  • Tworzenie własnych klas ciągu tekstowego za pomocą dziedziczenia po klasie std::char_traits (281)
    • Jak to zrobić? (282)
    • Jak to działa? (286)
  • Tokenizowanie danych wejściowych za pomocą biblioteki wyrażeń regularnych (287)
    • Jak to zrobić? (287)
    • Jak to działa? (289)
  • Wygodne formatowanie liczb w locie w zależności od kontekstu (291)
    • Jak to zrobić? (291)
  • Przechwytywanie na podstawie błędów std::iostream wyjątków możliwych do odczytania (293)
    • Jak to zrobić? (294)
    • Jak to działa? (296)

Rozdział 8. Klasy narzędziowe (297)

  • Wprowadzenie (298)
  • Konwertowanie między różnymi jednostkami czasu za pomocą std::ratio (298)
    • Jak to zrobić? (299)
    • Jak to działa? (301)
    • Co dalej? (303)
  • Konwertowanie między bezwzględnymi i względnymi wartościami czasu za pomocą std::chrono (304)
    • Jak to zrobić? (304)
    • Jak to działa? (306)
  • Bezpieczne sygnalizowanie awarii za pomocą typu std::optional (307)
    • Jak to zrobić? (307)
    • Jak to działa? (310)
  • Użycie funkcji wraz z krotkami (311)
    • Jak to zrobić? (311)
    • Jak to działa? (313)
  • Szybkie opracowywanie struktur danych za pomocą std::tuple (313)
    • Jak to zrobić? (314)
    • Jak to działa? (318)
  • Zastąpienie void* przez std::any dla zwiększenia bezpieczeństwa typu (320)
    • Jak to zrobić? (321)
    • Jak to działa? (323)
  • Przechowywanie różnych typów za pomocą std::variant (323)
    • Jak to zrobić? (324)
    • Jak to działa? (327)
  • Automatyczna obsługa zasobów za pomocą std::unique_ptr (329)
    • Jak to zrobić? (329)
    • Jak to działa? (332)
  • Automatyczna obsługa współdzielonej pamięci na stercie za pomocą std::shared_ptr (333)
    • Jak to zrobić? (333)
    • Jak to działa? (336)
    • Co dalej? (337)
  • Praca ze słabymi wskaźnikami do współdzielonych obiektów (338)
    • Jak to zrobić? (339)
    • Jak to działa? (341)
  • Uproszczenie obsługi zasobów przestarzałych API za pomocą sprytnych wskaźników (342)
    • Jak to zrobić? (343)
    • Jak to działa? (344)
  • Współdzielenie różnych wartości składowych tego samego obiektu (345)
    • Jak to zrobić? (346)
    • Jak to działa? (347)
  • Generowanie liczb losowych i wybór odpowiedniego silnika do generowania tego rodzaju liczb (348)
    • Jak to zrobić? (349)
    • Jak to działa? (353)
  • Generowanie liczb losowych i umożliwienie bibliotece STL określenia szczegółów rozkładu (354)
    • Jak to zrobić? (354)
    • Jak to działa? (359)

Rozdział 9. Programowanie równoległe i współbieżność (361)

  • Wprowadzenie (362)
  • Automatyczne stosowanie programowania równoległego w kodzie utworzonego za pomocą standardowych algorytmów (363)
    • Jak to zrobić? (363)
    • Jak to działa? (365)
  • Uśpienie programu na podany okres czasu (369)
    • Jak to zrobić? (369)
    • Jak to działa? (370)
  • Uruchamianie i zatrzymywanie wątków (371)
    • Jak to zrobić? (371)
    • Jak to działa? (373)
  • Przeprowadzanie bezpiecznego pod względem wyjątkównakładania blokady współdzielonej za pomocą std::unique_lock istd::shared_lock (375)
    • Jak to zrobić? (375)
    • Jak to działa? (378)
  • Zapobieganie zakleszczeniom dzięki stosowaniu algorytmu std::scoped_lock (381)
    • Jak to zrobić? (382)
    • Jak to działa? (384)
  • Synchronizacja jednoczesnego użycia algorytmu std::cout (384)
    • Jak to zrobić? (385)
    • Jak to działa? (386)
  • Bezpieczne odkładanie inicjalizacji za pomocą std::call_once (388)
    • Jak to zrobić? (389)
    • Jak to działa? (390)
  • Przesunięcie zadania do wykonywania w tle za pomocą std::async (390)
    • Jak to zrobić? (391)
    • Jak to działa? (393)
    • Co dalej? (395)
  • Implementacja wzorca producent - konsument za pomocą std::condition_variable (395)
    • Jak to zrobić? (396)
    • Jak to działa? (398)
  • Implementacja wzorca producent - konsument za pomocą std::condition_variable (400)
    • Jak to zrobić? (400)
    • Jak to działa? (404)
  • Równoległe generowanie za pomocą std::async danych ASCII dla zbioru Mandelbrota (406)
    • Jak to zrobić? (406)
    • Jak to działa? (409)
  • Implementacja za pomocą std::future niewielkiej biblioteki automatycznej programowania równoległego (410)
    • Jak to zrobić? (411)
    • Jak to działa? (415)

Rozdział 10. System plików (419)

  • Wprowadzenie (419)
  • Implementowanie programu przeprowadzającego normalizację ścieżki dostępu (420)
    • Jak to zrobić? (420)
    • Jak to działa? (422)
    • Co dalej? (422)
  • Pobieranie kanonicznej ścieżki dostępu na podstawie względnej ścieżki dostępu (423)
    • Jak to zrobić? (423)
    • Jak to działa? (426)
  • Wyświetlanie wszystkich plików znajdujących się w danym katalogu (426)
    • Jak to zrobić? (427)
    • Jak to zrobić? (430)
  • Implementowanie programu wyszukującego dane i działającego podobnie jak narzędzie grep (431)
    • Jak to zrobić? (431)
    • Jak to działa? (433)
    • Co dalej? (434)
  • Implementowanie programu automatycznie zmieniającego nazwy plików (434)
    • Jak to zrobić? (435)
  • Implementowanie programu obliczającego wielkość katalogu (437)
    • Jak to zrobić? (437)
    • Jak to działa? (439)
  • Obliczanie danych statystycznych dotyczących typów plików (440)
    • Jak to zrobić? (440)
  • Implementowanie narzędzia zmniejszającego wielkość katalogupoprzez zastąpienie powielonych plików dołączeniamisymbolicznymi (442)
    • Jak to zrobić? (443)
    • Jak to działa? (445)
    • Co dalej? (446)

Skorowidz (447)

Kategoria: Programowanie
Zabezpieczenie: Watermark
Watermark
Watermarkowanie polega na znakowaniu plików wewnątrz treści, dzięki czemu możliwe jest rozpoznanie unikatowej licencji transakcyjnej Użytkownika. E-książki zabezpieczone watermarkiem można odczytywać na wszystkich urządzeniach odtwarzających wybrany format (czytniki, tablety, smartfony). Nie ma również ograniczeń liczby licencji oraz istnieje możliwość swobodnego przenoszenia plików między urządzeniami. Pliki z watermarkiem są kompatybilne z popularnymi programami do odczytywania ebooków, jak np. Calibre oraz aplikacjami na urządzenia mobilne na takie platformy jak iOS oraz Android.
ISBN: 978-83-283-4502-7
Rozmiar pliku: 4,7 MB

BESTSELLERY

Kategorie: