Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00061 005870 11250746 na godz. na dobę w sumie
Język C w pigułce - ebook/pdf
Język C w pigułce - ebook/pdf
Autor: , Liczba stron:
Wydawca: Promise Język publikacji: polski
ISBN: 978-83-7541-221-5 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie
Porównaj ceny (książka, ebook, audiobook).

Nowe wydanie tego klasycznego podręcznika zawiera jednoznaczne i szczegółowe wyjaśnienie każdej funkcjonalności języka C i biblioteki wykonawczej, włącznie z wielowątkowością, generycznymi makrami i funkcjami bibliotecznymi wprowadzonymi w w nowej wersji standardu C (C11). Każdy programista C, który potrzebuje poznać efekty mniej znanej funkcji lub zrozumieć, jak musi się ona zachowywać zgodnie ze standardem, znajdzie tu potrzebne informacje wraz z przykładami.
Idealna dla doświadczonych programistów C i C++, książka zawiera również omówienie popularnych narzędzi z kolekcji oprogramowania GNU. Czytelnik dowie się, jak budować programy przy użyciu GNU Make, kompilować pliki wykonywalne z kodu źródłowego oraz testować i debugować programy za pomocą debugerów GNU .
Trzy części tej autorytatywnej książki obejmują:
Koncepcje języka C i elementy składniowe, z odrębnymi rozdziałami poświęconymi typom, wyrażeń, wskaźników, zarządzania pamięcią, obsługi wejścia/wyjścia i innych.
Standardowa biblioteka C, obejmująca opis standardowych nagłówków i szczegółowe omówienie wszystkich funkcji bibliotecznych.
Podstawowe narzędzia programisty C ze zbioru oprogramowania GNU, wraz z instrukcjami ich użycia w Eclipse IDE.
„Język C w pigułce to wspaniałe narzędzie dla programistów C. W jednym miejscu znajdziemy omówienie najnowszych usprawnień dodanych w wersji 2011 standardu.”
— Peter Hessheimer
Project Manager,
KPIT Technologies
Peter Prinz prowadzi wykłady dla tysięcy programistów i projektantów oprogramowania dla systemów Unix i Windows. Jest również współautorem kilku książek o projektowaniu oprogramowania w językach C/C++.
Tony Crawford jest autorem i tłumaczem, zajmującym się programowaniem w C, lokalizacjami oprogramowania i administrowaniem sieciami.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

