Skocz do zawartości

  • Zaloguj korzystając z Facebooka Zaloguj korzystając z Twittera Zaloguj przez Steam Zaloguj poprzez Google      Logowanie »   
  • Rejestracja

Witamy w Nieoficjalnym polskim support'cie AMX Mod X

Witamy w Nieoficjalnym polskim support'cie AMX Mod X, jak w większości społeczności internetowych musisz się zarejestrować aby móc odpowiadać lub zakładać nowe tematy, ale nie bój się to jest prosty proces w którym wymagamy minimalnych informacji.

  • Rozpoczynaj nowe tematy i odpowiedaj na inne
  • Zapisz się do tematów i for, aby otrzymywać automatyczne uaktualnienia
  • Dodawaj wydarzenia do kalendarza społecznościowego
  • Stwórz swój własny profil i zdobywaj nowych znajomych
  • Zdobywaj nowe doświadczenia

Dołączona grafika Dołączona grafika

Guest Message by DevFuse
 

Zdjęcie

Introduction to SourcePawn


  • Nie możesz napisać tematu
  • Zaloguj się, aby dodać odpowiedź
1 odpowiedź w tym temacie

#1 MAGNET

    SourceLearned ;)

  • Moderator

Reputacja: 625
Wszechmogący

  • Postów:1510
  • GG:
  • Imię:Olek
  • Lokalizacja:Dalekoo
Offline

Napisano 29.10.2015 16:25

SourcePawn 1.7 – podstawy programowania
Poradnik ten jest zaprojektowany aby pokazać i nauczyć Was kilku podstawowych fundamentów programowania w SourcePawn’ie. Pawn(https://wiki.alliedmods.net/Pawn) jest to język programowania stosowany do ‘osadzania’ funkcji w innych programach. To znaczy, że nie jest to niezależny język jak C++ czy Java i jego dane będą różnić się od zastosowania/aplikacji. SourcePawn jest to wersja Pawn’a używana w SM.
Note: Jeśli jesteś osobą zaczynającą przygodę z programowaniem i nadal nie pojmujesz istoty programowania w SourcePawn’ie, spróbuj poczytać książki uczące programowania jak PHP, Python czy Java, aby zdobyć większa wiedzę na temat programowania.
 
Wprowadzenie dla początkujących
 
Symbole/Słowa klucze
Symbol czy też słowo klucz jest to seria liter, liczb i/lub podkreśleń, który jednoznacznie coś reprezentuje. W symbolach i słowach kluczach rozróżniana jest wielkość liter i zazwyczaj zaczynają się one z małej.
Jest kilka zarezerwowanych słów kluczy, które mają specjalne znaczenie np. if, for, and return. Są to specjalne konstrukcje w języku, które wytłumaczymy później. Pamiętaj, że nie mogą być one użyte jako symbole!

 
Zmienne
 
Jest kilka ważnych konstrukcji, który powinieneś znać zanim zaczniesz programować. Pierwsza z nich jest to zmienna. Zmienna jest to symbol, który przechowuje jakąś daną np. zmienna „z” może przechować liczby 2, 16, 0, etc. Skoro zmienna przechowuje dane, również lokuję w niej pamięć potrzebnej do przechowywania tych danych.
Oprócz nazwy, zmienne mają również swój typ. Typ mówi programowi jak interpretować dane i ile pamięci ta dana użyję. Pawn ma 3 typy danych, które są powszechnie używane:

·          Integers (liczby całkowite) typu int. Zmienne te mogą przechowywać liczby całkowite z przedziału od -2147483648 do 2147483647
·          Floats (liczby zmiennoprzecinkowe) typu float. Zmienne te mogą przechowywać liczby ułamkowe w ogromnym zakresie, choć nie są one tak dokładne jak Integers’y
·          Characters (znaki) typu char. Zmienne te przechowują jeden bajt informacji znaków, zwykle znaki ASCII (http://www.asciitable.com/)
·          Booleans (wartości logiczne) typu bool. Zmienne te przechowują albo wartość true albo false.
Przykłady tworzenia zmiennych i przypisywania im wartości:


int Money = 5400;
float percent = 67.3;
bool enabled = false;

 
Funkcje
 
Następną ważnym pojęciem są funkcje. Funkcja jest to fragment programu, któremu nadano nazwę, i który możemy wykonać poprzez podanie jego nazwy oraz ewentualnych argumentów/parametrów (o ile istnieją). Po ich wywołaniu, wykonują określoną sekwencję kodu, a następnie zwrócą wynik. Jest kilka rodzajów funkcji, ale każda funkcja jest aktywowana w ten sam sposób np.:

show(56);                                                // Wywoła funkcję „show” i da nam liczbę 56
enable();                                                   // Wywoła funkcję „enable” bez żadnych wartości
bool visible = show(a);                   // Wywoła funkcję „show”, przechowując wartość w zmiennej

Każdy kawałek danych przesyłanych do funkcji nosi nazwę argumentu / parametru. Argumenty wytłumaczymy w dalszej części poradnika.
Komentarze
Każdy tekst napisany po „//” jest nazywany „komentarzem” i nie jest on kodem. Jest on najczęściej używany do podpisywania jakiś zmiennych, funkcji, podania ich sposobu działania etc. Przykład użycia chociażby jest podany wyżej w „Funkcjach”. Są dwa rodzaje komentarzy:
·          // - wszystko w tej samej linii za tymi znakami jest ignorowane
·          /*  */ - Multi-liniowy komentarz, wszystko między gwiazdkami jest ignorowane
„Blokowe” kodowanie
Następnym pojęciem jest „blokowe” kodowanie (z ang. block coding). Możesz pogrupować swój kod w „bloki” oddzielone przez { i } przez co kod ….
Paradygmaty języka

 
Zmienne
Pawn obecnie używa następujący typów zmiennych:
·          bool ­– true (prawda) albo false (fałsz)
·          char –  ciąg znaków
·          int – liczba całkowita
·          float –liczba zmiennoprzecinkowa
·          Handle – podstawowy typ obiektu SM
Other types may exist when defined in include files - for example, enums create new types for named integers, and many types derive from Handle.
Strings, currently, are 0-terminated arrays of chars. They're described a little further ahead.

 
Deklaracja
 
Niżej podamy kilka przykładów zadeklarowanych zmiennych, zarówno poprawnych jak i błędych.


int a = 5;
float b = 5.0;
bool c = true;
bool d = false:
Błedne użycie zmiennej:
int a = 5.0;                                             // Błąd „Type mismatch”. 5.0 jest to liczba zmiennoprzecinkowa
float b = 5;                                             // Błąd „Type mismatch”. 5 jest liczbą całkowitą

 
Jeżeli podczas deklaracji zmiennej nie jest przypisana jej wartość, to domyślnie jej wartość będzie wynosić 0 np.:

int a;            // a = 0
float b;       // b = 0.0
bool c;        // c = false

 
Inicjacja
 
Zmiennym można przypisać wartość również po ich utworzeniu np.:

int a;
float b;
bool c;
a = 5;
b = 5.0;
c = true;

 
Tablice
 
Tablica jest to uporządkowany zbiór danych. Tablic używamy wtedy kiedy chcemy przechować wieloczęściowe dane w jednej zmiennej.
Deklaracja
Tablica jest deklarowana poprzez użycie nawiasów (tych kwadratowych) czyli [ ]. Kilka przykładów:

int players[32];            // Dla players tworzy 32-tu elementową tablicę danych typu int
float origin[3];              // Dla origin tworzy 3 elementową tablicę danych typu float
Domyślnie każdy element tablicy ma wartość 0. Można jednak przypisać im różne wartości domyślne:
int numbers[5] = {1, 2, 3, 4, 5};                      // Przechowuje odpowiednio wartości 1, 2, 3, 4, 5.
float origin[3] = {1.0, 2.0, 3.0};                        // Przechowuje odpowiednio wartości 1.0, 2.0, 3.0.

Możesz również pominąć rozmiar tablicy, jeżeli przypiszesz do niej dane:


int numbers[] = {1, 3, 5, 7, 9};

Kompilator automatycznie wywnioskuje, że tablica ma rozmiar 5.
Kiedy tablica jest zadeklarowana z nawiasami kwadratowymi, Pawn interpretuje to tak, że zmienna ma określony rozmiar. Określony rozmiar tablicy jest zawsze znany. Niektórym tablicom rozmiar może zostać nadany dynamicznie poprzez zastosowanie nawiasów kwadratowych. Na przykład:


int[] numbers = new int[MaxClients]

 
Ta deklaracja tworzy zmienną o rozmiarze wartości MaxClients, która może być czymkolwiek. Rozmiar tablicy nie jest więc znany do czasu gdy zmienna MaxClients nie zostanie zadeklarowana

 

Z kolei taki zapis:

 

int tab[32] = {69, ...};

 

ustawi we wszystkich komórkach tablicy wartość 69
 
Użycie
Tablic używa się tak samo jak zwykłych zmiennych. Jedyną różnicą jest to, że tablica musi być zaindeksowana. Indeksowanie tablic oznacza wybranie jednego elementu, którego masz zamiar uzyć.
Dla przykładu kod używającego tablic i ich indeksowania:

int number[5];
float origin[3];

numbers[0] = 1;
numbers[1] = 2;
numbers[2] = 3;
numbers[3] = 4;
numbers[4] = 5;
origin[0] = 1.0;
origin[1] = 2.0;
origin[2] = 3.0;

Note: Indeksowanie zawsze zaczyna się od 0. Jeżeli jakaś tablica posiada N elementów to prawidłowe indeksy są od 0 do N-1.
Użycie niepoprawnego indeksu spowoduję błąd w kompilacji czyli error np.:


int numbers[5];

numbers[5] = 20;

Może to wyglądać poprawnie, ale 5 jest nie jest poprawnym indeksem tej tablicy. Najwyższym indeksem jest 4.
Możesz użyć dowolnego wyrażenia jako indeksu np.:


int a, number[5];

a = 1;                                                          // Ustawia zmiennej „a” wartość 1
numbers[a] = 4;                                  // Ustawia indeksowi 1 (bo a = 1) i elementowi drugiemu (bo indeks 1 to drugi element tablicy) wartość 4
numbers[numbers[a]] = 2;           // Ustawia indeksowi 4 (bo numbers[a] = 4) i elementowi piątemu (bo indeks 4 to piąty element tablicy) wartość 2

 
Ciąg znaków (Strings)
 
(Będę tutaj używał angielskiej jak i polskiej nazwy)
String’i są to konstrukcje do przechowywania tekstu. String jest to po prostu tablica znaków, z wyjątkiem ostatniego znaków który musi być 0 (zwany jako „the null terminator”). Bez niego, Pawn nie wiedziałby kiedy przestać czytać dany ciąg znaków. Wszystkie string’i są kodowane w UTF-8
Ogólnie, musisz wiedzieć jak długi będzie Twój string zanim go przechowasz. SourcePawn nie posiada jeszcze możliwości Stringów znanych np. w PHP

 
Użycie
 
Ciągi znaków są zwykle deklarowane jak tablice np.:

char message[] = "Hello!";
char Claus[6] = "Clams";
Rozłóżmy to na czynniki pierwsze:
char message[7];
char clams[6];

message[0] = 'H';
message[1] = 'e';
message[2] = 'l';
message[3] = 'l';
message[4] = 'o';
message[5] = '!';
message[6] = '\0';
clams[0] = 'C';
clams[1] = 'l';
clams[2] = 'a';
clams[3] = 'm';
clams[4] = 's';
clams[5] = '\0';

Mimo, żę string’i są rzadko inicjowane w ten sposób, to bardzo ważne jest, aby pamiętać pojęcie „null terminator”, który sygnalizuję o końcu string’a. Kompilator i większość funkcji SM automatycznie zakończy string zerem, co jest ważne gdy sami będziemy bezpośrednio edytować string.
Note: Zauważmy, że ciąg znaków jest w cudzysłowach z dwoma przecinkami u góry, natomiast pojedynczy znak jest w cudzysłowach z jednym przecinkiem na górze (lub miedzy apostrofami – jak kto woli)

 
Znaki
 
Znak tekstu może być użyty jako string lub jako komórka np.:


char text[] = "Crab";
char clam;

clam = 'D';                                              // Ustawia zmiennej clam wartość ‘D’
text[0] = 'A';                  // Zmienia indeks 0 (element pierwszy) tablicy text czyli ‘C’ na ‘A’. Teraz text to ‘Arab’
clam = text[0];             // Ustawia zmiennej clam wartość ‘A’
text[1] = clam;             // Zmienia indeks 1 (element drugi) tablicy text czyli ‘r’ na ‘A’. Teraz text to ‘AAab’
What you can't do is mix character arrays with strings. The internal storage is different.
int clams[] = "Clams"; // Błedne
int clams[] = {'C', 'l', 'a', 'm', 's', 0}; // Poprawne, ale TO NIE JEST STRING (CIĄG ZNAKÓW)

 
Funkcje
 
Funkcje, jak wspomnialiśmy wcześniej, jest to odizolowany blok kodu, który wykonuję określoną akcję. Mogą być one wywołane bez lub z argumentami / parametrami które przekazują jakieś dane do funkcji.
Funkcje można wywołać na 2 sposoby:

·          direct call – wywołanie samemu funkcji
·          callback - wywołanie funkcji dostarczanych przez aplikację?
Również rozróżniami kilka rodzajów funckji:
·          native (natywna) – bezpośrednia, wewnętrzna funkcja dostarczana przez aplikacje
·          public (publiczna) – szeroko dostępna funkcja, dla samego pluginu oraz na zewnątrz jego
·          normal (normalna) – normalna funkcja, którą tylko Ty możesz wywołać. Dostępna tylko dla innych funkcji w pluginie
·          static (statyczna) – zakres tej funkcji jest ograniczony w bieżącym pliku
·          stock (stock’owa) – generalnie jest to funkcja normala. Różni się od niej tym, że nieużyta nie powoduję ostrzeżeń przy kompilacji.
·          forward (forward) –
Cały kod w Pawn’ie musi być w funkcjach. To jest różnica między językami jak PHP, Perl czy Python, które pozwalają pisać globalny kod. That is because Pawn is a callback-based language: it responds to actions from a parent application, and functions must be written to handle those actions. Although our examples often contain free-floating code, this is purely for demonstration purposes. Free-floating code in our examples implies the code is part of some function.
Deklaracja
W przeciwieństwie do zmiennych, funkcje nie muszą być deklarowane zanim je użyjesz. Funkcja zbudowana jest z ‘nagłówka’, który zawiera jej nazwę i jej argumenty oraz kodu. Przykład funkcji z podanym jej działaniem:

int AddTwoNumbers(int first, int second)                       // nagłówek składający się z nazwy funkcji I jej parametrów
{
                        int sum = first + second;              // ustawiamy zmiennej sum typu int wartość sumy dwóch zmiennych first i second
                        return sum;                                           // zwraca wartość zmiennej sum (czyli wynik sumy first i second)
}

Jest to prosty przykład funkcji. Zajmijmy się naraziłem ‘nagłówkiem’:


int AddTwoNumbers(int first, int second)
int – typ zwracanej wartości (liczba całkowita)
AddTwoNumbers – nazwa naszej funkcji
int first – pierwszy argument, liczba całkowita
int second – drugi argument, liczba całkowita

Ważną rzeczą na którą warto zwrócić jest return, który informuję o końcu funkcji i zwróceniu wartości wywołującemu funkcję. Wszystkie funkcje coś zwracają na zakończenie, chyba że zwracają specjalny typ zwanym void.
Funkcja może przekazać każdy typ danych i może zwrócić każdy rodzaj nie będący tablicą

Oczywiście można przekazać zmienne do funkcji


int numbers[3] = {1, 2, 0};

numbers[2] = AddTwoNumbers(numbers[0], numbers[1]);         // Zamieni 0 na 3 ( bo 1+2=3 )

Należy pamiętać, że komórki są przekazywane przez wartość. Oznacza to, że ich wartości nie mogą być zmieniane przez funkcję np.:


int a = 5;

ChangeValue(a);

ChangeValue( B);
{
                        b = 5;
}

Ten kod nie zmieni wartości zmiennej „a”, ponieważ to kopia wartości zmiennej „a” przechodzi zamiast jej oryginał.
Więcej przykładów funkcji będzie podanych w dalszej cześci poradnika.

 
Publiczne (Public)
Publicznych funkcji używa się w celu implementacji callbacka. Nie powinieneś tworzyć funkcji publicznej jeśli nie tworzysz do niej żadnego callbacka. Np. takie 2 callback’i z scourcemod.inc:


forward void OnPluginStart();
forward void OnClientDisconnected(int client);

Aby korzystać z możliwości tych forwardów musisz stworzyć funkcję:


public void OnPluginStart()
{
                        /* Code Here */
}

public void OnClientDisconnected(int client)
{
                        /* Code here */
}

 
Słowo public jest sygnałem, aby dołączyć funkcję do odpowiadającemu jej forwardowi
 
Natywy (Natives)
 
Natywy są wbudowanymi funkcjami dostarczony przez SM. Możesz je wywołać tak jak normalne funkcje. Krótko: możemy korzystać z danych jednego pluginu w innym. Np. SM ma następującą funkcję natywną:

native float FloatRound(float num);             // zaokrągla liczby ułamkowe do liczby całkowitej
Może być również wywołana w taki sposób:
int rounded = FloatRound(5.2);                                             // zmienna rounded będzie wynosić 5 (5.2 ≈ 5)

 
Argumenty/Parametry Tablic
 
Można przekazać tablice lub string’i jako argumenty. Ważne, aby zauważyć, że są przekazywane przez referencję. Oznacza to, że zamiast tworzenia kopii danych, dane są referenced directly. Istnieje prostszy sposób wyjaśnienia tego bardziej konkretnie.

int example[] = {1, 2, 3, 4, 5};

ChangeArray(example, 2, 29);

void ChangeArray(int[] array, int index, int value)
{
                        array[index] = value;                       // ustawi 3 na 29
}

Funkcja ustawia dany w tablicy indeks danej wartości. Po wywołaniu naszej funkcji drugi indeks tablicy zmiennej example 3 zmieni się na 29:


example[2] = 29;

Aby zapobiec modyfikowaniu tablicy w funkcji, można zaznaczyć ją jako const. Spowoduje to error podczas kompilacji np.:


void CantChangeArray(const array[], int index, int value)
{
                        array[index] = value;                                               // Nie skompiluje się
}

Używanie const jest dobrym pomysłem w parametrach tablic jeśli wiesz, że tablica nie będzie modyfikowana; może to zapobiec pojawiania się błędów w kodowaniu.
 
Wyrażenia
 
Wyrażenia są takie same jak w matematyce. Są to grupy operatorów/symboli, często w nawiasach.  Zawierają one ścisłą „kolejność operacji” i mogą zawierać w sobie zmienne, funkcje, liczby i nawet wyrażenia same w sobie. Mogą być również przekazane jako parametr jakiejś funkcji.
Najłatwiejszym wyrażeniem jest pojedyncza liczba np.:

0;                   // zwróci liczbę 0
(0);                // również zwróci liczbę 0

Mimo, że wyrażenia mogą zwracać jakąkolwiek wartość, mogę też zwrócić zarówno zero jak i non-zero (liczbę niezerową), w tym sensie że zero = false a non-zero = true np. -1 to true w Pawn’ie, ponieważ jest niezerowe. Nie zakładajmy, że liczby negatywne są false (fałszywe).
Kolejność wykonywania działań jest identyczna jak w matematyce. Podajmy kilka przykładów:


5 + 6;                                  // 11
5 * 6 + 3;                         // 33
5 * (6 + 3);                                             // 45
5.0 + 2.3;                         // 7.3
(5 * 6) % 7;                     // 2; operator modulo (dzielenie, zwraca tylko resztę z dzielenia)
(5 + 3) / 2 * 4 – 9;     // -8

Jak wspomnieliśmy, wyrażenia mogą zawierać zmienne, a nawet funkcje:


int a = 5 * 6;                                                                // 30
int b = a * 3;                                                                // 30 * 3 = 90
int c = AddTwoNumbers(a, B) + (a * B);     // (30 + 90) + (30 * 90) = 390

 
Operatory (przypisania, arytmetyczne, znaku liczby, bitowe, skróconego przypisania, logiczne, warunkowe etc.)
Dokładnie opisane operatory bitowe znajdziecie pod tym linkiem: http://amxx.pl/topic...atory-w-pawnie/
Warunki
Wyrażenia warunkowe pozwalają uruchomić kod, tylko wtedy, kiedy dany warunek jest spełniony.
Wyrażenie if
Wyrażenie if sprawdza jeden lub wiecej warunków np.:

if (a == 5)
{
                        /* Kod, który zostanie uruchomiony kiedy warunek będzie true (prawdziwy) czyli w tym przypadku gdy a będzie równe 5*/
}

Może zostać rozszerzony do zastosowania większej ilości warunków np.:


if (a == 5)
{
                        /* Kod */
}
else if (a == 6)
{
                        /* Kod */
}
else if (if == 7)
{
                        /* Kod */
}

Można zrobić również taki sposób:


if (a == 5)
{
                        /* Kod */
}
else
{
                        /* Kod uruchomi się gdy a nie będzie równe 5 */
}

Note: Do sprawdzania czy coś jest równe czemuś używamy operatora == a nie =. „==” jest to operator logiczny do sprawdzania czy wartości są równe natomiast „=” jest to operator przypisania służący do umieszczania wartości znajdującej się z prawej strony w zmiennej po lewej stronie.
Wyrażenie switch
Wyrażenie switch jest to ograniczone wyrażenie if. Testują one jedno wyrażenie dla serii możliwych wartości np.:


switch (a)
{
                        case 5:
                        {
                                               /* Kod */
                        }
                        case 6:
                        {
                                               /* Kod */
                        }
                        case 7:
                        {
                                               /* Kod */
                        }
                        case 8, 9, 10:
                        {
                                               /* Kod */
                        }
                        default:
                        {
                                               /* uruchomi się gdy żadna z podanych wyżej wartości nie będzie pasowała */
                        }
}

 
Pętle
Pętla służy do powtarzania instrukcji, które chcemy by się wykonały więcej niż raz bez konieczności ich wielokrotnego pisania w kodzie.
Pętla for
Pętla for jest to pętla składająca się z 4 cześci (którym nadam od razu jakieś skróty):
·          nadawanie początkowych wartości zmiennym (inicjalizacja)
·          warunek kończący pętle (warunek)
·          zmiany po obrocie pętle (iteracja)
·          kod, który będzie się wykonywał po obrocie pętli gdy warunek będzie spełniony (kod)
 

for ( /* inicjalizacja */ ; /* warunek */ ; /* iteracja */ )
{
                        /* kod */
}

Prosty przykład użycia funkcji sumującej tablicę:


int array[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int sum = SumArray(array, 10);

SumArray(const array[], count)
{
                        int Total;

                        for (int i = 0; i < count; ++i)
                        {
                                               total += array[i];
                        }

                        return total;
}

Działanie:
 
·          int i = 0 – tworzy nową zmienną dla pętli i ustawia jej wartość na 0
·          i < count – pętla będzie uruchamiana tylko wtedy gdy ‘i’ będzie mniejsze niż ‘count’. Gwarantuje to, że pętla zatrzyma się w określonym punkcie. W tym przypadku nie chcemy czytać nieistniejących indeksów tablicy
·          ++i - preinkrementacja ‘i’ o 1 po każdym obrocie pętli. Zapewnia to, że pętla nie będzie obracała się wiecznie; ewentualnie ‘i’ stanie się zbyt duże i pętla się skończy
Tak więc funkcja SumArray będzie się obracać przez istniejące indeksy tablicy, za każdym razem dodając wartość indeksu do zmiennej total.
Pętla while
Pętla while są mniej powszechne niż pętle for ale są najprostszym sposobem pętli. Składa się ona z dwóch części:
·          warunek kończący pętlę (warunek)
·          kod, który będzie się wykonywał po obrocie pętli gdy warunek będzie spełniony (kod)
 


while ( /* warunek */ )
{
                        /* kod */
}

Jak długo warunek będzie spełniony, tak długo pętla będzie się powtarzała. Każda pętla for może być zamieniona na pętlę while:
/* inicjalizacja */


while ( /* warunek */ )
{
                        /* kod */
                        /* iteracja */
}

Przykład poprzedniej pętli for zamienionej na pętlę while:

SumArray(const array[], count)
{
                        int total, i;

                        while (i < count)
                        {
                                               total += array[i];
                                               i++;
                        }

                        return total;
}

Jest jeszcze pętla do…while które są jeszcze mniej powszechne. Są to te same pętle co pętle while z wyjątkiem, że warunek jest sprawdzany dopiero PO każdym obrocie pętli, a nie przed. To znaczy, że pętla zawsze obróci się co najmniej raz.


do
{
                        /* kod */
}
while ( /* warunek */ );

 
Kontrola pętli
Istnieją dwa przypadki, w których możesz wpłynąć na działanie pętli:
·          pomijanie (continue) jednej iteracji pętli ale dalsze jej kontynuowanie, lub;
·          przerwanie (break) całkowite pętli zanim się ukończy.
Powiedzmy, że masz funkcję, która pobiera tablicę i szuka odpowiedniej liczby. Chcesz ją zatrzymać kiedy liczba zostanie znaleziona:

/**
 * zwraca wartość indeksu tablicy lub -1 jeżeli nie znajdzie wartości
 */
SearchInArray(const array[], count, value)
{
                        int index = -1;

                        for (int i = 0; i < count; i++)
                        {
                                               if (array[] == value)
                                               {
                                                                       index = i;
                                                                       break;
                                               }
                        }

                        return  index;
}

W pomijaniu iteracji pętli słowem klucz jest continue. Na przykład, powiedzmy, że chcemy zsumować wszystkie liczby parzyste:


int SumEvenNumbers(const array[], count)
{
                        int sum;

                        for (int i = 0; i < count; ++i)
                        {
                                               /* jeżeli reszta z dzielenia przez 2 to 1, to wiemy że to liczba nieparzysta */
                                               if (array[i] % 2 == 1)
                                               {
                                                                       /* Pomija obrót pętli */
                                                                       continue;
                                               }
                                               sum += array[i];
                        }

                        return sum;
}

  • +
  • -
  • 3

#2 Linux'

    Pan Pomocny

  • Power User

Reputacja: 489
Wszechobecny

  • Postów:1426
  • Steam:steam
  • Imię:Sebastian
  • Lokalizacja:AmxMod i SourceMod
Offline

Napisano 25.04.2016 21:08

Co tu pisać, kawał dobrej roboty. Nawet mało ogarnięci powinni się połapać.


  • +
  • -
  • 0

Posiadam na sprzedaż w pełni odwzorowaną paczkę nowego coda do csgo. Kliknij by dowiedzieć się więcej!

 

- PISZE MODYFIKACJE.

- NAPRAWIAM POPSUTE PLUGINY.

- DZIALAM W DZIALACH AMXX/SOURCEMOD. MASZ ZLECENIE? PISZ.





Użytkownicy przeglądający ten temat: 0

0 użytkowników, 0 gości, 0 anonimowych