Metody6time_paradoxPętle w programowaniu są powszechne, gdyż wykonywanie jakiejś czynności X razy z innymi parametrami jest na porządku dziennym.

Oczywiście zmorą każdego początkującego programisty jest fakt ,że pętle muszą się kiedyś skończyć.

Jednak nie ma w nich nic strasznego, jeśli się pamięta o paru podstawowych rzeczach.

Pętla While

Pętla while powtarza blok kodu tak długo ,aż warunek jest prawidłowy. Składnia pętli while jest następująca.

while (warunekbool)
{  
    operacje  
}
Warunek bool tak długo, jak będzie prawdziwy to tak długo pętla while będzie się wykonywała. Warunek ten jest sprawdzany z każdym wykonaniem tego bloku kodu. Pętla się przerwie, gdy warunek bool będzie równy false.

Jeśli warunek bool jest false na start pętla nie wykona nawet pierwszej iteracji.

Jak zapewne zdałeś sobie sprawę trzeba bardzo uważać by pętla była skończona, czyli trzeba w jakiś sposób zmienić warunek bool w bloku, gdzie wykonuje się pętla.
int i = 0;
while (i < 5)
{
    Console.WriteLine(i++);
}
Pętle while są przydatne ,a raczej były przydatne do odczytywania plików. Teraz istnieją gotowe metody, które czytają całą zawartość pliku od razu. Jednak wciąż stosowane są przy algorytmach.

Pętla For

Pętla For jest jedną z najczęściej spotykanych pętli w C# . Jest ona stworzona do operacji iteracyjnych z określoną ilością , a ponieważ aby jej użyć trzeba (powiedzmy) zadeklarować zmienną pomocniczą, liczącą iteracje, to na pewno o niej nie zapomnisz.

Ciało pętli for wygląda następująco. Każdy element pętli for w nawiasie musi być odseparowany średnikiem.

for (inicjalizacja zmiennej; warunek logiczny; 
zaktualizowanie zmiennej)
{   
                //blok kodu 
}

Oto pętla for, która robi dokładnie to samo, co pierwszy przykład pętli while.

for (int i = 0; i < 5; i++)
{  
    Console.WriteLine(i);      
}
Zmienna “i” jest inicjalizowana na początku pętli. Przy pierwszym wykonaniu jest sprawdzany warunek. Po każdym wykonaniu bloku kodu zmienna jest poddana aktualizacji (w tym wypadku zwiększona o 1) po czym ponownie jest sprawdzany warunek ,jeśli jest on zgodny to pętla wykonuje się dalej.
 

błąd tak nie można w pętli for
Aktualizowanie zmiennej może nastąpić poprzez inkrementacje lub dekrementację oraz poprzez wyrażenia, które zwiększają daną liczbę o samą siebie. Obrazek powyżej reprezentuje moją próbę napisania pętli for, która zwiększałaby liczbę o wartość 3. Jak widać o czymś ważnym zapomniałem ,a dokładniej mówiąc o znaku równa się.

Prawidłowe zapis pętli w inny sposób niż inkrementacja i dekrementacja jest następujący.

for (int j = 21; j >= 7 ; j = j  - 3)
{
    Console.WriteLine(j);//21,18,15,12,9 
}
Dla ułatwienia możemy posłużyć się innymi skrótami językowymi w C#. Nie martw się opiszę je jeszcze w tym wpisie. Kod poniżej robi dokładnie to samo co powyżej.
 
for (int j = 21; j >= 7 ; j -= 3)
{
    Console.WriteLine(j);//21,18,15,12,9 
}
Nie musimy koniecznie operować w każdej iteracji na typie int. Oto przykład pętli z zastosowany typem decimal.
 
for (decimal i = 0.7m; i <= 1; i = i + 0.1m)   
{
    Console.WriteLine(i); //0.7,0.8,0.9,1.0 
}
Jedna nie jest to zalecane, ponieważ operację ułamkowe w C# w zależność o typu mogą wykazać się dziwnym zachowaniem. Zwłaszcza kiedy inkrementuje się wartość o1/3. Diabeł
 
for (float i = -0; i <= 1; i = i + 0.1f)   
{
    Console.WriteLine(i); 
    //...0.7,0.8,0.9,1.0 spodziewany rezultat 
}

for (float i = -2.5f; i <= 1; i = i + (1f / 3f))
{
    Console.ForegroundColor = ConsoleColor.Yellow;
    Console.WriteLine(i); 
}

Console.ReadKey();
Rezultat kodu. Żółty kolor podkreśla drugą pętle.
 
image
 
Wyraźnie widać, że w pierwszej pętli pod koniec mamy dziwne resztki. Natomiast w drugiej pętli po wartość –1,5 wyrażenia matematyczne zaczynają się rozwalać.
 
Dlatego lepiej trzymać się stałych liczb w pętli.
 
Pętla for może być stworzona nawet w okrojony sposób np. nie musi ona zawierać zmiennej inicjalizującej i fragmentu, który by tą zmienną zaktualizował. Taka pętla wygląda jak dziwna wersja pętli while.
int i = 0;
for (;i < 5;)
{   
    Console.WriteLine(i++);
}

W pętli for bez problemu możemy zawrzeć kolejną pętle for. Trzeba tylko pamiętać by nasz zmienna pomocnicza była inna niż w pierwszej pętli.

for (int i = 0; i < 2; i++)
{
    for (int j = 9; j >= 7 ; j--)
    {
        Console.WriteLine(i + j);//9,8,7,10,9,8     }
}

Jeśli zaistnieje taka potrzeba można w pętli for zainicjalizować wiele zmiennych, ale wyrażenie warunkowe bool będzie zawsze jedno ,ale może być ono złożone z nawiasami. Nie zobaczysz często takich zapisów w programowaniu zresztą na pierwszy rzut oka nawet ja nie bardzo wiedziałem co się dzieje w takim losowym kodzie, który napisałem.

for (int i = 0, j = -10, k = 1; i > (j + k); i--, j++, k++)
{
    Console.WriteLine(" i = " + i.ToString() + " j = 
    " + j.ToString() + " k = " + k.ToString());
}
 

Rezultat pętli for
Pierwsza iteracja: 0 > (-10 + 1)

Druga iteracja: -1 > (-9 +2)

Trzecia iteracja: –2 > (-8 + 3)

Czwarta iteracja: –3 > ( –7 + 4) || warunek niespełniony przerwanie pętli.

Tak jak w przypadków if i else zmienne zadeklarowane w pętli for jak “i’,”j”,”k” istnieją tylko w tym bloku kodu i nie są dostępne poza nimi. Zmienne zadeklarowane w pętli nie mogą być zadeklarowane wcześniej w kodzie.

Pętla “Do While”

Pętle for i while sprawdzają swój warunek na początku pętli. Są jednak algorytmy, które wymagają aby kod w pętli wykonał się na początku i chociaż raz, bądź warunek jest sprawdzany zaraz po wykonaniu pierwszej iteracji .

W pętli for bądź while, jeśli warunek logiczny ma wartość false pętla nie wykona się ani razu.

Do tego właśnie celu mamy pętle “do while” co w bezpośrednim tłumaczeniu brzmi “zrób to dopóki” trafnie opisując działanie pętli.

int b = 0;
do{
    b += 2;
    Console.WriteLine(b);
} 
while (b < 9);

Skróty Arytmetyczne

Tajemniczy zapis b+=2 zwiększa zmienną b co 2 ,jest to skrócony zapis b = b + 2;

Przy okazji umieszczę tutaj tabelkę związaną z tymi skrótowymi zapisami, ponieważ najwyraźniej zapomniałem wspomnieć o tym w poprzednich rozdziałach. A to może być pomocne przy pętlach.

Normalny zapisSkrócony zapis
b = b +2;b += 2;
b = b / 2;b /= 2;
b = b % 2;b %=2;
b = b –2;b –=2;
b = b * 2;b *= 2;

 

Continue i Break

Czy istnieje jakiś inny sposób przerwania pętli? Oczywiście ,że tak.

Break jak dobrze pamiętasz z “zeskakiwała” z konstrukcji      switch. Tak samo jest z pętlami, kiedy blok kodu pętli napotka słowo kluczowe break pętla jest natychmiast przerywana i wykonuje się następne wyrażenie, które jest już po pętli.

Natomiast Continue     zatrzymuje daną iteracje i zmusza program do przejścia do następnej. Oto fragment kodu, który rzuci więcej światła na te słowa kluczowe.

int b = 0;
do{
    b += 2;
    if (b == 12)
        break;
    else if ((b == 4) || (b == 10))
        continue;
                
    Console.WriteLine(b);
} while (true); //2,6,8

Jak widzisz pętla zastanie przerwana gdy zmienna “b” dojdzie do 12 dzięki słowu kluczowemubreak. Natomiast liczby 4 i 10 nie zostaną wyświetlone w konsoli, ponieważ słowo kluczowe continue przerwało daną iteracje, więc kod “Console.WriteLine” się nie wykonał.

Debugowanie kodu i śledzenie działania pętli

Powinien coś wspomnieć o możliwości śledzenia kodu w Visual Studio 2010. Na ślepo nie będziesz śledził pętli.

Pamiętaj jak w czasach pisania algorytmów w “turbo pascalu” rozpisywałem sortowania i grafy na kartce papieru.Zmieszanie

Więcej o tym, jak Visual Studio może pomóc w śledzeniu kodu w tym wpisie.

Tyle o pętlach

W C# została do poznania tylko jedna pętla foreach, ale do zrozumienia jak ona działa najpierw musiałbym powiedzieć coś o kolekcjach, dlatego na razie o tym nie myśl i przygotuj się na przedostatni wpis z podstaw C# mówiący o błędach i wyjątkach.