Język C w pigułce Peter Prinz, Tony Crawford przekład: Joanna Zatorska, Leszek Biolik APN Promise Warszawa 2016 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Język C w pigułce © 2016 APN PROMISE SA Authorized translation of English edition of C in a nutshell ISBN 978-1-491-90475-6 Copyright © 2016 Peter Prinz and Tony Crawford. All rights reserved. This translation is published and sold by permission of O’Reilly Media, Inc., which owns or controls of all rights to publish and sell the same. APN PROMISE SA, biuro: ul. Domaniewska 44a, 02-672 Warszawa tel. +48 22 35 51 600, fax +48 22 35 51 699 e-mail: mspress@promise.pl Wszystkie prawa zastrzeżone. Żadna część niniejszej książki nie może być powielana ani rozpowszechniana w jakiejkolwiek formie i w jakikolwiek sposób (elektroniczny, mechaniczny), włącznie z fotokopiowaniem, nagrywaniem na taśmy lub przy użyciu innych systemów bez pisemnej zgody wydawcy. Logo O’Reilly jest zarejestrowanym znakiem towarowym O’Reilly Media, Inc. Fluent Python, ilustracja z okładki i powiązane elementy są znakami towarowymi O’Reilly Media, Inc. Wszystkie inne nazwy handlowe i towarowe występujące w niniejszej publikacji mogą być znakami towarowymi zastrzeżonymi lub nazwami zastrzeżonymi odpowiednich firm odnośnych właścicieli. Przykłady firm, produktów, osób i wydarzeń opisane w niniejszej książce są fikcyjne i nie odnoszą się do żadnych konkretnych firm, produktów, osób i wydarzeń. Ewentualne podobieństwo do jakiejkolwiek rzeczywistej firmy, organizacji, produktu, nazwy domeny, adresu poczty elektronicznej, logo, osoby, miejsca lub zdarzenia jest przypadkowe i niezamierzone. APN PROMISE SA dołożyła wszelkich starań, aby zapewnić najwyższą jakość tej publikacji. Jednakże nikomu nie udziela się rękojmi ani gwarancji. APN PROMISE SA nie jest w żadnym wypadku odpowiedzialna za jakiekolwiek szkody będące następstwem korzystania z informacji zawartych w niniejszej publikacji, nawet jeśli APN PROMISE została powiadomiona o możliwości wystąpienia szkód. ISBN: 978-83-7541-161-4 Projekt okładki: Karen Montgomery Ilustracje: Rebecca Demarest Przekład: Joanna Zatorska, Leszek Biolik Redakcja: Marek Włodarz Korekta: Ewa Swędrowska Skład i łamanie: MAWart Marek Włodarz ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści Wstęp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .ix Część I: Język 1 Podstawy języka. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 Cechy języka C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .3 Struktura programów w języku C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .4 Pliki źródłowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .6 Komentarze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .7 Zbiory znaków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 Identyfikatory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .15 Jak działa kompilator C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .20 2 Typy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 Typologia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .25 Typy całkowite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .26 Typy zmiennopozycyjne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .33 Zespolone typy zmiennopozycyjne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .36 Typy wyliczeniowe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .37 Typ void . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .38 Wyrównanie obiektów w pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .40 3 Literały. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41 Stałe całkowite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .41 Stałe zmiennopozycyjne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .42 Stałe znakowe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .44 Literały łańcuchowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .48 4 Przekształcenia typów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 Przekształcenia typów arytmetycznych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .54 Przekształcenia typów niearytmetycznych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .62 Jawne przekształcenia wskaźników. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== iii 5 Wyrażenia i operatory. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 Jak są przetwarzane wyrażenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .72 Szczegóły dotyczące operatorów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .78 Wyrażenia stałe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104 6 Instrukcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .107 Instrukcje wyrażeniowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .107 Instrukcje blokowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .108 Pętle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .109 Instrukcje sterujące . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .114 Przeskoki bezwarunkowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .118 7 Funkcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123 Definicje funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .123 Deklaracje funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .131 Jak są wykonywane funkcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .133 Wskaźniki jako argumenty i zwracane wartości. . . . . . . . . . . . . . . . . . . . . . . . .133 Funkcje otwarte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .135 Funkcje, które niczego nie zwracają . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137 Funkcje rekurencyjne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .137 Zmienna liczba argumentów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .139 8 Tablice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .141 Definiowanie tablic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .141 Dostęp do elementów tablicy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .143 Inicjalizowanie tablic. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .144 Łańcuchy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .146 Tablice wielowymiarowe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .149 Tablice jako argumenty funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .151 9 Wskaźniki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .155 Deklarowanie wskaźników. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .155 Operacje ze wskaźnikami. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .159 Wskaźniki i kwalifikatory typu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .163 Wskaźniki do tablic i tablice wskaźników . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .167 Wskaźniki do funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .172 10 Struktury, unie i pola bitowe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .175 Struktury. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .175 Unie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .187 Anonimowe struktury i unie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .189 iv | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Pola bitowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .190 11 Deklaracje. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193 Deklaracje obiektów i funkcji . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .194 Nazwy typów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .202 Deklaracje typedef. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .203 Deklaracje _Static_assert . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .205 Łączność identyfikatorów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .206 Czas trwania obiektów w pamięci. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .208 Inicjalizacja. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .209 12 Dynamiczne zarządzanie pamięcią. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .211 Dynamiczne alokowanie pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .212 Cechy zaalokowanej pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .214 Zmiana ilości i zwalnianie pamięci. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .214 Drzewo binarne ogólnego przeznaczenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .216 13 Wejście i wyjście . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .229 Strumienie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .230 Pliki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .231 Otwieranie i zamykanie plików . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .234 Odczytywanie i zapisywanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .236 Bezpośredni dostęp do pliku . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .257 14 Wielowątkowość . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .261 Wątki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .262 Dostęp do danych współdzielonych . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .267 Komunikacja między wątkami: zmienne warunkowe . . . . . . . . . . . . . . . . . . . .275 Obiekty lokalne wątku i pamięć własna wątku . . . . . . . . . . . . . . . . . . . . . . . . . .280 15 Dyrektywy preprocesora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .285 Włączanie zawartości plików nagłówkowych . . . . . . . . . . . . . . . . . . . . . . . . . . .286 Definiowanie i używanie makr . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .288 Makra generyczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .296 Kompilacja warunkowa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .297 Definiowanie numerów wierszy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .299 Generowanie komunikatów błędu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300 Dyrektywa #pragma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .300 Operator _Pragma. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .301 Makra predefiniowane . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .302 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | v Część II: Biblioteka standardowa 16 Nagłówki standardowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .307 Wykorzystywanie nagłówków standardowych . . . . . . . . . . . . . . . . . . . . . . . . . .308 Funkcje ze sprawdzaniem zakresów . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .312 Zawartość nagłówków standardowych. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .313 17 Rzut oka na funkcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .347 Wejście i wyjście . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .347 Funkcje matematyczne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .349 Klasyfikacja i przekształcanie znaków . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .357 Przetwarzanie łańcuchów. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .359 Znaki wielobajtowe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .361 Przekształcenia między liczbami i łańcuchami . . . . . . . . . . . . . . . . . . . . . . . . . .362 Wyszukiwanie i sortowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .364 Obsługa bloku pamięci . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .364 Dynamiczne zarządzanie pamięcią. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365 Data i czas. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .365 Sterowanie procesem. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .367 Internacjonalizacja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .368 Nielokalne skoki . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .369 Wielowątkowość (C11). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .370 Debugowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .374 Komunikaty błędu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .375 18 Funkcje biblioteki standardowej . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .377 Część III: Podstawowe narzędzia 19 Kompilowanie z wykorzystaniem GCC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .745 GNU Compiler Collection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .745 Pobieranie i instalowanie GCC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .746 Kompilowanie programów C za pomocą GCC. . . . . . . . . . . . . . . . . . . . . . . . . .747 Dialekty C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .759 Optymalizacja . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .762 Debugowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .766 Profilowanie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .767 Podsumowanie opcji i zmiennych środowiskowych . . . . . . . . . . . . . . . . . . . . .767 vi | Spis treści ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 20 Wykorzystanie make do budowania programów C. . . . . . . . . . . . . . . . . . . . . . . . .773 Elementy docelowe, zależności i polecenia . . . . . . . . . . . . . . . . . . . . . . . . . . . . .774 Makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .774 Reguły . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .775 Komentarze . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .782 Zmienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .783 Cele pozorne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .791 Inne atrybuty elementu docelowego. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .793 Makra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .794 Funkcje . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .795 Dyrektywy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .800 Uruchamianie make . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .804 21 Debugowanie programów C za pomocą GDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . .813 Instalowanie GDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .814 Przykładowa sesja debugowania . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .814 Uruchamianie GDB. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .819 Korzystanie z poleceń GDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .825 Analiza stosu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .838 Analiza plików zrzutu pamięci w GDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .850 22 Tworzenie programów C za pomocą IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .853 Środowiska IDE dla C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .853 Eclipse dla C/C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .854 Tworzenie programu C za pomocą Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . .856 Debugowanie programu C w Eclipse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .860 Więcej informacji na temat środowiska Eclipse . . . . . . . . . . . . . . . . . . . . . . . . .863 Indeks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .865 O autorach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .885 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Spis treści | vii ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp Ta książka jest kompletnym źródłem informacji o języku programowania C i bibliotece czasu wykonania C. Z racji tego, że jest to zbiór informacji „w pigułce”, książka ta preten- duje do miana wygodnego i wiarygodnego towarzysza codziennej pracy programistów C. Opisuje wszystkie elementy języka i ilustruje ich użycie za pomocą wielu przykładów. Obecny opis języka C jest oparty na  międzynarodowym standardzie C ISO/IEC 9899:2011 z 2011 roku, znanym szerzej jako C11. Zastępuje on wcześniejszy standard C99, czyli ISO/IEC 9899:1999, oraz poprawki Technical Corrigenda, TC1 z 2001 roku, TC2 z 2004 roku i TC3 z 2007 roku. Pierwszy międzynarodowy standard C, czyli ISO/ IEC 9899:1990, został opublikowany w 1990 roku i uzupełniony dodatkiem Normative Addendum 1 (ISO/IEC 9899/AMD1:1995) z 1995 roku. Standard 1990 ISO/IEC odpo- wiada standardowi ANSI X3.159, który został ratyfi kowany pod koniec 1989 roku i jest popularnie nazywany ANSI C lub C89. Nowe funkcjonalności standardu C z 2011 roku nie są jeszcze w pełni wspierane przez wszystkie kompilatory i implementacje biblioteki standardowej. Dlatego, w tej książce, wszystkie nowości z roku 2011, takie jak wielowątkowość, makra generyczne i nowe funkcje biblioteki standardowej, oznaczyliśmy skrótem C11. Rozszerzenia wprowadzone w standardzie C99 zostały oznaczone skrótem C99. Ta książka nie jest wstępem do programowania w C. Chociaż opisuje podstawy ję- zyka, nie jest zorganizowana, ani napisana jak przewodnik. Czytelnicy, którzy dopiero rozpoczynają przygodę z C, powinni wcześniej przeczytać choć jedną z wielu dostępnych książek, opisujących podstawy języka, lub powinni znać jeden z pokrewnych języków, takich jak Java lub C++. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== ix Organizacja książki Tak książka jest podzielona na trzy części. Pierwsza część opisuje język C w ścisłym zna- czeniu; druga część zawiera omówienie biblioteki standardowej; natomiast trzecia część opisuje proces kompilacji i testowania programów za pomocą popularnych narzędzi z ko- lekcji oprogramowania GNU. Część I Część pierwsza, dotycząca języka C, zawiera rozdziały od 1. do 15. Rozdział 1. opisuje ogólne koncepcje oraz elementy języka, natomiast każdy kolejny jest poświęcony okre- ślonemu zagadnieniu, na przykład typom, instrukcjom lub wskaźnikom. Chociaż tematy są opisane w takiej kolejności, że podstawowe koncepcje każdego zagadnienia zostały przedstawione we wcześniejszym rozdziale – na przykład typy są opisane przed wyra- żeniami i operatorami, które z kolei poprzedzają opis instrukcji, itd. – czasem zrozu- mienie wszystkich szczegółów wymaga zapoznania się z zagadnieniami z późniejszych rozdziałów, zgodnie z odwołaniami umieszczonymi w tekście. Na przykład, w rozdziale 5. (opisującym wyrażenia i operatory) konieczne jest zrozumienie pewnych koncepcji dotyczących wskaźników i tablic, chociaż wskaźniki i tablice są szczegółowo opisane do- piero w rozdziałach 8. i 9. Rozdział 1, „Podstawy języka” Opisuje cechy języka oraz strukturę i kompilowanie programów C. Ten rozdział wprowadza podstawowe koncepcje, takie jak jednostka tłumaczenia, zestaw znaków i identyfi katory. Rozdział 2, „Typy” Zawiera omówienie typów w języku C oraz opisuje typy podstawowe, typ void i typy wyliczeniowe. Rozdział 3, „Literały” Opisuje stałe liczbowe, stałe znakowe oraz literały łańcuchowe, włącznie z sekwen- cjami specjalnymi. Rozdział 4, „Przekształcenia typów” Opisuje niejawne i jawne przekształcenia typów, włącznie z promocją całkowitą i zwykłymi przekształceniami arytmetycznymi. Rozdział 5, „Wyrażenia i operatory” Opisuje przetwarzanie wyrażeń, wszystkie operatory oraz ich operandy. Rozdział 6, „Instrukcje” Opisuje instrukcje C, takie jak bloki, pętle i skoki. x | Wstęp ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Rozdział 7, „Funkcje” Opisuje defi nicje funkcji i wywołania funkcji, włącznie z funkcjami rekurencyjnymi i otwartymi. Rozdział 8, „Tablice” Opisuje tablice o stałej i zmiennej długości, włącznie z łańcuchami, inicjalizacją tablic i tablicami wielowymiarowymi. Rozdział 9, „Wskaźniki” Opisuje defi nicje i wykorzystanie wskaźników do obiektów i funkcji. Rozdział 10, „Struktury, unie i pola bitowe” Opisuje organizację danych w typach zdefi niowanych przez użytkownika. Rozdział 11, „Deklaracje” Opisuje ogólną składnię deklaracji, łączność identyfi katorów i czas trwania obiektów. Rozdział 12, „Dynamiczne zarządzanie pamięcią” Opisuje funkcje biblioteki standardowej, służące do dynamicznego zarządzania pa- mięcią, ilustruje ich użycie w przykładowej implementacji drzewa binarnego ogó- lnego przeznaczenia. Rozdział 13, „Wejście i wyjście” Omawia koncepcję wejścia i wyjścia w języku C. Zawiera opis wykorzystania stan- dardowej biblioteki wejścia-wyjścia. Rozdział 14, „Wielowątkowość” Opisuje wykorzystanie wielowątkowości w standardzie C11. Znajdziemy tu opis użycia operacji niepodzielnych, komunikacji między wątkami i pamięci własnej wątku. Rozdział 15, „Dyrektywy preprocesora” Opisuje defi niowanie i wykorzystanie makr, kompilację warunkową i wszystkie po- zostałe dyrektywy i operatory preprocesora. Część II Część II, zawierająca rozdziały 16., 17. i 18., jest poświęcona standardowej bibliotece C. Zawiera przegląd nagłówków standardowych i zawiera także szczegółowy opis funkcji. Rozdział 16, „Nagłówki standardowe” Opisuje zawartość nagłówków i ich wykorzystanie. Nagłówki zawierają wszystkie defi nicje makr i typów biblioteki standardowej. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp | xi Rozdział 17, „Rzut oka na funkcje” Zawiera przegląd funkcji biblioteki standardowej, zorganizowany według obszarów zastosowań (np. funkcje matematyczne, funkcje przetwarzające daty i czas, itd.). Rozdział 18, „Funkcje biblioteki standardowej” Opisuje szczegółowo każdą funkcję w kolejności alfabetycznej i zawiera przykłady ilustrujące wykorzystanie każdej funkcji. Część III Trzecia część tej książki, obejmująca rozdziały od 19. do 22., dostarcza niezbędnej wiedzy na temat podstawowych narzędzi programisty C: kompilatora, narzędzia make i debugera. Opisane tu narzędzia należą do kolekcji oprogramowania GNU. Na końcu opisane zostało wykorzystanie tych narzędzi w zintegrowanym środowisku programistycznym (IDE) dla języka C. Jako przykład posłużyło środowisko Eclipse IDE. Rozdział 19, „Kompilowanie z wykorzystaniem GCC” Opisuje najważniejsze możliwości, oferowane przez popularne kompilatory C. Rozdział 20, „Wykorzystanie make do budowania programów C” Opisuje wykorzystanie programu make w celu automatyzacji procesu kompilacji dużych programów. Rozdział 21, „Debugowanie programów C za pomocą GDB” Opisuje uruchamianie programu pod kontrolą debugera GNU. Pokazuje, jak ana- lizować zachowanie programów w czasie wykonania w celu znalezienia błędów logicznych. Rozdział 22, „Tworzenie programów C za pomocą IDE” Opisuje wykorzystanie zintegrowanego środowiska programistycznego (IDE), które umożliwia ujednolicony, wygodny dostęp do wszystkich narzędzi służących do two- rzenia programów C. Dalsza lektura Oprócz źródeł wspomnianych w tekście książki, istnieje szereg zasobów, z których mogą skorzystać Czytelnicy, zainteresowani bardziej szczegółowymi zagadnieniami techniczny- mi. Międzynarodowa grupa robocza, zajmująca się standaryzacją C, ma ofi cjalną stronę internetową, dostępną pod adresem http://www.open-std.org/jtc1/sc22/wg14, która zawiera łącza do najnowszej wersji standardu C oraz do bieżących projektów prowadzonych przez grupę. xii | Wstęp ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Czytelnicy zainteresowani nie tylko tym co i jak osiągnąć w C, lecz także dlaczego sto- suje się określone mechanizmy, mogą zajrzeć na stronę WG14, zawierającą łącza do szki- ców i projektów. Te dokumenty opisują niektóre inspiracje i ograniczenia związane z pro- cesem standaryzacji. Ponadto, Czytelnicy zainteresowani głównie tym, jak C „wyewolu- ował do obecnej postaci”, zainteresują się zapewne artykułem twórcy języka C, Dennisa Ritchiego, zatytułowanym „Th e Development of the C Language” (https://www.bell-labs. com/usr/dmr/www/chist.html). Ten oraz inne dokumenty historyczne są nadal dostępne na stronie laboratorium Bell Labs https://www.bell-labs.com/usr/dmr/www/index.html. Czytelnicy, zainteresowani szczegółami działań matematycznych na liczbach zmien- nopozycyjnych, które wykraczają poza zakres C, być może zechcą się zapoznać z grun- townym wstępem autorstwa Davida Goldberga „What Every Computer Scientist Should Know About Floating-Point Arithmetic”, dostępnym pod adresem http://docs.sun.com/ source/806-3568/ncg_goldberg.html. Konwencje wykorzystywane w tej książce W tej książce wykorzystywane są następujące konwencje typografi czne: Kursywa Stosowana do wyróżnienia nowej terminologii, nazw plików, rozszerzeń plików, adresów URL, katalogów i narzędzi uniksowych. Czcionka o stałej szerokości Stosowana do oznaczenia wszystkich elementów kodu źródłowego C: słów klu- czowych, operatorów, zmiennych, funkcji, makr, typów, parametrów i literałów. Stosowana również do oznaczenia poleceń konsoli, opcji oraz wyniku działania tych poleceń. Pogrubiona czcionka o stałej szerokości Służy do oznaczenia w przykładowym kodzie omawianych funkcji lub instrukcji. W sesjach kompilatora, programu make i debugera ta czcionka służy do zaznaczenia poleceń, które muszą być wpisane przez użytkownika. Czcionka o stałej szerokości z kursywą Służy do zaznaczenia parametrów w prototypach funkcji lub wartości zastępczych, które muszą być zastąpione wartościami użytkownika. Zwykły tekst Służy do zapisu klawiszy, takich jak Return, Tab i Ctrl. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp | xiii W ten sposób oznaczana jest wskazówka lub sugestia. W ten sposób oznaczana jest ogólna uwaga. W ten sposób oznaczane jest ostrzeżenie. Korzystanie z przykładowego kodu Materiały dodatkowe (przykładowy kod, ćwiczenia, itd.) są dostępne pod adresem https:// github.com/oreillymedia/c-in-a-nutshell-2E. Celem tej książki jest pomoc programiście w wykonaniu pracy. Ogólnie rzecz biorąc, Czytelnicy mogą wykorzystać kod znajdujący się w tej książce w swoich programach i dokumentacji. Nie ma konieczności kontaktowania się z nami w celu uzyskania zezwo- lenia, chyba że Czytelnik ma zamiar powielić znaczną część kodu. Na przykład, pisanie programu wykorzystującego kilka fragmentów kodu z tej książki nie wymaga zezwolenia. Sprzedaż lub dystrybucja przykładów z książek wydawnictwa O’Reilly na płytach CD wy- maga zezwolenia. Odpowiedź na pytanie, wykorzystująca cytaty z książki wraz z przykła- dowym kodem, nie wymaga zezwolenia. Włączenie znacznej ilości przykładowego kodu z tej książki do dokumentacji własnego produktu wymaga zezwolenia. Doceniamy, lecz nie wymagamy odnośników wskazujących źródło. Odnośnik taki powinien zawierać tytuł, autorów, wydawcę i numer ISBN oryginalnego, anglojęzycznego wydania książki. Może to na przykład wyglądać tak: „C w pigułce, autorstwa Petera Prinza i Tony’ego Crawforda, wydana przez O’Reilly Media, Inc., 978-1-491-90475-6 ”. Jeśli Czytelnik uważa, że wykorzystanie przez niego przykładowego kodu wykra- cza poza opisane tu przypadki dopuszczalnego użycia, prosimy o kontakt pod adresem permissions@oreilly.com. xiv | Wstęp ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Kontakt Komentarze i pytania dotyczące tej książki należy kierować do wydawnictwa: O’Reilly Media, Inc. 1005 Gravenstein Highway North Sebastopol, CA 95472 800-998-9938 (numer dla Stanów Zjednoczonych lub Kanady) 707-829-0515 (numer międzynarodowy lub lokalny) 707-829-0104 (faks) Przygotowaliśmy stronę internetową przeznaczoną dla tej książki. Można na niej znaleźć erratę, przykłady i inne dodatkowe informaje. Strona ta jest dostępna pod adresem http:// bit.ly/C_Nutshell_2e. Aby skomentować lub zadać techniczne pytanie dotyczące tej książki, należy wysłać wiadomość e-mail na adres bookquestions@oreilly.com. Więcej informacji na temat naszych książek, kursów, konferencji i aktualności można znaleźć na naszej stronie, dostępnej pod adresem http://www.oreilly.com. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Wstęp | xv Podziękowania Chcielibyśmy obaj podziękować wszystkim pracownikom wydawnictwa O’Reilly za ich wspaniałą pracę nad naszą książką, a  w  szczególności naszym redaktorom Rachel Roumeliotis i Katie Schooling za ich pomoc w trakcie pracy. Dziękujemy też naszym re- cenzentom technicznym, Mattowi Crawfordowi, Davidowi Kitabjianowi, Chrisowi LaPre, Johnowi C. Craigowi i Loï cowi Peff erkornowi za ich cenne uwagi krytyczne na temat rękopisu. Jesteśmy wdzięczni naszej redaktor technicznej, Kristen Brown oraz naszemu adiustatorowi Gillianowi McGarvey’emu, za ich zaangażowanie w ostateczny, dobry wy- gląd naszej książki. Na koniec pragniemy podziękować Jonathanowi Gennickowi za to, że wiele lat temu zapoczątkował ten projekt. Peter Chciałbym najpierw podziękować Tony’emu za wspaniałą współpracę. Serdecznie dzię- kuję także wszystkim moim przyjaciołom, za zrozumienie, jakie mi ciągle okazywali, gdy miałem dla nich tak mało czasu. Wreszcie, chciałem dodać, że dedykuję tę książkę moim córkom, Vivian i Jeanette – obydwie są obecnie na informatycznych studiach doktoran- ckich – które wspierały moje ambicje dotyczące tego projektu. Tony Dziękuję Peterowi za przestrzeń, którą mi udostępnił w tym projekcie, a którą mogłem zapełnić. xvi | Wstęp ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== I Język ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 1 Podstawy języka Ten rozdział przedstawia podstawowe cechy i elementy języka programowania C. Cechy języka C C jest proceduralnym językiem programowania ogólnego stosowania. Język C został opra- cowany w latach 70-tych ubiegłego wieku przez Dennisa Ritchie’go w instytucie AT T Bell Laboratories w Murray Hill, w stanie New Jersey. Język ten miał umożliwić implementację systemu operacyjnego Unix na dowolnych platformach sprzętowych. Język C nadaje się do tego szczególnie dobrze ze względu na swoje główne cechy: • Przenośność kodu źródłowego • Możliwość operowania „blisko maszyny” • Wydajność Te cechy pozwoliły programistom systemu Unix napisanie większej części systemu w ję- zyku C. Jedynie minimalna ilość kodu obsługi sprzętu specyfi czna dla systemu musiała powstać w asemblerze. Przodkiem języka C był beztypowy język BCPL (Basic Combined Programming Language), opracowany przez Martina Richardsa, oraz język B, opracowany przez Kena Th ompsona, spadkobierca języka BCPL. Nową cechą języka C jest różnorodność do- stępnych typów danych: znakowych, liczbowych, tablic, struktur i innych. W 1978 roku Brian Kernighan i Dennis Ritchie opublikowali ofi cjalny opis języka programowania C. Ich opis, będący de facto pierwszym standardem języka, jest określany po prostu jako ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== 3 „K R”1. Wysoka przenośność języka C wynika ze zwięzłości podstawowego języka, który jest zależny od sprzętu tylko w niewielu aspektach. Język C nie obsługuje na przykład dostępu do plików, czy też dynamicznego zarządzania pamięcią. Nie istnieją też żadne instrukcje odczytu i wypisywania danych w konsoli. Funkcje służące do wykonania tych zadań zostały zaimplementowane w obszernej bibliotece standardowej języka C. Taka konstrukcja języka sprawia, że kompilator C jest względnie zwarty i łatwy do prze- niesienia na nowe systemy. Ponadto po zainstalowaniu kompilatora w nowym systemie, większość funkcji z biblioteki standardowej nie wymaga żadnych modyfi kacji, ponieważ zostały one napisane z wykorzystaniem przenośnego języka C. Dzięki temu kompilatory C są dostępne praktycznie dla każdego system operacyjnego. Ponieważ język C został zaprojektowany specjalnie na potrzeby programowania sy- stemu, nie należy się dziwić, że obecnie jest stosowany przeważnie w programowaniu systemów wbudowanych. Jednakże wielu programistów wykorzystuje język C jako prze- nośny, strukturalny język wysokiego poziomu do pisania takich programów, jak wydajne procesory tekstu, aplikacje bazodanowe czy grafi czne. Struktura programów w języku C Proceduralnymi blokami tworzącymi program C są funkcje, które mogą wywoływać kolejne funkcje. W dobrze zaprojektowanym programie każda funkcja ma swoje prze- znaczenie. Funkcje zawierają instrukcje, które są po kolei wykonywane przez program. Ponadto instrukcje mogą być także pogrupowane w instrukcje blokowe, zwane inaczej blokami. Programista ma również do dyspozycji gotowe funkcje z biblioteki standardowej. Może także pisać własne funkcje, jeśli żadna ze standardowych funkcji nie spełnia jego potrzeb. Oprócz biblioteki standardowej dostępne są także różnorodne wyspecjalizowane biblioteki, na przykład biblioteki zawierające funkcje grafi czne. Jednakże używanie takich niestandardowych bibliotek wiąże się z ograniczeniem przenośności programu do tych systemów, do których biblioteki te zostały przystosowane. W każdym programie C musi się znaleźć co najmniej jedna funkcja o specjalnej na- zwie main(). Jest to pierwsza funkcja wykonywana podczas uruchamiania programu. main() stanowi najwyższy poziom kontroli programu i może wywoływać inne funkcje jako podprogramy. Struktura prostego, kompletnego programu C jest przedstawiona w przykładzie 1-1. W dalszej części książki omówimy szczegółowo deklarowanie i wywoływanie funkcji, strumienie wejścia/wyjścia i wiele więcej. W tej części książki chcemy jedynie przedsta- wić ogólną strukturę kodu źródłowego C. W programie przedstawionym w przykładzie 1-1 zdefi niowane są dwie funkcje – main() i circularArea(). Funkcja main() wywołuje 1 Drugie wydanie, odzwierciedlające standard ANSI C, zostało wydane w Polsce pod tytułem Język ANSI C, Brian W. Kernighan i Dennis M. Ritchie, Wydawnictwa Naukowo-Techniczne, Warszawa 1994 (przyp. tłum.). 4 | Rozdział 1: Podstawy języka ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== funkcję circularArea(), aby uzyskać pole powierzchni koła o podanym promieniu. Następnie wywołuje funkcję printf() z biblioteki standardowej, aby wypisać sformato- wany wynik w konsoli. Przykład 1-1 Prosty program C // circle.c: Obliczanie i wyświetlanie pola powierzchni kół P o d s t a w y j ę z y k a #include stdio.h // Dyrektywa preprocesora double circularArea( double r ); // Deklaracja funkcji (forma prototypowa) int main() // Początek definicji main() { double radius = 1.0, area = 0.0; printf( Pola powierzchni kół\n\n ); printf( Promień Pole\n -------------------------\n ); area = circularArea( radius ); printf( 10.1f 10.2f\n , radius, area ); radius = 5.0; area = circularArea( radius ); printf( 10.1f 10.2f\n , radius, area ); return 0; } // Funkcja circularArea() oblicza pole powierzchni koła // Parametr: Promień koła // Zwracana wartość: Pole koła double circularArea( double r ) // Początek definicji circularArea() { const double pi = 3.1415926536; // Pi jest stałą return pi * r * r; } Wynik: Pola powierzchni kół Promień Pole ------------------------- 1.0 3.14 5.0 78.54 Zauważmy, że kompilator wymaga wcześniejszej deklaracji każdej wywoływanej funkcji. Prototyp funkcji circularArea() w trzecim wierszu przykładu 1-1 zawiera informacje Struktura programów w języku C | 5 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== niezbędne do skompilowania instrukcji, służącej do wywołania tej funkcji. Prototypy funkcji biblioteki standardowej znajdują się w standardowych plikach nagłówkowych. Ponieważ prototyp funkcji printf() znajduje się w pliku nagłówkowym stdio.h, dyrek- tywa preprocesora #include stdio.h deklaruje funkcję pośrednio, nakazując prepro- cesorowi kompilatora dołączenie zawartości tego pliku (patrz również podrozdział „Jak działa kompilator C” na końcu tego rozdziału). Funkcje zdefi niowane w programie można dowolnie uporządkować. W przykładzie 1-1 moglibyśmy równie dobrze umieścić funkcję circularArea() przed funkcją main(). W takim przypadku deklaracja prototypu circularArea() byłaby zbędna, ponieważ de- fi nicja funkcji jest zarazem jej deklaracją. Nie można zagnieżdżać defi nicji funkcji wewnątrz innej funkcji. Wewnątrz bloku funkcji można zdefi niować zmienną lokalną, lecz nie można zdefi niować funkcji lokalnej. Pliki źródłowe Na kod źródłowy programu C składają się defi nicje funkcji, deklaracje globalne i dyrekty- wy preprocesora. W przypadku małych programów kod źródłowy znajduje się w jednym pliku źródłowym. Większe programy C składają się z kilku plików źródłowych. Ponieważ defi nicje funkcji zazwyczaj zależą od dyrektyw preprocesora i deklaracji globalnych, we- wnętrzna struktura plików źródłowych jest zwykle następująca: 1. Dyrektywy preprocesora 2. Deklaracje globalne 3. Defi nicje funkcji Język C wspiera programowanie modułowe, pozwalając na uporządkowanie programu w postaci dowolnej liczby plików nagłówkowych oraz na ich osobną edycję i kompilację. Każdy plik źródłowy zawiera logicznie powiązane funkcje, na przykład funkcje dotyczące interfejsu użytkownika programu. Pliki źródłowe programu C zwykle mają rozszerzenie .c. Przykłady 1-2 i 1-3 przedstawiają ten sam program, który znamy z przykładu 1-1, lecz podzielony na dwa pliki źródłowe. Przykład 1-2 Pierwszy plik źródłowy, zawierający funkcję main() // circle.c: Wyświetla pola powierzchni kół. // Do obliczeń wykorzystuje plik circulararea.c #include stdio.h double circularArea( double r ); int main() { 6 | Rozdział 1: Podstawy języka ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== /* ... Jak w przykładzie 1-1... */ } Przykład 1-3 Drugi plik źródłowy, zawierający funkcję circularArea() // circulararea.c: Oblicza pola powierzchni kół. // Wywoływany przez funkcję main() w pliku circle.c double circularArea( double r ) { /* ... Jak w przykładzie 1-1... */ } P o d s t a w y j ę z y k a Jeśli program składa się z kilku plików źródłowych, wówczas w wielu z tych plików nale- ży zadeklarować te same funkcje i zmienne globalne, zdefi niować te same makra i stałe. Te deklaracje i defi nicje tworzą swego rodzaju nagłówek pliku, który jest mniej więcej jednakowy dla całego programu. Dla uproszczenia i zachowania spójności, można zapisać te informacje tylko raz, w osobnym pliku nagłówkowym, a następnie odwołać się do pli- ku nagłówkowego korzystając z dyrektywy #include w każdym pliku źródłowym. Pliki nagłówkowe są zwykle identyfi kowane przez przyrostek .h. Plik nagłówkowy dołączony do źródłowego pliku C może także dołączać inne pliki. Każdy plik źródłowy C, wraz ze wszystkimi dołączonymi do niego plikami źródłowymi tworzy jednostkę tłumaczenia. Kompilator przetwarza po kolei jednostki tłumaczenia, tłu- macząc kod źródłowy na tokeny, czyli najmniejsze jednostki leksykalne, takie jak nazwy zmiennych i operatory. Więcej informacji na ten temat można znaleźć w punkcie „Tokeny” pod koniec tego rozdziału. Między kolejnymi tokenami może się znajdować dowolna liczba białych znaków, dzięki czemu mamy ogromną dowolność w formatowaniu kodu źródłowego. Nie istnieją żadne reguły dotyczące łamania wierszy, czy wcięć. Korzystając ze spacji, tabulacji i pustych wierszy możemy sformatować kod źródłowy w sposób przyjazny dla człowieka. Taka do- wolność nie obejmuje dyrektyw preprocesora. Dyrektywa preprocesora musi się zawsze znajdować w osobnym wierszu, zaś przed znakiem kratki (#) rozpoczynającym wiersz mogą się znaleźć tylko znaki spacji lub tabulacji. Istnieje wiele różnych konwencji i „fi rmowych stylów” formatowania kodu źródłowe- go. Większość z nich opiera się na następujących regułach: • Każda nowa deklaracja i instrukcja powinna się znaleźć w nowym wierszu. • Wcięcia pozwalają odzwierciedlić zagnieżdżoną strukturę instrukcji blokowych. Komentarze Kod źródłowy należy obfi cie komentować, aby zapewnić dokumentację programów. W języku C do dyspozycji mamy dwa sposoby umieszczania komentarzy. Pierwszy ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Komentarze | 7 to komentarze blokowe, zaczynające się znakami /* i kończące znakami */, zaś drugi to komentarze wierszowe, zaczynające się znakami // i kończące znakiem nowego wiersza. Ograniczniki /* i */ można stosować na początku i końcu komentarzy jednowierszo- wych oraz do oznaczenia komentarzy rozciągających się na kilka wierszy. Na przykład w następującym prototypie funkcji wielokropek (...) oznacza, że funkcja open() przyj- muje trzeci opcjonalny parametr. Użycie opcjonalnego parametru objaśnia komentarz: int open( const char *name, int mode, ... /* int permissions */ ); Znaków // można użyć do utworzenia komentarzy rozciągających się na cały wiersz lub do utworzenia dwukolumnowego kodu źródłowego, z kodem programu w lewej kolumnie i komentarzami w prawej: const double pi = 3.1415926536; // Pi jest stałą Komentarze liniowe zostały ofi cjalnie dodane do języka C przez standard C99, lecz więk- szość kompilatorów wspierało je jeszcze przed pojawieniem się standardu C99. Są one niekiedy nazywane komentarzami w „stylu C++”, choć w rzeczywistości wywodzą się od poprzednika C, czyli języka BCPL. Znaki /* i // znajdujące się wewnątrz cudzysłowów ograniczających stałą znakową lub literał łańcuchowy nie rozpoczynają komentarza. Na przykład następująca instrukcja nie zawiera komentarzy: printf( Komentarze w C rozpoczynają się od /* lub //.\n ); Jedynymi poszukiwanymi przez preprocesor znakami wewnątrz komentarza są znaki jego końca, dlatego zagnieżdżanie komentarzy jest niemożliwe. Jednak można skorzy- stać ze znaków /* i */, aby zakomentować fragment programu zawierający komentarze wierszowe: /* Tymczasowe usunięcie dwóch wierszy: const double pi = 3.1415926536; // Pi jest stałą area = pi * r * r // Obliczanie pola powierzchni Tymczasowe usunięcie do tego miejsca */ Jeśli chcemy zakomentować fragment programu zawierający komentarze blokowe, może- my skorzystać z warunkowej dyrektywy preprocesora (opisanej w rozdziale 14.): #if 0 const double pi = 3.1415926536; /* Pi jest stałą */ area = pi * r * r /* Obliczanie pola powierzchni */ #endif Preprocesor zastąpi każdy komentarz spacją. Sekwencja znaków min/*max*/Value przyj- mie więc postać dwóch tokenów min Value. 8 | Rozdział 1: Podstawy języka ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== P o d s t a w y j ę z y k a Zbiory znaków Język C odróżnia środowisko, w którym kompilator tłumaczy pliki źródłowe programu (środowisko tłumaczeniowe) od środowiska, w którym skompilowany program jest uru- chamiany, czyli środowiska wykonania. Odpowiednio, C defi niuje dwa zbiory znaków: źródłowy zbiór znaków zawierający znaki, z których można korzystać w kodzie źródłowym C, oraz zbiór znaków wykonania programu, który zawiera znaki interpretowalne przez uruchomiony program. W wielu implementacjach C te dwa zbiory znaków są identycz- ne. Jeśli się różnią, wówczas kompilator przekształca znaki ze stałych znakowych oraz literałów łańcuchowych w kodzie źródłowym w odpowiednie elementy zbioru znaków wykonania programu. Każdy z tych zbiorów znaków zawiera podstawowy zbiór znaków oraz znaki dodatkowe. Język C nie określa znaków dodatkowych, które zwykle zależą od lokalnego języka. Znaki dodatkowe wraz z podstawowym zbiorem znaków tworzą powiększony zbiór znaków. Podstawowe zbiory źródłowe i wykonania programu zawierają następujące rodzaje znaków: Litery alfabetu łacińskiego: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z a b c d e f g h i j k l m n o p q r s t u v w x y z Cyfry dziesiętne 0 1 2 3 4 5 6 7 8 9 29 następujących znaków grafi cznych ! # () * + , − . / : ; = ? [ \ ] ^ _ { | } ~ Pięć białych znaków Znak spacji, tabulacji poziomej, tabulacji pionowej, nowego wiersza i wysuwu strony Podstawowy zestaw znaków wykonywalnych zawiera także cztery znaki niedrukowalne: znak null, który działa jako znak kończący łańcuch znakowy, alarm, cofanie i powrót ka- retki. Znaki te można odzwierciedlić w literałach znakowych i łańcuchowych wpisując odpowiednie sekwencje specjalne, rozpoczynające się od ukośnika wstecznego: \0 repre- zentuje znak null, \a reprezentuje alarm, \b oznacza cofanie, zaś \r powrót karetki. Więcej informacji na ten temat można znaleźć w rozdziale 3. Rzeczywista liczbowa wartość znaku – kod znaku – może się różnić w zależności od implementacji C. Sam język nakłada jedynie następujące warunki: • Każdy znak w podstawowym zbiorze znaków musi być reprezentowany przez jeden bajt. • Znak null jest reprezentowany przez bajt, w którym wszystkie bity mają wartość 0. Zbiory znaków | 9 ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== • Wartości kolejnych cyfr dziesiętnych następujących po 0 są większe o jeden od war- tości odpowiadającej poprzedniej cyfrze. Znaki rozszerzone i wielobajtowe C został opracowany w środowisku angielskojęzycznym, w którym dominował zbiór zna- ków opisany 7-bitowym kodem ASCII. Od tego czasu największą popularność zyskało kodowanie znaków za pomocą bajtów 8-bitowych, lecz oprogramowanie przeznaczone do użytku międzynarodowego musi mieć możliwość reprezentowania większej różnorod- ności znaków, do których zakodowania nie wystarczy jeden bajt. Ponadto w wielu krajach już od dawna używano różnorodnych schematów wielobajtowych, służących do repre- zentowania alfabetów niełacińskich oraz chińskich, japońskich i koreańskich systemów pisma. W 1994 roku, wraz z dostosowaniem do dokumentu „Normative Addendum 1”, ISO C wprowadziło dwa standardy reprezentacji większych zbiorów znaków: • Znaki rozszerzone, w których każdy znak w zbiorze ma taką samą liczbę bitów. • Znaki wielobajtowe, w których dowolny znak może być reprezentowany przez jeden lub kilka bajtów, zaś wartość znakowa danej sekwencji bajtów może zależeć od kon- tekstu w łańcuchu lub strumieniu. Chociaż C udostępnia obecnie abstrakcyjne mechanizmy manipulowania i przekształcania różnych rodzajów schematów kodowania, sam język nie de- finiuje i nie określa żadnego schematu kodowania, ani żadnego zbioru znaków, oprócz zbiorów znaków podstawowych i rozszerzonych opisanych w poprzed- nim podrozdziale. Innymi słowy, sposób kodowania znaków rozszerzonych i wspierane schematy kodowania wielobajtowego zostały pozostawione w ge- stii poszczególnych implementacji. Znaki rozszerzone Począwszy od roku 1994, oprócz typu char, język C udostępnia także typ wchar_t, czy- li rozszerzony typ znakowy. Typ ten, zdefi niowany w pliku nagłówkowym stddef.h, jest na tyle duży, że pozwala na reprezentację dowolnego elementu z powiększonego zbioru znaków danej implementacji. Chociaż standard C nie wymaga wsparcia dla zbiorów znaków Unicode, to jednak wie- le implementacji do przekształceń znaków rozszerzonych wykorzystuje formaty Unicode, takie jak UTF-16 i UTF-32 (patrz http://www.unicode.org/). Standard Unicode jest w du- żej mierze identyczny ze standardem ISO/IEC 10646 i jest nadzbiorem wielu istniejących wcześniej zbiorów znaków, w tym 7-bitowego kodu ASCII. Gdy zaimplementowany jest standard Unicode, typ wchar_t składa się z 16 lub 32 bitów, zaś wartość przechowywana 10 | Rozdział 1: Podstawy języka ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== w zmiennej typu wchar_t reprezentuje jeden znak Unicode. Na przykład następująca defi nicja inicjalizuje zmienną wc i przypisuje do niej grecką literę α. wchar_t wc = \x3b1 ; Sekwencja specjalna rozpoczynająca się od \x oznacza, że zmienna będzie przechowywać kod znakowy w notacji szesnastkowej - w tym przypadku jest to kod oznaczający małą literę alfa. W celu uzyskania lepszego wsparcia dla Unicode standard C11 wprowadził dodatkowe rozszerzone typy znakowe char16_t i char32_t, które zostały zdefi niowane w pliku na- główkowym uchar.h jako bezznakowe typy całkowite. Znaki typu char16_t są zakodowa- ne w UTF-16 w implementacjach C, które defi niują makro __STDC_UTF_16__. Podobnie, w implementacjach defi niujących makro __STDC_UTF_32__, znaki typu char32_t są za- kodowane w schemacie UTF-32. P o d s t a w y j ę z y k a Znaki wielobajtowe W zbiorach znaków wielobajtowych każdy znak jest zakodowany za pomocą sekwencji jednego lub kilku bajtów. Zarówno znaki z źródłowych zbiorów znaków, jak i zbiorów wykonania programu zajmują tylko jeden bajt, zaś żaden znak wielobajtowy, z wyjątkiem znaku null, nie może zawierać bajtu złożonego z samych bitów 0. Znaki wielobajtowe mogą być wykorzystywane w stałych znakowych, literałach łańcuchowych, identyfi ka- torach, komentarzach i nazwach plików nagłówkowych. Wiele zbiorów znaków wielo- bajtowych zaprojektowano z myślą o konkretnym języku, czego przykładem może być zbiór znaków Japanese Industrial Standard (JIS). Zbiór znaków wielobajtowych UTF-8, zdefi niowany przez konsorcjum Unicode (Unicode Consortium), pozwala na zakodowa- nie wszystkich znaków Unicode. W UTF-8 każdy znak jest reprezentowany przez jeden do czterech bajtów. Najważniejsza różnica między znakami wielobajtowymi a znakami typu rozszerzone- go (czyli znakami typu wchar_t, char16_t oraz char32_t) polega na tym, że wszystkie znaki typu rozszerzonego mają ten sam rozmiar, zaś znaki wielobajtowe są reprezento- wane przez różną liczbę bajtów. Taka reprezentacja sprawia, że przetwarzanie łańcuchów znaków wielobajtowych jest bardziej skomplikowane niż łańcuchów znaków typu roz- szerzonego. Na przykład, nawet jeśli znak A można przedstawić w postaci jednego bajtu, znalezienie go w łańcuchu znaków wielobajtowych wymaga nie tylko zwykłego porówny- wania bajt po bajcie, ponieważ określony bajt w konkretnym położeniu może wchodzić w skład innego znaku. Jednakże znaki wielobajtowe świetnie się nadają do zapisywania tekstu w plikach (patrz rozdział 13.). Ponadto kodowanie znaków wielobajtowych zależy od architektury systemu, natomiast kodowanie znaków typu rozszerzonego zależy od upo- rządkowania bajtów w danym systemie: otóż w zależności od systemu, bajty znaku typu rozszerzonego mogą się znajdować w porządku big-endian lub little-endian. ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Zbiory znaków | 11 Przekształcenia C udostępnia funkcje standardowe pozwalające uzyskać wartość wchar_t dowolnego znaku wielobajtowego i przekształcenie dowolnego znaku typu rozszerzonego w repre- zentację wielobajtową. Na przykład, jeśli kompilator C używa standardów Unicode UTF- 16 i UTF-8, wówczas następujące wywołanie funkcji wctomb() (z ang. „wide character to multibyte” – znak typu rozszerzonego w wielobajtowy) pozwala uzyskać wielobajtową reprezentację znaku α: wchar_t wc = L \x3B1 ; // Mała grecka litera alfa, α char mbStr[10] = ; int nBytes = 0; nBytes = wctomb( mbStr, wc ); if( nBytes 0) puts( W ustawieniach regionalnych nie znaleziono odpowiedniego znaku wielobajtowego. ); Po udanym wywołaniu funkcji, tablica mbStr będzie zawierać znak wielobajtowy, czyli w tym przypadku sekwencję \xCE\xB1 . Wartość zwracana przez funkcję wctomb(), przypisana tutaj do zmiennej nBytes, oznacza liczbę bajtów potrzebną do zareprezento- wania znaku wielobajtowego, czyli w tym przypadku 2. Biblioteka standardowa udostępnia również funkcje służące do przekształceń typów char16_t i char32_t, czyli nowych typów znaków typu rozszerzonego wprowadzonych w C11. Przykładem może być funkcja c16rtomb(), która zwraca znak wielobajtowy, od- powiadający podanemu znakowi typu rozszerzonego char16_t (patrz podrozdział „Znaki wielobajtowe” w rozdziale 17.). Uniwersalne nazwy znaków C wspiera także uniwersalne nazwy znaków, które pozwalają na korzystanie z poszerzo- nego zbioru znaków niezależnie od kodowania stosowanego w implementacji. Dowolny znak typu rozszerzonego można określić za pomocą uniwersalnej nazwy znaku, która odpowiada jego wartości w Unicode w następującej postaci: \uXXXX lub: \UXXXXXXXX gdzie XXXX lub XXXXXXXX jest pozycją kodu Unicode w zapisie szesnastkowym. W zapisie tym należy używać przedrostka w postaci małej litery u, po której następują cztery cyfry szesnastkowe, lub w postaci wielkiej litery U, po której następuje dokładnie osiem cyfr szesnastkowych. Jeśli pierwsze cztery cyfry są zerem, wówczas uniwersalna nazwa znaku może być zapisana w postaci \uXXXX lub \U0000XXXX. 12 | Rozdział 1: Podstawy języka ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Uniwersalne nazwy znaków można stosować w identyfi katorach, stałych znakowych i literałach tekstowych. Jednakże nie można ich używać do reprezentowania znaków w podstawowym zbiorze znaków. Gdy określamy znak za pomocą jego uniwersalnej na- zwy, kompilator przechowuje go w zbiorze znaków wykorzystywanych przez implemen- tację. Na przykład, jeśli w programie wykorzystywany jest zbiór znaków wykonywalnych ISO 8859-7 (grecki 8-bitowy), wówczas następująca defi nicja zainicjalizuje zmienną alpha kodem \xE1: P o d s t a w y j ę z y k a char alpha = \u03B1 ; Jednakże, jeśli wykorzystywany jest zbiór znaków wykonywalnych UTF-16, wówczas na- leży zdefi niować zmienną w postaci znaku typu rozszerzonego: wchar_t alpha = \u03B1 ; // lub char16_t alpha = u \u03B1 ; W tym przypadku wartość kodu znakowego przypisana do zmiennej alpha ma postać szesnastkowego kodu 3B1, takiego samego, jak uniwersalna nazwa znaku. Nie wszystkie kompilatory wspierają uniwersalne nazwy znaków. Dwuznaki i trójznaki W języku C dostępne są alternatywne reprezentacje dla kilku znaków interpunkcyjnych, które nie są dostępne na niektórych klawiaturach. Sześć z nich to dwuznaki, czyli tokeny dwuznakowe, które reprezentują znaki przedstawione w tabeli 1-1. Tabela 1-1 Dwuznaki Dwuznak : Odpowiednik [ : : ] { } # : : ## Jeśli sekwencje te wchodzą w skład stałych znakowych lub literałów łańcuchowych, wów- czas nie są interpretowane jako dwuznaki. W pozostałych przypadkach zachowują się do- kładnie jak reprezentowane przez siebie tokeny jednoznakowe. Następujące przykładowe ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== Zbiory znaków | 13 fragmenty kodu są dokładnie równoważne i pozwalają uzyskać identyczny wynik. Z wy- korzystaniem dwuznaków: int arr :: = 10, 20, 30 ; printf( Drugim elementem w tablicy jest d .\n , arr :1: ); Bez dwuznaków: int arr[] = { 10, 20, 30 }; printf( Drugim elementem w tablicy jest d .\n , arr[1] ); Wynik: Drugim elementem w tablicy jest 20 . W języku C dostępne są także trójznaki, czyli reprezentacje trzyznakowe, z których każda rozpoczyna się od dwóch znaków zapytania. Trzeci znak określa, który znak interpunk- cyjny jest reprezentowany przez trójznak, co uwidacznia tabela 1-2. Tabela 1-2 Trójznaki Trójznak ??( Odpowiednik [ ??) ?? ?? ??= ??⁄ ??! ?? ??- ] { } # \ | ^ ~ Trójznaki pozwalają na napisanie dowolnego programu w C z wykorzystaniem jedynie znaków dostępnych w zdefi niowanym w 1991 roku standardzie ISO/IEC 646, odpowiada- jącym 7-bitowemu ASCII. Preprocesor kompilatora zastępuje trójznak odpowiednikiem jednoznakowym w pierwszym etapie kompilacji. Oznacza to, że trójznaki, w odróżnie- niu od dwuznaków, są tłumaczone na swoje jednoznakowe odpowiedniki niezależnie od miejsca wystąpienia, nawet jeśli znajdą się w stałych znakowych, literałach tekstowych, komentarzach i dyrektywach preprocesora. W poniższym przykładzie drugi i trzeci znak zapytania zostanie zinterpretowany przez preprocesor jako początek trójznaku: printf( Cancel???(y/n) ); 14 | Rozdział 1: Podstawy języka ##7#52#aSUZPUk1BVC1WaXJ0dWFsbw== W tym przypadku w wyniku działania preprocesora uzyskamy wiersz kodu w niepożą- danej postaci: printf( Cancel?[y/n) ); Jeśli zależy nam na użyciu jednej z tych trójznakowych sekwencji i chcemy uniknąć jej zinterpretowania jako trójznaku, możemy zapisać znaki zapytania za pomocą sekwencji specjalnych: printf( Cancel\?\?\?(y/n) ); Jeśli po dowolnych dwóch znakach zapytania następuje znak inny, niż zaprezentowane w tabeli 1-2, wówczas sekwencja nie jest traktowana jak trójznak i nie jest przetwarzana. P o d s t a w y j ę z y k a Oprócz dwuznaków i trójznaków dostępny jest jeszcze inny substytut zna- ków interpunkcyjnych. Dostępny jest za  pośrednictwem pliku nagłówko- wego iso646.h, który zawiera makra definiujące alternatywne reprezentacje operatorów logicznych i bitowych języka C, takich jak and dla i xor dla ^. Szczegółowe omówienie zawiera rozdział 16. Identyfikatory Termin identyfi kator odnosi się do nazw zmiennych, funkcji, makr, struktur i innych obiektów zdefi niowanych w programie C. Identyfi katory mogą zawierać następujące znaki: • Litery z podstawowego zestawu znaków, a-z i A-Z. Wielkość liter w identyfi katorach ma znaczenie. • Znak podkreślenia _. • Cyfry dziesiętne 0-9, chociaż nie mogą one stanowić pierwszego znaku identyfi katora. • Uniwersalne nazwy znaków, które reprezentują litery i cyfry obecne w innych językach. Dozwolone znaki uniwersalne są przedstawione w dodatku D do standardu C i odpowia- dają znakom zdefi niowanym w standardzie ISO/IEC TR 10176, z pominięciem znaków z podstawowego zestawu znaków. Identyfi katory mogą także zawierać znaki wielobajtowe. Jednakże to dana implemen- tacja C odpo
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Język C w pigułce
Autor:
,

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: