Witam i witam ponownie.
Nadal powiem trochę o przepływie kontroli.
Przejdźmy więc od razu do pętli powtarzających kod.
Najpierw porozmawiamy o tym for loop.
Pętla for będzie polegała
na powtarzaniu kodu. Tak więc, dla przypomnienia, powtarzanie
kodu jest sposobem na uniknięcie powielania i
być może w rzeczywistości wykonujesz więcej niż jeden podobny kod na
raz.
Tak więc język programowania c ma pewne konstrukcje zaprojektowane dla
języka, którego możesz użyć, gdy chcesz powtórzyć kod.
A to pozwala ci powtarzać blok instrukcji, dopóki nie zostanie spełniony jakiś warunek.
Jest to więc podobne do pętli for i masz zamiar ocenić
wyrażenie boolowskie, warunek. Nie możesz biec wiecznie.
Kiedy biegniesz w pętli w nieskończoność, oznacza to, że jest to nieskończona pętla.
I są tylko chwile, w których możesz
chcieć to zrobić, zwykle w celu monitorowania lub słuchania czegoś.
Zatem liczba powtórzeń pętli może być kontrolowana po prostu przez konto.
Istnieją 2 rodzaje pętli,
które możesz wykonać, pętla kontroli licznika lub pętla kontrolna wartownika, tak to nazywają.
Pętla sterowania licznikiem oznacza, że pętla
działa 10 razy, 20 razy, 30 razy w określonym czasie.
Powtarza ten sam blok instrukcji wewnątrz pętli
kilka razy.
Możesz mieć inny typ pętli, w którym nie jest kontrolowany przez licznik.
Może działać 5 razy, może działać 100, może chcieć 20,
wszystko zależy od warunku, zmiennej lub czegoś podobnego. Na przykład możesz uruchomić pętlę, która mówi,
że mam zamiar uruchamiać moją pętlę w kółko, aż użytkownik
wejdzie w wyjście.
Więc dopóki zmienna nie zmieni się, aby zakończyć. To nie jest kontrolowane. To nie jest zależne.
Ponownie może działać 10 razy, może działać 100 razy.
To są 2 różne rodzaje pętli. Podam więc przykłady obu, ale
po prostu pomyśl o tym na wysokim poziomie, kiedy chciałbym powtórzyć kod?
Cóż, mogę chcieć powtórzyć kod 5 razy, przez określony czas,
określony czas lub mogę chcieć wprowadzić kod
na podstawie określonego warunku wprowadzonego przez użytkownika, a to się nazywa wartownik.
Nasza pętla for ma słowo kluczowe for. Jest używany do wykonania
określonej liczby razy. Zwykle jest używany do sterowania licznikiem, ale nie musi.
Możesz go użyć do pętli kontrolnej licznika lub jako wartownika do pętli kontrolnej.
To zależy od Ciebie. Ale wiele przykładów w wielu
praktykach jest kontrolowanych przeciwnie, pewną liczbę razy.
Jeśli chcesz na przykład wyświetlić liczby od 1 do 10, użyj pętli for.
Nie chciałbyś napisać 10 linii kodu
z tą samą instrukcją printf wyświetlającą inną liczbę.
To bardzo nieefektywne. To bardzo czasochłonne.
Do powtórzenia kodu użyłbyś pętli for.
To, co byś zrobił, to zrobiłbyś coś takiego.
Oto wprowadzenie do tego, jak wygląda
pętla for, składnia.
Masz słowo kluczowe for, a następnie masz te nawiasy.
Ponownie, nawiasy identyfikują różne rzeczy, które mają miejsce w
pętli for.
Następnie masz nawias i instrukcje wewnątrz nawiasów.
Zatem znowu nawiasy kwadratowe reprezentują treść
pętli, podobnie jak nawiasy reprezentujące treść instrukcji if.
Jeśli masz tam jedno stwierdzenie, nie potrzebujesz nawiasów, ale dobra
praktyka, aby zawsze ich używać.
Więc w tym przykładzie widzisz słowo kluczowe „for”, które powinno być pierwszą rzeczą, którą zidentyfikujesz.
Operacja, czas jej trwania jest kontrolowana i to, co pojawia się w
nawiasach po słowie kluczowym for, które omówimy szczegółowo.
Są tam w zasadzie 3 różne wyrażenia.
Możesz je rozpoznać, ponieważ są oddzielone średnikiem.
Tak więc średnik mówi, że jest to instrukcja wyrażenia.
Więc co robią te 3 rzeczy, opiszemy.
Czynność, którą chcesz powtórzyć,
znajduje się w treści pętli, to dzieje się tak wiele razy.
W tym przykładzie treść pętli to printf.
Więc jeśli warunek zostanie oceniony jako prawdziwy, będzie on nadal wyświetlał tę liczbę.
I znowu, w przypadku pojedynczych instrukcji możesz pominąć nawiasy klamrowe.
Więc omówmy to szczegółowo.
ogólny wzorzec pętli for jest taki, że masz tego typu instrukcję.
Masz for, a następnie masz warunek początkowy, to jest pseudokod.
Próbuję tutaj opisać pętlę for.
Więc warunek początkowy jest pierwszą rzeczą, wszystko przed pierwszym średnikiem.
Drugą rzeczą jest warunek kontynuacji ze
średnikiem na końcu, a ostatnią rzeczą między nawiasami jest akcja na iterację.
I chcę opisać każdy z nich. Następnie wewnątrz ciała znajduje się instrukcja pętli.
Instrukcja pętli jest całkiem prosta. To jest tylko w ciele.
To kod, który ma zostać wykonany i który jest powtarzany za każdym razem.
To całkiem proste.
I znowu, możesz albo złamać nawiasy klamrowe, jeśli masz wiele instrukcji, albo
pominąć nawiasy, jeśli masz jedną instrukcję.
Warunkiem początkowym jest to, że pierwsza
rzecz w nawiasach przed pierwszym średnikiem to zwykle,
ale nie zawsze, inicjalizacja zmiennej, zwanej zmienną sterującą pętli.
To jest ta zmienna, której zaczniesz przyglądać się każdej iteracji.
Więc zmienna sterująca pętlą jest zwykle licznikiem
czasu, nie zawsze, ponownie, chcę podkreślić,
że nie musi. Ale wiele razy w pętli
for jest licznikiem i śledzi, jak często pętla była powtarzana.
To właśnie robi ten warunek początkowy i zmienna sterująca pętli.
Możesz tu również zadeklarować i zainicjować kilka zmiennych tego samego
typu z deklaracją oddzieloną przecinkami. Możesz więc mieć wiele inicjalizacji tutaj
zmiennych.
Teraz, w zależności od używanego kompilatora c,
możesz nie być w stanie zadeklarować tych zmiennych w instrukcji for.
Jeśli używasz czegokolwiek poniżej kompilatora C99, musisz zadeklarować zmienne
poza instrukcją for, a następnie zainicjować je w tym miejscu, w którym
mówi warunek początkowy, ale
przejdziemy przez niektóre z tych przykładów.
Ale warunkiem początkowym jest miejsce, w którym inicjalizujesz zmienne.
Jest to zmienna kontrolna pętli i została nazwana z tego powodu, ponieważ
kontroluje, jak często pętla będzie wykonywana po jej zainicjowaniu.
Następną rzeczą, o której chcę porozmawiać, jest warunek kontynuacji, warunek kontynuacji, część
znajdująca się przed pierwszym średnikiem w pętli for.
To jest logiczne wyrażenie.
To jest warunek, który zostanie oceniony jako prawdziwy lub fałszywy.
Dzieje się tak, gdy zamierzasz wskoczyć w pętlę lub wyjść z pętli.
To określa, czy pętla powinna być nadal wykonywana.
Dopóki warunek ten ma wartość true, pętla jest wykonywana,
wszystkie instrukcje w treści będą wykonywane.
Spowoduje to zazwyczaj sprawdzenie wartości zmiennej sterującej pętli.
Więc inicjalizujesz zmienną sterującą pętli w warunku początkowym,
a następnie patrzysz na warunek kontynuacji.
Możesz umieścić tutaj dowolną logikę lub dowolne wyrażenie arytmetyczne, o ile wiesz, co robisz.
Warunek kontynuacji jest testowany na początku pętli, a nie na końcu.
Nazywa się to pętlą przed testem.
Zauważysz różnicę, gdy mówimy o pętli do-while, która jest pętlą po teście.
Ale oznacza to, że instrukcja pętli może zostać wykonana raz, może
zostać wykonana 0 razy.
Wszystko zależy od tego, czy warunek kontynuacji jest prawdziwy, czy fałszywy.
Jeśli oszacuje jako fałsz, nigdy nie wykonasz ciała.
Jeśli zwróci wartość true, wykonasz to ciało co najmniej raz.
Akcja na iterację, która znajduje się na samym końcu pętli for po
drugim średniku, zwykle powoduje jakąś modyfikację zmiennej sterującej pętli.
Zwiększy lub zmniejszy go, jeśli jest to licznik
pętli lub jeśli jest to pętla wartownicza, może poprosić użytkownika o wprowadzenie większej ilości danych wejściowych.
Możesz także wykonać więcej niż jedną modyfikację zmiennej.
Możesz modyfikować zmienną sterującą pętli, a także możesz modyfikować inne zmienne.
Wystarczy oddzielić je przecinkami.
Ale podsumowując wszystko,
co powiedziałem, mamy małą tabelkę, która to opisuje.
Ale zanim o tym porozmawiamy, spójrzmy na mały przykład.
Oto przykład. Mamy słowo kluczowe for.
A potem zauważysz, że mamy int I równa się 1 j równa się
2, to jest miejsce, w którym inicjalizujemy zmienne.
W rzeczywistości inicjalizujemy tutaj 2 zmienne oddzielone przecinkami,
zazwyczaj w pętli for, zwykle tylko jedną, zmienną kontrolną pętli.
Ale w tym przypadku inicjalizujemy I i j.
Po tym średniku mamy warunek.
Kiedy wejdziemy i kiedy wyjdziemy z tej pętli.
Wejdziemy tak długo, jak długo będę miał mniej niż 5.
To jest nasze wyrażenie boolowskie, które daje wartość prawda lub fałsz.
A potem po drugim
średniku zmodyfikujemy tę zmienną kontrolną pętli lub inne zmienne, których dotyczyła.
Tutaj robimy plus, plus ja, to jest
operator inkrementacji, przedrostek I. A potem przypisujemy j równe j plus 2.
Zwykle będzie to twój warunek x, modyfikujący
zmienną sterującą pętli.
A potem treść pętli ma tylko jedną instrukcję, więc nie potrzebujemy nawiasów.
Po prostu wypisujemy wartości I razy j.
Zatem dane wyjściowe wygenerowane przez ten kod
będą miały wartości 2, 8, 18, 32 i 50 w jednym wierszu.
Pierwsza iteracja pętli, I będzie równa 1, j będzie równa 2.
Więc powie I razy j, czyli 1 razy 2 i wyświetli to.
Będzie sprawdzać, czy nie mam więcej niż 5, a nie jest to 1.
Więc wróci i wykona po raz drugi.
Modyfikujemy również tę zmienną I w naszym ostatnim stwierdzeniu.
Więc w drugiej iteracji pętli będę równy 2.
A j będzie równe 2 dodać 2, co daje 4.
Więc teraz pomnożymy 2 razy 4, czyli 8
i wyświetlimy to, a następnie sprawdzimy, czy ja
jestem większy niż 5? Nie, nadal mam 2 lata.
Więc modyfikujemy I, aby teraz było równe 3 dla
następnej iteracji, i modyfikujemy j, aby było równe 4 dodać
2, czyli 6.
A następnie dla trzeciej
iteracji pętli mnożymy I razy J. Mówimy więc 3 razy 6 i wyświetlamy 18.
Zanim wykonamy czwartą iterację, sprawdzamy, czy I jest większe niż 5.
Nie, to jest 4. Następnie zwiększamy ją, mówimy, że jest to 5. Jest równa 5, więc nadal będzie działać.
Wtedy zrobimy 32, a potem 50.
Więc to jest oświadczenie. Chcesz to uruchomić i wykonać w
przeglądarce kodu, bawić się i zmieniać rzeczy.
Ale to, co tutaj robimy, polega na tym, że robimy 3 oddzielne rzeczy w jednym wierszu kodu.
Inicjalizujemy zmienną sterującą pętli lub dowolną inną zmienną.
Nasze wyrażenie logiczne mamy po pierwszym średniku, naszym warunku wyjścia.
Następnie modyfikujemy zmienną kontrolną pętli i wszelkie inne zmienne, które chcemy,
aby były ostatnią częścią instrukcji for.
Podsumowując to, co robimy, znalazłem ten ładny, mały, poręczny wykres
z książki i chciałem ci pokazać. To podsumowuje wszystko.
Ten pierwszy średnik inicjuje zmienną sterującą pętli.
Po pierwszym średniku wykonujemy nasz warunek, nasze wyrażenie boolowskie.
A potem po drugim
średniku modyfikujemy tę zmienną sterującą pętli. I to jest typowy przykład, jaki widzisz.
Jest to pętla sterowania licznikiem, która zaczyna się od 1 i przechodzi do 10.
Więc to faktycznie zostanie wykonane 10 razy.
Klucz jest mniejszy niż 10. Więc zobaczycie operatory relacyjne jako nasze warunki, tak
jak widzieliśmy operatory relacyjne jako nasze warunki w naszym wyrażeniu if.
Kluczem tutaj jest to, że chcesz zmodyfikować tę zmienną sterującą pętli lub nigdy nie zamierzasz wyjść.
Więc liczba plus plus jest bardzo ważna.
A jeśli chodzi o inkrementację przed lub po, niezależnie od tego, czy ten plus jest przed
zmienną, czy
po zmiennej, nie musisz się tym martwić,
ponieważ będzie on zwiększany lub zmniejszany dopiero po iteracji pętli, więc tak się nie dzieje. Nie
ma znaczenia, czy zrobisz plus plus liczyć czy liczyć plus plus.
I znowu, w zależności od wersji c, którą uruchamiasz dla
swojego kompilatora, możesz być
w stanie zadeklarować liczbę zmiennej wewnątrz pętli for lub możesz powiedzieć, że
int count równa się 1 lub in count poza pętlą for i następnie zainicjuj go pierwszym średnikiem.
C99 dodał inicjalizację i deklarację w tej samej
części pętli for.
Ale w zasadzie tak działa pętla for.
Przejdźmy teraz do małego przykładu, chcę pokazać elastyczność pętli for.
Oto przykład, w którym zamierzamy po prostu zsumować kilka liczb całkowitych.
W tym przykładzie poprosimy użytkownika o podanie liczby liczb całkowitych, które chcą zsumować.
Zamierzamy przechowywać to w zmiennej o nazwie count.
Będziemy teraz mieć pętlę for, która przechodzi przez wszystkie te
elementy w zależności od liczby, którą wprowadzili, i iteruje przez to wiele razy.
Więc tutaj mówimy 4, mamy unsigned int, nie musi być unsigned for
int I równa się 1. Inicjalizujemy zmienną sterującą pętli.
A potem mówimy, że jeśli ja jest mniej niż liczyć, to wtedy wyjdziemy,
a potem zmodyfikujemy materiał pętli plus plus I.
Więc to będzie działać. Ponownie
1 oznacza liczbę wprowadzoną przez użytkownika, 10 lub 20.
A wszystko, co zamierzamy zrobić, to powiedzieć, że suma równa się sumie plus 1.
Teraz pętla for jest tak potężna, ponieważ pętla for
umożliwia modyfikowanie wielu zmiennych.
Nie musimy nawet umieszczać tej sumy plus równe I w treści pętli for.
Możemy to umieścić na końcu ostatniej wypowiedzi.
Więc oprócz zwiększenia I o 1, możemy po prostu powiedzieć, że suma plus równa się I plus plus.
Zrobiliśmy więc wszystko w jednym wierszu
kodu, co pokazuje elastyczność. to wszystko dlatego, że możemy
zmodyfikować zmienną w samej instrukcji for. Nie musimy mieć takiej linii ciała.
Spójrzmy więc na ten przykład w blokach kodu, aby
pokazać, jak można nim manipulować i zobaczyć, jakie jest wyjście.
Oto nasz przykład, który mieliśmy na wykładzie. Chcę iść dalej i spróbować to skompilować.
A kiedy to skompiluję, zauważysz, że mam błąd.
Mówi, że nie mogę zadeklarować mojej zmiennej w instrukcji for. Dzieje się tak, ponieważ używam starszej
wersji kompilatora c. Używam C89.
Prawdopodobnie tego nie będziesz mieć.
Ale jeśli kiedykolwiek zobaczysz tego typu błąd, aby rozwiązać ten problem,
musisz go tylko rozszyfrować poza pętlą for. Więc po prostu powiedz: ja bez podpisu.
Następnie wewnątrz pętli for inicjalizujesz ją,
coś w tym rodzaju. Teraz spróbujmy zbudować i
po prostu muszę pozbyć się niektórych z tych specyfikatorów formatu.
Więc kiedy pomyślnie skompiluję i
uruchomię ten program, zobaczysz, jak działa pętla.
Poprosi mnie o wprowadzenie liczb całkowitych, które chcę zsumować. Jeśli wpiszę 5, zsumuje
1 2 3 4 i 5, czyli 15.
To, co moglibyśmy zrobić, aby to debugować, to dodać nawias do pętli for i
moglibyśmy chcieć po prostu zobaczyć, ile razy działa, możemy dodać instrukcję print niekoniecznie
aby ją debugować, ale po prostu zobaczyć, co się dzieje , możemy powiedzieć, że pętla wewnętrzna.
A to powie nam, że pętla działa 5
razy, ponieważ będzie działać I liczyć.
Chcę więc pokazać, ile razy to działa. Więc teraz, kiedy go
zbuduję i uruchomię, zobaczę, co się dzieje w każdej iteracji.
Więc zamierzam powiedzieć 8.
Pętla wewnętrzna, pętla wewnętrzna, pętla wewnętrzna, nie dodałem wysuwu linii. Trudno to więc czytać, ale
pętla wewnętrzna jest wyświetlana 8 razy.
Następnie sumuję każdą z tych liczb wewnątrz pętli, więc odpowiedź to 36,
1 dodać 2 dodać 3 dodać 4 dodać 5 dodać 6 dodać 7 dodać 8.
Więc możesz się tym bawić. Ale znowu inicjalizujemy
naszą zmienną sterującą pętli. Sprawdzamy warunek wyjścia. Zamierzamy wyjść, gdy trafimy na
to, co wprowadził użytkownik. Jeśli użytkownik wprowadził 8, będziemy
uruchamiać 8 razy, a następnie musimy zmodyfikować I. Gdybyśmy nie zmodyfikowali I tutaj, miałbyś wieczną pętlę.
A co by się stało, gdybyś uruchomił
program, działałby wiecznie.
Więc zobaczysz, że po wpisaniu numeru Twój program nigdy się nie zakończy.
Powiedzmy, że wpisujemy 6, wciskam Enter, spójrz, co się dzieje, po
prostu wypisuję pętlę w środku. Nigdy nie wychodzi.
To nieskończona pętla. Więc ta ostatnia rzecz jest bardzo, bardzo ważna. Zawsze chcesz zmodyfikować zmienną sterującą pętli.
I znowu zmienna sterująca pętlą określa wyjście, w tym przypadku I.
Więc pętla for jest używana dość często.
Jest bardzo łatwy w użyciu i pozwala na wykonanie 3 różnych czynności wewnątrz pętli.
Zainicjuj zmienną sterującą pętli, sprawdź sterowanie
zmienną pętli pod kątem warunku wyjścia, a następnie
zmodyfikuj zmienną sterującą pętli.
To są 3 rzeczy, które musisz zrobić w pętli i możesz zrobić w jednej instrukcji.
Pozwólcie mi teraz porozmawiać naprawdę szybko o nieskończonej pętli.
Więc właśnie zademonstrowałem nieskończoną pętlę. To jest miejsce, w którym nigdy nie wychodzisz.
Nie masz obowiązku umieszczania żadnych parametrów w instrukcji pętli for.
Właściwie możesz celowo napisać nieskończoną pętlę.
Sposób, w jaki to zrobisz, polega na umieszczeniu tam średników.
Więc miałbyś pętlę for z 2 średnikami.
Jeśli kiedykolwiek to zobaczysz, oznacza to, że piszesz nieskończoną pętlę.
Teraz zazwyczaj nie chcesz mieć nieskończonych
pętli, ale czasami zdarza się, że nie ma warunku kontynuowania pętli.
Pętla będzie trwała w nieskończoność. Jest to czasami przydatne, jeśli monitorujesz dane.
Więc jeśli monitorujesz dane, możesz coś tam mieć.
Zwykle, gdy masz pętlę wieczną, zwykle masz również
tryb uśpienia, który wstrzymuje wykonywanie programu, może na sekundę, więc coś monitorujesz.
Innym przypadkiem użycia, w którym możesz mieć nieskończoną pętlę, jest nasłuchiwanie połączenia.
Więc jeśli czekasz i nasłuchujesz połączenia lub jeśli coś ciągniesz, aby coś
zobaczyć, możesz to zrobić.
Niektórzy ludzie twierdzą, że nigdy nie należy ciągnąć i nigdy nie
słuchać, ale to kolejny argument.
To naprawdę jedyny przypadek dla niektórych pętli, które są nieskończone.
Unikaj nieskończonych pętli tak bardzo, jak to możliwe, modyfikując tę zmienną sterującą pętli.
Mam nadzieję, że to było pomocne. To jest pętla for.
Wykorzystamy pętlę for w jednym z naszych wyzwań, dzięki czemu będziemy bardziej zaznajomieni.
Dziękuję Ci.