obrazek

Prezentowane materiały są przeznaczone dla uczniów szkół ponadgimnazjalnych.
Autor artykułu: mgr Jerzy Wałaszek, wersja1.0

obrazek

Pomoce:

Instalacja Code Blocks i tworzenie projektu aplikacji konsoli.
System uzupełnień do podstawy - U2

Wprowadzenie do języka C++

Utwórz w środowisku Code Blocks projekt aplikacji konsoli, a następnie w edytorze usuń szablon programu i wpisz poniższy tekst:

int main()
{

}

Jest to najprostszy program w C++, który nic nie robi, ale daje się skompilować i uruchomić. Zawiera on funkcję main(), która zwraca wartość całkowitą. Funkcja main() w C++ pełni specjalną rolę - od niej program rozpoczyna swoje działanie - wynika stąd prosty wniosek:

Każdy program w języku C++ musi posiadać funkcję main(), od której rozpoczyna działanie.

Sprawdź co się stanie, gdy nazwę funkcji wpiszesz jako Main(), zamiast main().

Funkcja main() zwraca wartość całkowitą, którą można wykorzystać (i często to się robi) do zwrócenia dodatkowych informacji przez program - np. czy wykonanie go powiodło się, czy też wystąpił jakiś błąd. Do zwracania wartości przez funkcję używamy polecenia return. Jeśli je pominiesz, to funkcja zwróci zero. Zmień program w edytorze na poniższy:

int main()
{
    return 155;
}

Jeśli teraz skompilujesz i uruchomisz program, w oknie konsoli pojawi się informacja:

Process returned 155 (0x9B) execution time : 0.040 s Press any key to continue.

To właśnie jest argument instrukcji return. Dodatkowo, ponieważ kod zwrócony przez program był różny od 0, w okienku Logs & others pojawi się na czerwonym tle napis:

Process terminated with status 155 (0 minutes, 0 seconds)

Tak będzie zawsze, jeśli funkcja main() zwróci wartość różną od 0 (oznaczającego wykonanie z sukcesem - inna wartość jest zawsze interpretowana jako błąd). Najczęściej funkcję main() będziemy kończyli instrukcją:

int main()
{
    return 0;
}

Jeśli teraz skompilujesz i uruchomisz program, to w oknie Logs & others nie pojawi napis na czerwonym tle, lecz napis niebieski:

Process terminated with status 0 (0 minutes, 1 seconds) Proces zakończył się ze statusem 0 ...

Zwykle program w C++ musi odczytywać dane z konsoli i wyprowadzać na nią wyniki swojego działania. Operacje wejścia/wyjścia nie są częścią definicji języka C++, lecz osobną biblioteką. Jeśli chcemy z nich korzystać, to musimy poinformować kompilator o obiektach, które tych operacji dokonują. Powszechnie wykorzystywaną biblioteką we/wy w C++ jest biblioteka STL (ang. Standard Template Library - Biblioteka Standardowych Szablonów). Definicje tych obiektów zawarte są w tzw. plikach nagłówkowych (ang. header files), które dołączamy do programu dyrektywą #include. Wpisz poniższy program:

#include <iostream>

int main()
{
    return 0;
}

Pliki nagłówkowe są bardzo wygodnym rozwiązaniem - zamiast w każdym programie wpisywać żmudnie definicje tych samych obiektów, wpisujemy jedynie prostą dyrektywę. Przed rozpoczęciem kompilacji plik źródłowy jest wstępnie obrabiany przez tzw. preprocesor. Wyszukuje on w programie źródłowym swoich poleceń, które nazywamy dyrektywami preprocesora. Np. polecenie #include każe preprocesorowi zastąpić się zawartością odpowiedniego pliku nagłówkowego, który jest wstawiany w miejscu tej dyrektywy. Następnie tak zmieniony plik wędruje do kompilatora, który ma już pod ręką wszystkie potrzebne definicje.

Plik nagłówkowy iostream definiuje tzw. strumienie wejścia/wyjścia konsoli (ang. input output streams). Strumień wyjścia cout (ang. console output) pozwala wyświetlać informację w oknie konsoli. Strumień wejścia cin (ang. console input) z kolei pozwala odczytywać informację wpisaną przez użytkownika z klawiatury. Wpisz poniższy program:

#include <iostream>

int main()
{
    std::cout << "Tutaj program w C++" << std::endl;
    return 0;
}

