Podstawowe elementy w językach programowania, cz. 2 - Programowanie jest łatwe

Po co jest średnik i dlaczego jest najczęściej poszukiwanym znakiem przez programistów? Jak sterować przepływem algorytmu? Odpowiedzi na te pytania w tym artykule.

Entre les trous de la memoire, Dominique Appia

W poprzedniej części poruszyłem podstawowe elementy, które występują w każdym języki programowania. Teraz, bez zbędnego wprowadzenia, przedstawię kolejne składniki, z którymi przyjdzie się zmierzyć każdemu, kto programuje.

Instrukcje, operacje

Możemy umieścić kilka instrukcji w ramach jednej operacji. Każdą operację oddzielamy przecinkiem. Jeżeli pominiemy średnik, kompilator nam o tym przypomni zgłaszając błąd kompilacji. Oddzielanie instrukcji średnikiem ma takie samo znaczenie jak umieszczanie instrukcji w osobnych blokach przy tworzeniu schematów blokowych.


// -------------------------------------------------------
int speed = 0;

speed = 10; // poprawnie zakończenie instrukcji
speed += 5  // brak średnika po instrukcji, błąd kompilacji
speed = (10 / 2) - speed; // poprawne zakończenie instrukcji
// -------------------------------------------------------

Po co średnik? Po to aby rozdzielać instrukcje i unikać dwuznaczności. W przykładzie powyżej druga linia jest dwuznaczna ponieważ po niej następuje kolejna. Gdy brakuje średnika kompilator nie wie w jaki sposób postąpić z takim zapisem i zgłasza błąd. Średnik nierzadko nazywany jest przez programistów jako “najbardziej poszukiwany znak” gdyż jego brak może nie tylko powodować błąd kompilacji. Istnieją sytuacje, w których brak średnika zostanie potraktowany przez kompilator jako coś normalnego a podczas wykonywania się programu napotkamy na nieprzewidywalne wyniki. Wyobraź sobie takie zdanie: “Weź ze sobą nóż, gaśnicy nie ruszaj.”. Przecinak tutaj rozdziela zdanie na dwa zdania proste. Co jeśli przesuniemy przecinek o jedno słowo dalej albo w ogóle go pominiemy? Ponieważ C pozwala nam na dowolne formatowanie każdej instrukcji niezbędne staje się zastosowanie znaku, który umożliwi kompilatorowi ich odróżnianie.

// -------------------------------------------------------
int speed 
= 0;
int a = 
                       speed + 1;
// -------------------------------------------------------

Bloki, długość życia zmiennych

Zmienne, które tworzymy nie wiszą w powietrzu, ich długość życia, czyli to, jak długo mamy do nich dostęp jest określony a raczej sami określamy jak długo będą żyć. Nie jest to zabawa w boga, jedynie racjonalne korzystanie z zasobów pamięci. Po prostu chcemy mieć pewność, że zmienna zajmuje pamięć tylko wtedy, gdy jest potrzebna. Gdy jej nie potrzebujemy ta pamięć powinna zostać zwolniona. Zmienne mogą być globalne, czyli takie, które trwają tak długo jak jak długo program jest uruchomiony, deklaruje się je poza jakimkolwiek blokiem; zmienne mogą być lokalne czyli takie, które mają zasięg konkretnego bloku. Blokiem określamy wydzielony obszar programu/algorytmu i opisujemy go za pomocą nawiasów klamrowych { }. Bloki mogą się zagnieżdżać. Zmienne, które są zadeklarowane w bloku żyją tak długo, jak długo program jest w trakcie wykonywania instrukcji z tego bloku i są dostępne w każdym bloku, który jest zagnieżdżony.

// -------------------------------------------------------
{
  int speed = 0;

  speed = 10; 

  {
    int b = 5;
    int speed = 0; // błąd, speed już istnieje w bloku powyżej
    b += speed;
  }
  b = speed; // błąd, b tutaj już nie istnieje
  int b = 10; // wszystko ok, w tym bloku taka nazwa nie występuje

}
// -------------------------------------------------------

Instrukcje warunkowe

Instrukcja warunkowa pozwala na sterowanie wykonywanym programem. Poznałeś/łaś ją już tworząc algorytmy. Instrukcja warunkowa mówi, czy konkretny blok programu ma się wykonać oraz kiedy ma to nastąpić. Ogólna składnia przybiera postać następującą:

if (prawda) {}
else if (prawda) {}
else if (prawda) {}
...
else {}

Można to przeczytać następująco: jeżeli A to zrób TO, w innym przypadku jeżeli B to zrób TAMTO, w innym przypadku jeżeli C to zrób TAMTO, w innym przypadku (bezwarunkowo) zrób TAMTO. Używamy co najmniej jednego warunku po którym otwieramy nowy blok instrukcji, które wykonają się, gdy warunek jest spełniony. Pozostałych warunków możemy nie używać- wszystko zależy od naszych potrzeb.

// -------------------------------------------------------
{
  int speed = 0;
  int gear = 0; // określamy bieg
  speed = 10; 

  if (speed > 0) {
    gear = 1; // zwiększamy bieg bo pojazd się porusza
  }

  speed = 40;

  if (speed > 20 && speed < 30) {
    gear = 2; // jeżeli prędkość jest pomiędzy 20 a 30 to bieg drugi
  }
  else if (speed >= 30 && speed < 40) {
    gear = 3; // trzeci bieg bo prędkość większa od 30, mniejsza od 40
  }
  else {
    gear = 4; // niezależnie jaka prędkość, czwarty bieg
  }

  // tutaj program idzie dalej...

}
// -------------------------------------------------------

To muśnięcie tematu. Zalecam odwołać się do literatury/kursów online, które dogłębnie poruszają te tematy.

W kolejnej, ostatniej części jeszcze ciekawiej!


Dodano: 2018-01-26 04:22 przez Piotr Poźniak

podręcznik , języki programowania , instrukcje , operacje , średnik , bloki , długość życia zmiennych , instrukcje warunkowe , białe znaki , instrukcje warunkowe ,
Piotr Poźniak
O autorze:

Programuję od ponad 15 lat. Prowadzę software house. Angażuję i zachęcam wszystkich do programowania w ramach inicjatywy Programowanie jest łatwe.