Microsoft Visual Studio 2012 Programowanie 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ś.

Spis treści:

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)