Po uruchomieniu zobaczymy w oknie konsoli napis:

Tutaj program w C++ Process returned 0 (0x0) execution time : 0.130 s Press any key to continue.

<< jest operatorem przesłania danych do strumienia.

endl to tzw. manipulator powodujący przejście z wydrukiem do następnego wiersza w oknie konsoli. Dzięki niemu po napisie Tutaj program w C++ mamy jeden pusty wiersz odstępu. Zamiast manipulatora endl można w tekście umieszczać znaki końca wiersza - \n:

#include <iostream>

int main()
{
    std::cout << "Tutaj program w C++\n";
    return 0;
}

Zwróć uwagę, że nazwy cout oraz endl są poprzedzone napisem std::. Jeśli go usuniesz, to program nie da się skompilować, ponieważ kompilator nie potrafi odnaleźć cout i endl. Napis std to tzw. przestrzeń nazw, w której żyją obiekty biblioteki STL. Wyobraź sobie ją jako worek z napisem std. Poza tym workiem nazwy zdefiniowanych w nim obiektów są niedostępne, o ile nie poprzedzisz je napisem std:: - wtedy kompilator będzie po prostu wiedział gdzie ich szukać. Możesz jednakże poinformować kompilator, że chcesz standardowo korzystać z danej przestrzeni nazw - do tego celu służy dyrektywa using namespace, za którą wpisujemy nazwę przestrzeni nazw. Gdy taką dyrektywę umieścisz w swoim programie, to nie będziesz musiał poprzedzać nazw cout, cin i innych z STL kwalifikatorem std:: - do duże ułatwienie. Dyrektywa using namespace std mówi po prostu kompilatorowi, że jeśli nie znajdzie danej nazwy w standardowym środowisku, to ma jej poszukać w "worku" o nazwie std. Przestrzenie nazw zmniejszają ryzyko konfliktów nazw różnych obiektów i z tego powodu znalazły się w języku C++. Uwierz nam, to dobry wynalazek.

Wpisz poniższy program:

#include <iostream>

using namespace std;

int main()
{
    cout << "Tutaj program w C++" << endl;
    return 0;
}

Na początku programu umieszczamy zwykle krótki komentarz informujący użytkownika o przeznaczeniu danego programu, autorze i dacie utworzenia. Komentarze mamy za darmo - nie są one przenoszone do programu wynikowego i w żaden sposób nie zwiększają jego pojemności ani nie zmniejszają szybkości działania. Komentujmy zatem programy - staną się o wiele czytelniejsze nawet dla samych ich autorów - szczególnie po upływie kilku tygodni od daty utworzenia.

// Przykładowy program w C++
// (C)2010 mgr Jerzy Wałaszek
// I LO w Tarnowie
//---------------------------

#include <iostream>

using namespace std;

int main()
{
    cout << "Tutaj program w C++" << endl;
    return 0;
}

Podsumowanie

Program w języku C++ posiada następującą strukturę:

// Przykładowy program w C++ // (C)2010 mgr Jerzy Wałaszek // I LO w Tarnowie //---------------------------	Komentarz
#include <iostream>	Pliki nagłówkowe zawierające definicje używanych w programie struktur danych oraz funkcji bibliotecznych.
using namespace std;	Jeśli wykorzystujemy elementy biblioteki STL, to wstawiamy do programu dyrektywę informującą kompilator o używanej przestrzeni nazw.
int main() { cout << "Tutaj program w C++" << endl; return 0; }	Każdy program w języku C++ musi posiadać funkcję main(), od której rozpoczyna się wykonywanie programu. Zawartość tej funkcji określa to, co program robi.

Zmienne

Zwykle chcemy przetwarzać w programie pewne dane. Do ich przechowywania służą zmienne (ang. variables). Zmienna jest fragmentem pamięci komputera, w którym program przechowuje określone dane. Przed pierwszym użyciem zmiennej musi ona zostać zdefiniowana. Definicja zmiennej w C++ jest następująca:

typ_danych nazwa_zmiennej;

typ_danych - określa rodzaj przechowywanej w zmiennej informacji. Na poprzednich zajęciach poznaliśmy kod U2, który jest powszechnie używany do reprezentacji liczb całkowitych w systemach komputerowych. Typ int oznacza 32 bitową liczbę U2 o zakresie od -2³¹ do 2³¹ - 1, czyli około ± 2 mld. Będziemy również używali 32 bitowych liczb w naturalnym kodzie binarnym, który w języku C++ reprezentowany jest przez typ unsigned int.

nazwa_zmiennej jest napisem, dzięki któremu mamy dostęp do danych przechowywanych przez zmienną. Nazwy w języku C++ tworzymy z liter małych i dużych, cyfr oraz znaku podkreślenia _. Pierwszym znakiem nazwy powinna być litera (nie może być nim cyfra!). Zmienna nie powinna mieć nazwy dłuższej od 31 znaków (tyle zwykle zapamiętują kompilatory C++). Nie wolno również zmiennym nadawać nazw identycznych ze słowami kluczowymi języka C++ (np. return, int, unsigned, itp.). Nazwa zmiennej powinna również kojarzyć się ze spełnianą przez tą zmienną funkcją w programie.

Przykłady definicji zmiennych:

int a; // zmienna a jest zmienną U2


int a,b,c,d;             
// w jednej definicji można umieścić kilka zmiennych
unsigned int x1,x2,wynik; // zmienne NBC

Ze strumienia cin możemy odczytać dane wprowadzone przez użytkownika z klawiatury w oknie konsoli i umieścić je w wybranej zmiennej. Wykonujemy to następująco:

cin >> nazwa_zmiennej;

// Przykładowy program w C++
// (C)2010 mgr Jerzy Wałaszek
// I LO w Tarnowie
//---------------------------

#include <iostream>

using namespace std;

int main()
{
    unsigned int wiek;

    cout << "Witaj. Ile masz lat? : ";
    cin  >> wiek;
    cout << "Teraz masz " << wiek
         << ". Ale za 15 lat bedziesz mial juz " << wiek + 15
         << ".\n\n";

    return 0;
}

Instrukcja przypisania

Do przetwarzania danych w programie służy instrukcja przypisania (ang. assignement statement). W języku C++ posiada ona następującą postać:

zmienna = wyrażenie;

Komputer oblicza wartość wyrażenia i wynik umieszcza w podanej zmiennej. Znaku = nie traktuj jako równość matematyczną, jest to symbol operacji przypisania.

// Program  przeliczający stopnie
// Celsjusza na stopnie Fahrenheita.
// (C)2010 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
    int tc,tf;
    cout << "Przeliczanie stopni Celsjusza na stopnie Fahrenheita\n"
            "----------------------------------------------------\n\n"
            "Temperatura w stopniach Celsjusza?  : ";
    cin  >> tc;
    tf = (9 * tc) / 5 + 32;
    cout << "Temperatura w stopniach Fahrenheita : " << tf << endl << endl;
    return 0;
}

Instrukcje modyfikacji zmiennej

Język C++ posiada dwa użyteczne operatory do zwiększania i zmniejszania zawartości zmiennej:

++ - zwiększa zawartość zmiennej o 1
-- - zmniejsza zawartość zmiennej o 1

Operatory te można stosować na dwa sposoby:

++ zmienna lub zmienna ++

-- zmienna lub zmienna --

Jeśli operacja zwiększania zmiennej jest samodzielną instrukcją, to nie ma znaczenia, który z tych sposobów użyjemy. Poniższe dwa programy dają identyczne wyniki:

// Modyfikacja zmiennej
// (C)2010 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
    int a = 125, b = 30;

    ++a;  --b;
    cout << a << " " << b << endl;

    system("pause");
    return 0;
}

// Modyfikacja zmiennej
// (C)2010 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
  int a = 125, b = 30;

  a++;  b--;
  cout << a << " " << b << endl;

  system("pause");
  return 0;
}

W obu programach tworzone są dwie zmienne a i b. Zmiennej a nadajemy wartość 125, a zmiennej b 30. Następnie program zwiększa zawartość zmiennej a o 1 do 126, a zawartość zmiennej b zmniejsza o 1 do 29. Na koniec zawartości zmiennych są kolejno wyświetlane i otrzymujemy liczby 126 i 29. W pierwszym programie operatory ++ i -- stosujemy przed zmiennymi, a w drugim po zmiennych.

Jeśli operator zwiększania ++ lub zmniejszania -- zastosujemy do zmiennej użytej w wyrażeniu, to bardzo istotne jest, którą z form wybierzemy:

++ zmienna, -- zmienna : najpierw modyfikuje zawartość zmiennej, a następnie wynik jest używany do obliczeń w wyrażeniu
zmienna ++, zmienna -- : w wyrażeniu stosowana jest bieżąca zawartość zmiennej, a następnie po wyliczeniu wyrażenia zmienna jest modyfikowana.

Przykład:

Poniższe dwa programy dają różne wyniki:

// Modyfikacja zmiennej
// (C)2010 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
  int a = 125, b = 30,c,d;

  c = ++a;  d = --b;

  cout << a << " " << b << " "
       << c << " " << d << endl;

  system("pause");
  return 0;
}

// Modyfikacja zmiennej
// (C)2010 I LO w Tarnowie
//----------------------------------

#include <iostream>

using namespace std;

int main()
{
  int a = 125, b = 30,c,d;

  c = a++;  d = b--;

  cout << a << " " << b << " "
       << c << " " << d << endl;

  system("pause");
  return 0;
}

Programy różnią się jedynie sposobem umieszczenia operatorów ++ oraz -- w stosunku do modyfikowanej zmiennej. W obu przypadkach zmienna a przyjmuje na końcu wartość 126, a zmienna b 29. Jednakże w pierwszym programie do zmiennej c trafi 126 i do d 29, a w drugim do c trafi 125, a do d 30. W pierwszym programie zmienna a w wyrażeniu c = ++a; jest najpierw zwiększana z 125 na 126 i ten wynik trafia do zmiennej c. podobnie zmienna b w wyrażeniu d = --b; zostanie najpierw zmniejszona do 29 i wynik ten trafi do zmiennej d. W drugim programie operatory ++ i -- umieszczone są za zmienną. Zatem w wyrażeniu c = a++; do zmiennej c trafi najpierw zawartość zmiennej a, czyli 125, a następnie zmienna a zostanie zwiększona do 126. Podobnie w wyrażeniu d = b--; do zmiennej d trafi zawartość b, czyli 30, a następnie zmienna b zostanie zmniejszona do 29.

Na opisane wyżej zjawisko należy bardzo uważać w programach C++, gdyż często prowadzi ono do trudno wykrywalnych błędów. Najbezpieczniej jest modyfikować zmienną poza wyrażeniami, lecz często robi się to wewnątrz wyrażeń w celu optymalizacji kodu. Wybór jest twój - zostałeś ostrzeżony.

Poza prostymi operatorami zwiększania lub zmniejszania o 1 zawartości zmiennej, język C++ posiada bogatą gamę operatorów modyfikacji:

zmienna += wyrażenie; - zwiększa zawartość zmiennej o wartość wyrażenia:

a += 2; // zmienne a zostaje zwiększona o 2 c += a + b; // zmienna c zostaje zwiększona o sumę zmiennych a i b

zmienna -= wyrażenie; - zmniejsza zawartość zmiennej o wartość wyrażenia:

a -= 3; // zmienna a zostaje pomniejszona o 3 b -= 2 * c; // zmienna b zostaje pomniejszona o 2 * c

zmienna *= wyrażenie; - mnoży zawartość zmiennej przez wartość wyrażenia

a *= 3; // zmienna a zostaje pomnożona przez 3 b *= c - d; // zmienna b zostaje pomnożona przez różnicę zmiennych c i d

zmienna /= wyrażenie; - dzieli zawartość zmiennej przez wartość wyrażenia

a /= 4; // zawartość zmiennej a zostaje podzielona przez 4 b /= c--; // zawartość zmiennej b zostaje podzielona przez c, po czym c zostaje zmniejszone o 1

zmienna %= wyrażenie; - w zmiennej zostanie umieszczona reszta z dzielenia tej zmiennej przez wartość wyrażenia:

a %= 10; // w zmiennej a znajdzie się reszta z dzielenia a przez 10, czyli ostatnia cyfra dziesiętna a %= 2; // w zmiennej a będzie 0, jeśli a było parzyste, lub 1, jeśli a było nieparzyste

Podane powyżej operatory modyfikacji (jak również instrukcje przypisania) mogą wystąpić w wyrażeniach, lecz odradzamy takie rozwiązania poza szczególnymi wyjątkami - prowadzą one do bardzo zawiłych kodów, które trudno później analizować:

a = 1; b = 2; c = 3; a = c + (b += 5 * (c *= 3 + b)); // odpowiedz bez uruchamiania, jaki będzie wynik w a?

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe