Katalog książek

Wydawnictwo Helion

Helion SA
ul. Kościuszki 1c
44-100 Gliwice
tel. (32) 230-98-63




© Helion 1991-2014

Lauret zaufanych opinii
Microsoft Visual Studio 2012. Pr...

Microsoft Visual Studio 2012. Programowanie w C i C++

Autor: 

Microsoft Visual Studio 2012. Programowanie w C i C++
okładka przód okładka tył
Ocena:
   3.5/6  Opinie  (2)
Stron: 592
Ksiazka drukowana Druk (oprawa: miękka)
Cena:
89,00 zł

Dołącz do najlepszych, zacznij programować w C i C++!

  • Poznaj środowisko Microsoft Visual Studio 2012!
  • Odkryj uniwersalne narzędzia programistyczne!
  • Naucz się programować w językach C i C++!

Informatyka w obecnym kształcie nie mogłaby istnieć bez języków C i C++. Oba miały ogromne znaczenie dla powstania współczesnych systemów operacyjnych i oprogramowania użytkowego. Od systemu UNIX, poprzez Linuksa, aż po różne wersje systemu Windows — wszystkie środowiska w mniejszym lub większym stopniu zostały zbudowane za pomocą C lub C++. Prosta składnia tych języków, ich wysoka wydajność i ogromne możliwości zapewniły im wierną rzeszę profesjonalnych użytkowników, wielką popularność w instytucjach naukowych oraz liczne „potomstwo” w postaci języków programowania wykorzystujących mechanizmy i konstrukcje wprowadzone po raz pierwszy właśnie w C i C++.

Jeśli chcesz poznać podstawy programowania przy użyciu najpopularniejszego narzędzia do tworzenia aplikacji dla Windows, nie mogłeś lepiej trafić! Książka Microsoft Visual Studio 2012. Programowanie w C i C++ wprowadzi Cię w świat programowania proceduralnego w C i zorientowanego obiektowo w C++. Dowiesz się, jak zainstalować i wykorzystywać środowisko Visual Studio 2012, poznasz techniki stosowane przez programistów oraz nauczysz się samodzielnie budować programy. Uważna lektura pozwoli Ci opanować języki C i C++ w takim stopniu, aby dalsza nauka nie stanowiła najmniejszego problemu.

Przeczytaj i poznaj:

  • metody instalacji i konfiguracji środowiska Visual Studio 2012
  • sposoby kompilacji, budowania, poprawiania i uruchamiania programów
  • strukturę kodu programów i konstrukcje programistyczne w językach C i C++
  • instrukcje warunkowe, operatory i funkcje
  • operacje wejścia-wyjścia, strumienie oraz działania na zbiorach danych
  • podstawy programowania zorientowanego obiektowo
  • dziedziczenie i polimorfizm, szablony i iteratory oraz obsługę sytuacji wyjątkowych

Programowanie to nic trudnego, przekonaj się o tym jeszcze dziś!

Wstęp (11)

  • Język C (11)
  • Język C++ (12)
  • Zawartość książki (14)
  • Trochę teorii (15)
    • Kod maszynowy (15)
    • Asembler (16)
    • Interpreter (16)
    • Kompilator (17)
    • Kompilator JIT (18)
    • Problem jajka i kury (18)
CZĘŚĆ I. ŚRODOWISKO PRACY (19)

Rozdział 1. Środowisko programistyczne Microsoft Visual Studio Express 2012 (21)

  • Pobranie programu instalacyjnego (21)
  • Instalacja (24)
  • Pierwsze uruchomienie (26)
  • Instalacja pakietu polonizującego (28)
  • Uruchamianie (30)
  • Wybór języka interfejsu użytkownika (32)
  • Rejestracja (33)
  • Tworzenie nowego projektu (35)
  • Tworzenie zbiorów tekstu źródłowego programu (38)
  • Kompilacja rozwiązania (42)
  • Wybór wariantu kompilacji (44)
  • Usuwanie błędów kompilacji (45)
  • Zapisywanie zmian w tekście źródłowym (48)
  • Uruchamianie programu spoza środowiska (48)
  • Kończenie pracy (49)
CZĘŚĆ II. JĘZYK C (51)

Rozdział 2. Wprowadzanie, wyprowadzanie i przechowywanie danych (53)

  • Podprogram główny (53)
  • Umieszczanie tekstu na ekranie (55)
  • Komentarze (61)
  • Przechowywanie danych w pamięci (63)
    • Literały (63)
    • Deklaracja a definicja (63)
    • Definiowanie zmiennej (65)
    • Całkowite typy danych (65)
    • Znakowe typy danych (68)
    • Zmiennoprzecinkowe typy danych (69)
    • Nazywanie zmiennych (70)
    • Deklarowanie własnych typów danych (71)
  • Obliczenia (71)
    • Operacje algebraiczne (71)
    • Operacje bitowe (73)
    • Skracanie wyrażeń algebraicznych (74)
  • Wyprowadzanie danych (77)
  • Rzutowanie typów danych (81)
  • Zmienne tymczasowe (82)
  • Pobieranie informacji o zmiennych (83)
  • Pobieranie danych z klawiatury (86)
  • Śledzenie realizacji programu (90)
    • Krokowa realizacja programu (91)
    • Podgląd zawartości zmiennych (92)
    • Pułapki (94)
  • Podsumowanie (94)
Rozdział 3. Konstrukcje warunkowe i typy wyliczeniowe (97)

  • Zmienne i wyrażenia logiczne (98)
    • Wartości logiczne (98)
    • Zmienne logiczne (98)
    • Wyrażenia logiczne (99)
  • Instrukcja warunkowa (102)
  • Operator warunkowy (106)
  • Typy wyliczeniowe (109)
    • Definiowanie typu wyliczeniowego (109)
    • Wartości liczbowe wyliczeń (110)
    • Używanie zmiennych typów wyliczeniowych (111)
    • Konwersja typów wyliczeniowych i liczbowych (112)
  • Konstrukcja warunkowa (113)
  • Podsumowanie (120)
Rozdział 4. Struktury i unie (123)

  • Struktury (124)
    • Deklarowanie struktury (125)
    • Definiowanie zmiennej strukturalnej (126)
    • Korzystanie z pól struktury (127)
    • Zagnieżdżanie struktur (129)
    • Kopiowanie zmiennych strukturalnych (133)
  • Unie (134)
    • Deklarowanie unii (135)
    • Definiowanie unii (135)
    • Korzystanie z pól unii (135)
    • Unie anonimowe w strukturach (136)
  • Podsumowanie (138)
Rozdział 5. Pętle, tablice i zmienne łańcuchowe (141)

  • Pętle (142)
    • Pętla while (143)
    • Pętla do...while (146)
    • Pętla for (149)
    • Przerywanie pętli (151)
  • Tablice (154)
    • Definicja tablicy (154)
    • Zajętość pamięci tablicy (156)
    • Dostęp do elementów tablicy (157)
    • Tablice wielowymiarowe (158)
    • Zerowanie istniejącej tablicy (160)
  • Zmienne łańcuchowe (161)
    • Definiowanie zmiennej łańcuchowej (163)
    • Wypisywanie tekstu na ekranie (164)
    • Generowanie tekstu (166)
    • Przypisywanie i kopiowanie tekstu (167)
    • Scalanie napisów (171)
    • Wprowadzanie tekstu z klawiatury (172)
    • Pomiar długości tekstu (175)
    • Porównywanie napisów (177)
    • Wyszukiwanie fragmentów tekstu (179)
    • Podprogramy standardowe operujące na znakach (183)
  • Podsumowanie (184)
Rozdział 6. Programowanie proceduralne (187)

  • Techniki podziału na podprogramy (188)
  • Podprogramy bezparametrowe (189)
  • Zmienne globalne i lokalne (193)
    • Zmienne lokalne (194)
    • Zmienne globalne (195)
    • Statyczne zmienne lokalne (198)
  • Parametry podprogramów (199)
    • Parametry typów prostych (200)
    • Parametry tablicowe (201)
    • Parametry typów złożonych (203)
    • Parametry typu łańcuchowego (206)
  • Zwracanie wyniku działania podprogramu (207)
    • Zwracanie wyniku przez return (208)
    • Zwracanie wyników przez parametry (209)
  • Deklaracje podprogramów (211)
  • Podprogramy biblioteki standardowej (212)
    • stdlib.h (212)
    • math.h (213)
    • time.h (214)
    • conio.h (215)
  • Rekurencja (215)
    • Rekurencja jako odpowiednik pętli (216)
    • Algorytmy rekurencyjne (217)
    • Stos wywołań podprogramów (218)
  • Program przykładowy (220)
  • Podsumowanie (225)
Rozdział 7. Operacje wejścia-wyjścia (227)

  • Terminologia (228)
    • Zbiory danych (228)
    • Strumień danych (230)
    • Strumienie standardowe (231)
  • Wejście i wyjście standardowe (231)
    • Podprogramy wprowadzania i wyprowadzania danych (232)
    • Uruchamianie programów wsadowych (233)
    • Potoki (236)
    • Filtry (239)
  • Współpraca z systemem operacyjnym (241)
    • Wiersz polecenia (241)
    • Ustalanie treści wiersza polecenia (242)
    • Kod wyniku działania programu (243)
  • Zbiory (245)
    • Zmienna plikowa (245)
    • Otwieranie zbioru dyskowego (245)
    • Zamykanie zbioru dyskowego (247)
    • Zapisywanie danych tekstowych (248)
    • Odczytywanie danych tekstowych (249)
    • Stwierdzanie osiągnięcia końca zbioru (250)
    • Powtórne odczytanie zbioru (251)
    • Przykład odczytywania informacji ze zbioru tekstowego (252)
    • Binarny zapis informacji (254)
    • Zapisywanie danych binarnych (255)
    • Odczytywanie danych binarnych (257)
    • Zmienne łańcuchowe w zbiorach binarnych (258)
    • Pozycja w zbiorze binarnym (261)
    • Pobieranie rozmiaru zbioru (263)
    • Przykład korzystania ze zbioru binarnego (264)
    • Opróżnianie buforów zapisu (269)
  • Podsumowanie (270)
Rozdział 8. Dynamiczne gospodarowanie pamięcią operacyjną (273)

  • Informacje podstawowe (274)
    • Adresacja pamięci (274)
    • Typy bloków pamięci (276)
    • Terminologia (277)
  • Zmienne wskaźnikowe (278)
    • Definicja (278)
    • Pobranie adresu zmiennej (279)
    • Amorficzna zmienna wskaźnikowa (280)
    • Dereferencja (281)
    • Zmiana przyporządkowania (282)
    • Zmienne wskaźnikowe a tablice (283)
    • Zmienne wskaźnikowe a struktury i unie (284)
    • Zmienne wskaźnikowe a zmienne łańcuchowe (285)
    • Rozmiar wskaźnika (286)
  • Pamięć przydzielana dynamicznie (288)
    • Alokowanie bloku pamięci (289)
    • Zmiana rozmiaru bloku pamięci (292)
    • Zwalnianie bloku pamięci (295)
    • Dynamiczna alokacja pamięci na stosie (298)
  • Operacje na blokach pamięci (299)
    • Zapełnianie bloku pamięci (299)
    • Kopiowanie zawartości bloku pamięci (302)
    • Porównywanie zawartości bloków pamięci (307)
    • Wyszukiwanie bajtu (310)
  • Podsumowanie (311)
Rozdział 9. Programowanie wielomodułowe (313)

  • Jednostki kompilacji (314)
    • Dodawanie nowej jednostki kompilacji (314)
    • Zmiana nazwy zbioru (316)
    • Usuwanie jednostki kompilacji (317)
  • Podprogramy (317)
    • Deklaracje podprogramów (318)
    • W różnych jednostkach kompilacji (320)
  • Zmienne globalne (321)
  • Zbiory nagłówkowe (322)
  • Kompilacja warunkowa (323)
    • Warianty generowania kodu (323)
    • Kompilacja warunkowa (324)
    • Asercje (325)
  • Podsumowanie (327)
CZĘŚĆ III. JĘZYK C++ (329)

Rozdział 10. Składnia języka C++ (331)

  • Zbiory nagłówkowe (331)
  • Zmienne (332)
    • Definiowanie zmiennych (332)
    • Typy złożone (333)
    • Atrybut const (333)
    • Wartości stałe (334)
    • Referencje (335)
  • Podprogramy (338)
    • Parametry typu const (338)
    • Parametry przekazywane przez referencję (339)
    • Przeciążanie podprogramów (340)
    • Argumenty domyślne (342)
  • Rzutowanie typów danych (343)
  • Podsumowanie (345)
Rozdział 11. Przestrzenie nazw (347)

  • Tworzenie i rozszerzanie przestrzeni nazw (348)
  • Używanie przestrzeni nazw (349)
  • Wymuszanie użycia przestrzeni nazw (351)
    • Używanie wybranych symboli (351)
    • Używanie przestrzeni nazw (352)
    • Przemianowywanie przestrzeni nazw (352)
  • Anonimowe przestrzenie nazw (353)
  • Podsumowanie (354)
Rozdział 12. Programowanie obiektowe (355)

  • Struktury danych (355)
    • Deklaracja struktury (355)
    • Pola statyczne (356)
    • Konstruktor (357)
    • Destruktor (367)
    • Atrybuty dostępności (371)
    • Metody (373)
    • Wskaźnik this (381)
  • Hermetyzacja struktur danych (382)
  • Struktury, klasy, obiekty (387)
  • Podsumowanie (388)
Rozdział 13. Dziedziczenie i polimorfizm (391)

  • Dziedziczenie (392)
    • Klasa bazowa (392)
    • Klasa pochodna (393)
    • Hierarchia klas (394)
    • Dziedziczenie a zawieranie (394)
    • Konstruktory klas pochodnych (396)
    • Destruktory klas pochodnych (398)
    • Przykrywanie metod (399)
    • Dziedziczenie wielobazowe (401)
    • Przykład (407)
  • Polimorfizm w dziedziczeniu (411)
    • Kiedy dziedziczenie i przykrywanie metod nie wystarczają (411)
    • Metody wirtualne (413)
    • Konstruktory i destruktory (423)
  • Dynamiczna identyfikacja typów (424)
    • Mechanizm RTTI (424)
    • Rzutowanie dynamiczne (426)
    • Uwagi (428)
  • Podsumowanie (428)
Rozdział 14. Przeciążanie operatorów (431)

  • Operatory (432)
  • Przeciążanie operatorów symbolicznych (433)
    • Binarne operatory arytmetyczne (433)
    • Unarne operatory arytmetyczne (434)
    • Operatory porównania (436)
    • Operatory logiczne (437)
    • Operatory bitowe (438)
    • Operator przypisania (438)
    • Operatory zespolone (440)
    • Operator indeksowy (440)
    • Operatory adresowe (442)
    • Pozostałe operatory (442)
  • Operatory konwersji (443)
  • Podsumowanie (444)
Rozdział 15. Programowanie uogólnione (445)

  • Szablony podprogramów (446)
    • Zapisywanie szablonu (447)
    • Wyszczególnienie szablonu (448)
    • Specjalizowanie szablonu (450)
  • Szablony klas (451)
    • Szablony metod (452)
    • Zapisywanie szablonu (453)
    • Wyszczególnienie szablonu (454)
    • Szablony zależne od wartości liczbowych (455)
    • Argumenty domyślne szablonu (456)
    • Specjalizowanie szablonu (457)
  • Zaawansowane szablony (460)
    • Szablony cechujące (460)
    • Klasy określające reguły (461)
  • Podsumowanie (465)
Rozdział 16. Zmienne łańcuchowe i strumienie (467)

  • Zmienne łańcuchowe (468)
    • Obiektowe typy łańcuchowe (468)
    • Tworzenie zmiennej łańcuchowej (470)
    • Zmiana zawartości zmiennej łańcuchowej (470)
    • Pobieranie długości tekstu (471)
    • Pobieranie treści (471)
    • Porównywanie tekstu (472)
    • Dostęp do pojedynczych znaków (473)
    • Wyszukiwanie fragmentów tekstu (474)
    • Pobieranie wycinka tekstu (476)
  • Strumienie standardowe (476)
    • Podstawowe klasy strumieni (476)
    • Strumienie standardowe (477)
    • Operatory strumieniowe (478)
    • Wyprowadzanie informacji (478)
    • Formatowanie wyprowadzanych danych (479)
    • Wprowadzanie danych (480)
    • Wykrywanie końca danych wejściowych (482)
  • Strumienie zbiorów pamięci masowej (482)
    • Tryby otwarcia zbioru (483)
    • Otwieranie zbioru (484)
    • Zamykanie zbioru (485)
    • Serializacja i deserializacja danych (485)
    • Zbiory binarne (485)
  • Strumienie wirtualne (490)
    • Wirtualny strumień wejściowy (490)
    • Wirtualny strumień wyjściowy (491)
  • Podsumowanie (492)
Rozdział 17. Obsługa sytuacji wyjątkowych (495)

  • Sytuacje wyjątkowe (496)
    • Opis obiektowy (497)
    • Terminologia (498)
    • Wydajność (498)
    • Standardowe klasy sytuacji wyjątkowych (499)
  • Obsługa sytuacji wyjątkowych (501)
    • Blok chroniony (501)
    • Zgłaszanie sytuacji wyjątkowej (502)
    • Blok obsługi sytuacji wyjątkowych (504)
    • Zmienne w bloku chronionym (509)
  • Specyfikacje sytuacji wyjątkowych (509)
    • Specyfikacja sytuacji wyjątkowej (510)
    • Specyfikacja pusta (511)
    • Specyfikacja noexcept (512)
  • Podsumowanie (513)
Rozdział 18. Iteratory (515)

  • Teoria iteratorów (516)
    • Postać iteratora (516)
    • Rodzaje iteratorów (516)
    • Operacje wykonywane na iteratorze (518)
  • Iteratory standardowe (519)
    • Szablon std::iterator (520)
    • Zwyczajowe nazwy klas iteratorów (520)
    • Pobieranie iteratorów (521)
    • Przemieszczanie iteratora (522)
    • Pomiar odległości iteratorów (523)
  • Własne klasy iteratorów (524)
    • Przykładowa klasa kontenera (525)
    • Klasa iteratora (526)
    • Pola i ich inicjalizacja (526)
    • Przeciążenie operatorów (527)
    • Metody tworzące iteratory (530)
    • Całość klasy kontenera i iteratora (530)
    • Iterowanie kolekcji z wykorzystaniem iteratorów (531)
    • Przemieszczenie i odległość (532)
    • Program przykładowy (532)
  • Podsumowanie (534)
Rozdział 19. Biblioteka standardowa STL (537)

  • Pojęcia podstawowe (538)
    • Alokatory (538)
    • Pary (539)
  • Kontenery (540)
    • Podstawowe struktury przechowywania danych (540)
    • Podstawowe operacje (541)
    • Tablica dynamiczna (543)
    • Tablica segmentowa (548)
    • Lista (550)
  • Adaptery (553)
    • Stos (553)
    • Kolejka (555)
    • Tablica asocjacyjna (558)
    • Zbiory elementów (562)
  • Algorytmy (564)
    • Zamiana wartości (565)
    • Zliczanie elementów (565)
    • Określanie wartości skrajnych (565)
    • Porównywanie elementów (566)
    • Kopiowanie elementów (567)
    • Zapełnianie podzbioru elementów (568)
    • Porządkowanie elementów (568)
  • Podsumowanie (569)
Rozdział 20. Programowanie wielomodułowe (571)

  • Przestrzenie nazw (571)
  • Klasy (572)
  • Szablony (572)
  • Podsumowanie (573)
Dodatek. Tabela kodów znaków ASCII (575)

Skorowidz (581)

Najczęściej kupowane razem:
Microsoft Visual Studio 2012. Programowanie w C i C++ plus Java. Techniki zaawansowane. Wydanie IX plus Zwinne wytwarzanie oprogramowania. Najlepsze zasady, wzorce i praktyki
Cena zestawu: 277,95 zł 327,00 zł
Oszczędzasz: 49,05 zł (15%)
Dodaj do koszyka
zestaw0 Microsoft Visual Studio 2012. Programowanie w C i C++
Osoby, które kupowały książkę, często kupowały też:
Uczenie maszynowe dla programistów
Drew Conway, John Myles White
Cena: 49,00 zł
Spring w praktyce
Willie Wheeler, Joshua White
Cena: 89,00 zł
Spring. Receptury
Gary Mak, Daniel Rubio, Josh Long
Cena: 119,00 zł
Java. Podstawy. Wydanie IX
Cay S. Horstmann, Gary Cornell
Cena: 99,00 zł
6
(0)
5
(0)
4
(1)
3
(1)
2
(0)
1
(0)

Liczba ocen: 2

Średnia ocena
czytelników

  


okladka
  Ocena : 4 

Bardzo fajna książka polskiego autora. Szkoda, że tak mało polskich specjalistów podejmuje sie tej tematyki. Polecam
  Ocena : 3 

Po spisie treści widać, że to kolejne źródło płytkich wieści.