Spis treści

1
2010-05-29
Spis treści
1. LITERATURA.................................................................................................................................................................................... 3
2. PODSTAWOWE POJĘCIA .............................................................................................................................................................. 3
3. PROGRAM ......................................................................................................................................................................................... 4
3.1. JĘZYKI PROGRAMOWANIA .............................................................................................................................................................. 4
3.2. KOMPILOWANIE PROGRAMU .......................................................................................................................................................... 4
3.3. URUCHAMIANIE I TESTOWANIE PROGRAMU ................................................................................................................................... 4
3.4. DOKUMENTACJA PROGRAMU ......................................................................................................................................................... 4
3.5. PROGRAM – JEDNOSTKI SYNTAKTYCZNE ........................................................................................................................................ 5
4. ŚRODOWISKO PROGRAMISTYCZNE — WPROWADZENIE................................................................................................ 5
5. WPROWADZENIE DO C++............................................................................................................................................................. 6
ZMIENNE I FUNKCJE .............................................................................................................................................................................. 7
ZMIENNE TYPÓW ZŁOŻONYCH .............................................................................................................................................................. 7
6. INSTRUKCJE STERUJĄCE ............................................................................................................................................................ 8
INSTRUKCJA WARUNKOWA IF .............................................................................................................................................................. 8
PĘTLA WHILE ....................................................................................................................................................................................... 8
PĘTLA DO WHILE ................................................................................................................................................................................. 8
PĘTLA FOR ........................................................................................................................................................................................... 8
INSTRUKCJA WYBORU SWITCH ............................................................................................................................................................... 9
INSTRUKCJA GOTO ................................................................................................................................................................................. 9
INSTRUKCJA BREAK................................................................................................................................................................................ 9
INSTRUKCJA CONTINUE .......................................................................................................................................................................... 9
7. TYPY DANYCH ............................................................................................................................................................................... 10
7.1. DEFINIOWANIE ZMIENNYCH I STAŁYCH NAZWANYCH. DEKLARACJA A DEFINICJA ZMIENNEJ ....................................................... 10
7.2. KLASYFIKACJA TYPÓW ................................................................................................................................................................ 10
Typy proste wbudowane, reprezentujące liczby............................................................................................................................ 10
Typy złożone.................................................................................................................................................................................. 10
Typ void ...................................................................................................................................................................................... 11
Typ wyliczeniowy enum ................................................................................................................................................................ 11
Instrukcja typedef ..................................................................................................................................................................... 11
Modyfikator register ............................................................................................................................................................... 11
Modyfikator volatile ............................................................................................................................................................... 11
7.3. ZAKRES WAŻNOŚCI NAZWY A CZAS ŻYCIA OBIEKTU..................................................................................................................... 11
7.4. ZMIENNE GLOBALNE I LOKALNE. PRZESTRZEŃ NAZW. ZASŁANIANIE NAZW OBIEKTÓW ............................................................... 12
7.5. STAŁE DOSŁOWNE ........................................................................................................................................................................ 12
8. OPERATORY................................................................................................................................................................................... 13
8.1. OPERATORY MATEMATYCZNE ...................................................................................................................................................... 13
8.2. POZOSTAŁE OPERATORY .............................................................................................................................................................. 14
8.3. PRIORYTETY I ŁĄCZNOŚĆ OPERATORÓW ...................................................................................................................................... 14
9. FUNKCJE.......................................................................................................................................................................................... 16
9.1. PROCEDURA A FUNKCJA. PARAMETRY FORMALNE I AKTUALNE. DEKLARACJA A DEFINICJA FUNKCJI .......................................... 16
9.2. ZWRACANIE REZULTATU PRZEZ FUNKCJĘ..................................................................................................................................... 16
9.3. PRZESYŁANIE ARGUMENTÓW DO FUNKCJI PRZEZ WARTOŚĆ ......................................................................................................... 17
9.4. PRZESYŁANIE ARGUMENTÓW PRZEZ REFERENCJĘ ........................................................................................................................ 17
9.5. PRZESYŁANIE ARGUMENTÓW JAKO WSKAŹNIKÓW ....................................................................................................................... 17
9.6. ARGUMENTY DOMNIEMANE ......................................................................................................................................................... 18
9.7. ZAKRES WAŻNOŚCI NAZWY A CZAS ŻYCIA OBIEKTU — C.D.......................................................................................................... 18
Obiekty globalne ........................................................................................................................................................................... 18
Obiekty lokalne automatyczne...................................................................................................................................................... 18
Obiekty lokalne statyczne ............................................................................................................................................................. 18
10. TABLICE ........................................................................................................................................................................................ 19
10.1. DEFINIOWANIE TABLIC.............................................................................................................................................................. 19
10.2. ELEMENTY TABLICY ................................................................................................................................................................... 19
10.3. INICJALIZACJA TABLIC ............................................................................................................................................................... 19
10.4. TABLICE ZNAKOWE .................................................................................................................................................................... 19
10.5. PRZEKAZYWANIE TABLIC DO FUNKCJI. TABLICE WIELOWYMIAROWE ........................................................................................ 19
2
11. WSKAŹNIKI .................................................................................................................................................................................. 20
11.1. DEFINIOWANIE I UŻYWANIE WSKAŹNIKÓW ................................................................................................................................ 20
11.2. OPERATOR RZUTOWANIA REINTERPRET_CAST ........................................................................................................................... 20
11.3. WSKAŹNIKI TYPU VOID............................................................................................................................................................... 20
11.4. ZASTOSOWANIE WSKAŹNIKÓW WOBEC TABLIC .......................................................................................................................... 20
11.5. STAŁE WSKAŹNIKI, WSKAŹNIKI DO STAŁYCH ............................................................................................................................. 21
11.6. ZASTOSOWANIE WSKAŹNIKÓW W ARGUMENTACH FUNKCJI ....................................................................................................... 21
11.7. ZASTOSOWANIE WSKAŹNIKÓW PRZY DOSTĘPIE DO KONKRETNYCH KOMÓREK PAMIĘCI ............................................................. 21
11.8. REZERWACJA OBSZARÓW PAMIĘCI ............................................................................................................................................. 21
Operatory new i delete .......................................................................................................................................................... 21
Dynamiczna alokacja tablicy........................................................................................................................................................ 21
Umiejscawiający operator new .................................................................................................................................................... 21
3
1. Literatura
Algorytmika
[1] J. Glenn Brookshear: Informatyka w ogólnym zarysie. WNT, Warszawa 2003
[2] Leszek Jung: Podstawy użytkowania komputerów. Konstruowanie algorytmów. S. WAT, Warszawa 1988
[3] Niklaus Wirth: Algorytmy + struktury danych = programy. WNT, Warszawa 2004
[4] Henryk Spustek, Jerzy Grzyb: Informatyka - algorytmy, wstęp do programowania. Skrypt WSISiZ,
Warszawa 2002
Programowanie w C++
[5] Jerzy Grębosz: Symfonia C++ standard. Edition 2000 Kraków
[6] Jesse Liberty (tłum. Marcin Pancewicz): C++ dla każdego. Helion, Gliwice 1994
org. Teach Yourself C++ in 21 Days. Fourth Edition. Sams
[7] A.Stasiewicz: C++ Ćwiczenia praktyczne. Helion, Gliwice 08/2004
[8] Piotr Wróblewski: Język C++ dla programistów. Helion, Gliwice 1994
[9] Michael Flenov: Elementarz hakera. Helion, Gliwice 2005
[10] Richard C. Linecker, Tom Archer: Visual C++ Vademecum profesjonalisty. Helion, Gliwice
[11] Viktor Toth: Programowanie Windows 98/NT. Księga eksperta. Helion, Gliwice (org. Sams)
[12] Charles Petzold, Paul Yao: Programowanie Windows 95. Helion, ReadMe 1997 (org. Microsoft Press)
2. Podstawowe pojęcia
Informatyka – nauka o przetwarzaniu informacji przy użyciu środków automatyzujących ten proces.
Informacja – wielkość abstrakcyjna, która może być
• przechowywana w pewnych obiektach,
• przesyłana między pewnymi obiektami,
• przetwarzana w pewnych obiektach
• i stosowana do sterowania pewnymi obiektami,
przy czym przez obiekt rozumie się organizmy żywe, urządzenia techniczne oraz systemy takich obiektów.
Komunikat – odpowiednio zakodowana wiadomość, zawierająca pewną ilość informacji.
Komputer – urządzenie techniczne, umożliwiające automatyzację procesu przetwarzania informacji,
opisywanego przez program zapisywany w pamięci komputera,
a następnie wykonywany (celem realizacji tego procesu przetwarzania informacji)
przez jego procesor (układ operacyjny, zdolny do wykonywania obliczeń opisanych kolejnymi instrukcjami programu).
Programowanie – samodzielna dyscyplina, zajmująca się systematycznym konstruowaniem i formułowaniem
algorytmów, zapisywanych jako programy, które są następnie uruchamiane i testowane.
Algorytm – opis działań, które należy wykonać w określonej kolejności na ustalonych obiektach i zbiorach
wartości dla osiągnięcia wyznaczonego celu.
Schemat blokowy – graficzny zapis działań algorytmu przy wykorzystaniu ustalonych schematów graficznych
łączonych za pomocą skierowanych linii obrazujących kolejność ich wykonywania.
Program – skonkretyzowany zapis w formie tekstowej algorytmu (wraz z opisem obiektów w nim
występujących) przy użyciu pojęć danego języka programowania.
4
3. Program
Język programowania – ściśle określona konwencja notacyjna służąca do zapisu algorytmów w formie
programów, które są przeznaczone do wykonywania przez komputer.
Program – ciąg symboli definiowanych przez język programowania.
Komputer może wykonywać tylko programy zapisane w swoim języku wewnętrznym.
Język formalny – system:
gdzie:
J = V , G , D, Z ,
V – alfabet (dopuszczalny zbiór znaków języka);
G – gramatyka (składnia (syntaktyka); zbiór reguł składniowych);
D – dziedzina (zbiór informacji wyrażalnych w języku);
Z – znaczenie (semantyka; zbiór relacji wiążących wyrażenia języka z elementami jego dziedziny),
w którym – stosując dobrze określone reguły składniowe – możemy uzyskać (lub sprawdzić) wszystkie
napisy (zdania) uznawane za komunikaty w tym języku.
Pragmatyka języka – zbiór zaleceń dotyczących używania poprawnych wyrażeń języka.
3.1. Języki programowania
Język wewnętrzny (maszynowy) – język programowania, którego jedynymi dopuszczalnymi wyrażeniami są
zapisywane jako liczby binarne, słowa rozkazowe należące do repertuaru rozkazów (zwanego także listą
rozkazów), w który jest technicznie „wyposażony” dany komputer i które mogą być bezpośrednio
wykonywane (przez procesor).
Programy tłumaczące:
• asembler dla języków niskopoziomowych;
• kompilator dla języków wysokopoziomowych;
• interpreter dla języków konwersacyjnych;
Język niskopoziomowy – język programowania, którego własności w istotnym stopniu odzwierciedlają
własności konkretnego komputera.
Język zestawiający (asemblerowy) – język programowania, powstały z języka wewnętrznego przez
parametryzację zapisu części słowa rozkazowego; parametryzacja polega głównie na symbolicznym
zastąpieniu liczbowych kodów rozkazów oraz liczbowych adresów słów pamięci.
Język wysokopoziomowy – język programowania, którego własności i notacja jest zbliżona do stosowanej
notacji oraz pojęć z określonej dziedziny zastosowań.
3.2. Kompilowanie programu
Kompilacja – proces tłumaczenia programów zapisanych w języku programowania na równoważny
semantycznie (znaczeniowo) program zapisany w języku wewnętrznym komputera, realizowany przez
specjalny program tłumaczący, zwany kompilatorem.
3.3. Uruchamianie i testowanie programu
Testowanie programu – proces wielokrotnej realizacji programu dla zbioru zestawów danych testowych
(wybranych zestawów danych wejściowych) celem wykrycia możliwie największej liczby błędów;
Metoda eksperymentalnego badania poprawności programu, zajmująca od 30 do 60% całego czasu
przeznaczonego na opracowanie programu.
Uruchamianie programu – proces złożony z kilku etapów: wykrycie miejsca wystąpienia i powstania błędu,
doprowadzenie programu do działania, które są powtarzane cyklicznie, po każdorazowym stwierdzeniu
wystąpienia błędu.
3.4. Dokumentacja programu
Dokumentacja programu – jest wyselekcjonowanym zbiorem informacji z kolejnych etapów jego
projektowania oraz o sposobie użytkowania i pielęgnowania.
Trzy rodzaje dokumentacji programu:
– projektowa, opisuje kolejne etapów wytwarzania programu;
– eksploatacyjna, zwana podręcznikiem użytkownika, opisuje przeznaczenie programu i sposób używania;
– techniczna, tworzona dla potrzeb przyszłej pielęgnacji programu.
5
3.5. Program – jednostki syntaktyczne
Jednostka syntaktyczna – wyodrębniona część programu, która ma dobrze określoną interpretację (znaczenie)
w ramach programu.
Jednostki syntaktyczne:
Moduł – wyodrębniona część programu mająca:
• dobrze (i jednoznacznie) określone znaczenie, które jest niezależne od miejsca użycia modułu i wewnętrznej
struktury innych modułów;
• nazwę i ściśle określoną komunikację (więzi) z innymi modułami, poprzez specyfikację atrybutów
(jednostek programowych):
– importowanych z innych modułów,
– eksportowanych do innych modułów,
których rodzaj i sposób użycia określa jednoznacznie sama ich deklaracja;
• ustalone zasady łączenia z innymi modułami w większe jednostki programowe (do programu włącznie) na
podstawie ich specyfikacji i bez znajomości wewnętrznej struktury tych modułów.
Część deklaracyjna, część instrukcyjna.
Stała – jednostka syntaktyczna, reprezentująca synonim pewnej niezmiennej wartości wyrażenia (wielkości)
przypisanego jej w deklaracji stałych.
Wyrażenie – zespół argumentów powiązanych operatorami według ustalonych reguł syntaktycznych określonej konwencji
notacyjnej (najczęściej zwyczajowej notacji matematycznej).
Typ danych – jednostka syntaktyczna, określająca zbiór wartości oraz operacji wykonywanych na tych
wartościach.
Deklaracje typów wprowadzają nazwy, które reprezentują opis typu danych.
Zmienna – jednostka syntaktyczna reprezentująca obiekt programu, który może przyjmować wartości ze
zbioru określonego typem danych tej zmiennej.
Deklaracje stałych wprowadzają nazwy stałych jako synonimy ustalonych wielkości (literałów: liczb, znaków, ciągów znaków).
Deklaracje zmiennych wprowadzają nazwy, które reprezentują obiekty przyjmujące wartości ze zbioru wartości określonego typem
danych deklarowanej zmiennej.
Procedura / funkcja – wyodrębniona część programu (podprogramu, modułu), posiadająca:
• nazwę, opisującą dobrze określone działanie wykonywane na dobrze określonych obiektach (parametrach
formalnych, zmiennych lokalnych i zmiennych globalnych)
• ustalony sposób wymiany danych z pozostałymi częściami programu:
• sposób przekazu danych do treści procedury / funkcji z pozostałej części programu (w której nastąpiło
wywołanie procedury / funkcji)
• sposób przekazu obliczonej wartości do miejsca wywołania funkcji.
Deklaracje procedur / funkcji wprowadzają nazwy, którym przypisywana jest wyodrębniona część programu
Parametr formalny – nazwa zmiennej występującej w treści procedury, której nie odpowiada żaden obiekt
programu (algorytmu);
dopiero w chwili użycia (wywołania) procedury podczas wykonywania programu, w którym została
zdefiniowana, każdemu parametrowi formalnemu zostaje przyporządkowany
parametr aktualny, czyli jakiś obiekt (zmienna, wartość wyrażenia) programu, który zastępuje
odpowiadający mu parametr formalny w treści procedury.
Instrukcja – wyróżniona jednostka syntaktyczna mająca jasno określone znaczenie operacyjne przez
semantykę języka. Wykonanie instrukcji polega na realizacji w jednoznacznie określonym porządku operacji
(działań) na obiektach wskazanych przez identyfikatory zmiennych (oznaczających elementy struktury
danych) występujących w rozważanej instrukcji.
4. Środowisko programistyczne — wprowadzenie
6
5. Wprowadzenie do C++
#include
// Program 1
/* najprostszy program
w C++ */
/* wersja obiektowa */
#include <iostream.h>
void main()
{
cout << "Halo\n";
}
iostream.h
/* wersja
proceduralna */
#include <stdio.h>
void main()
{
printf("Halo\n");
}
stdio.h
main
void
\n
← dyrektywa włączenia tekstu
zawartego w pliku
← (Input Output Stream) plik
deklaracji obiektowych strumieni
wej/wyj
← (Standard Input Output) plik
deklaracji funkcji wej/wyj
← zastrzeżona nazwa głównej
funkcji programu
← typ danej “pustej”
← przejście do nowego wiersza
Wolny format zapisu programu
Instrukcje oddzielane za pomocą ; Białe znaki – ignorowane: spacje, tabulatory, nowe linie
lub
// do końca linii
Komentarze: /* nie wolno zagnieżdżać */
Zastrzeżona nazwa głównej funkcji programu — funkcja main()
Nazwy w C++
Dowolnie długi ciąg liter, cyfr oraz znaków podkreślenia _.
Nazwa nie może się zacząć od cyfry. Małe i wielkie litery w nazwach są rozróżniane.
Nazwa nie może być identyczna z żadnym ze słów kluczowych języka C++.
Słowa kluczowe w C++
asm
auto
bool
break
case
catch
char
class
const
const_cast
continue
default
delete
do
double
dynamic_cast
else
enum
explicit
export
extern
false
float
for
friend
goto
if
inline
int
long
mutable
namespace
new
operator
private
protected
public
register
reinterpret_cast
return
short
signed
sizeof
static
static_cast
struct
switch
template
this
throw
true
try
typedef
typeid
typename
union
unsigned
using
virtual
void
volatile
wchart_t
while
Standardowa obiektowa biblioteka wejścia/wyjścia – plik nagłówkowy <iostream.h> lub nowsza plik
nagłówkowy <iostream> (deklaracje).
obiekty predefiniowane:
cin – standardowy strumień wejściowy danych (zwykle klawiatura)
cout – standardowy strumień wyjściowy danych (zwykle ekran monitora)
cerr – standardowy strumień wyjściowy błędów (zwykle ekran monitora)
Zmiana strumienia wejściowego cin:
Wykorzystanie strumienia wyjściowego błędów cerr:
dany jest plik tekstowy a.txt,
zawierający np:
3.4 6.1
i wynikowy Program 2: program.exe,
który uruchamiamy: program.exe < a.txt
#include <iostream.h>
void main()
// ...
cerr << "OK!\n";
// ...
}
uruchamiamy: program.exe > kom.txt
7
Zmienne i funkcje
// Program 2
#include <iostream>
using namespace std;
// włączenie pliku
// użycie przestrzeni nazw std
endl ← (end line) manipulator
przejścia do nowej linii
float roznica(float x, float y); // deklaracja funkcji
void main()
// główna funkcja
{
float a, b;
// definicja zmiennych: a, b
cin >> a >> b;
// wczytanie wartości do a, b
float s = roznica(a, b); // wywołanie funkcji (parametry aktualne)
cout << "Roznica = " << s << "\n";
cout << "2 - 3 = " << roznica(2,3) << endl;
}
float roznica(float x, float y) // definicja funkcji
{
// x, y – parametry formalne
return x - y;
// zwrócenie wartości przez funkcję
}
Definicja zmiennej (§7.1, s. 10)
typz nazwa_zmiennej;
Definicja funkcji (§9.1, s. 16)
typf nazwa_fun(typ1 arg1, typ2 arg2, ..., typn argn)
{
// ciało funkcji
}
Deklaracja funkcji (§9.1, s. 16)
typf nazwa_fun(typ1 [arg1], typ2 [arg2], ..., typn [argn]);
Wywoływanie funkcji (§9.1, s. 16)
nazwa_fun(arg_akt1, arg_akt2, ..., arg_aktn)
Zmienne typów złożonych
zmienne wskaźnikowe (§11, s. 20), zmienne referencyjne, tablice (§10, s. 19).
// Program 3
#include <iostream>
using namespace std;
Odwołania programu Pamięć fizyczna
a
wartość
adres
&a
1->2->3
1000h
void main()
// główna funkcja
wsk
{
1000h
1004h
*wsk
int a = 1; // definicja i inicjalizacja zmiennej a
10
1008h
ref
// zmienna wskaźnikowa (wskaźnik to zmienna do przechowywania adresu)
20
100Ch
tab
int* wsk;
// definicja wskaźnika do obiektów typu int
0
1010h
wsk = &a;
// przypisanie do wskaźnika adresu zmiennej (obiektu) a
tab[0]
1014h
cout << a; // 1
tab[1]
1008h
*wsk = 2;
// przypisanie do obiektu wskazanego przez wsk wartości 2
tab[2]
cout << a; // 2
101Ch
wtab
// zmienna referencyjna (referencja to alias już istniejącej zmiennej):
int& ref = a;
// definicja referencji do obiektu a
cout << a; // 2
ref = 3;
// przypisanie do referencji ref wartości 3
cout << a; // 3
// tablica (grupuje zmienne jednego typu):
int tab[3] = {10, 20}; // definicja tablicy 3-elementowej obiektów typu int
for(int i=0; i<3; i++)
cout << tab[i]; // wydruk elem. tablicy: 10 20 0
int* wtab = tab; // nazwa tablicy jest adresem jej początku, czyli pierwszego
// elementu o indeksie 0 (tablice indeksowane są od 0)
}
// włączenie pliku
// użycie przestrzeni nazw std