Помогни ни да направим Uroci.net по - богат! Добави урок

Урок 3: Изрази, Условия, Цикли, Директиви в Pawn

Други уроци » Други
taffch0   трудност:    видян: 4522

Съдържание:

    1. Изрази
    2. Условия
      2.1. If .. then .. else if ... else
      2.2. Switch

    3. Цикли
      3.1. For
      3.2. While

    4. Директиви


Изрази

Сега ще ви обесня за изразите в pawn.
.. изрази, да правилно прочетохте Smile Ноооо изразите в любимия ви предмет - математиката Razz

Те обхващат събирането, умножението, разделянето, изваждането и т.н.
Можете да сравнявате и преравнявате дадени изрази, и дори да ги прекарате във функция като параметър.

Ако даден израз не е 0, или не е false (говорихме в миналия урок за TRUE/FALSE), не само че връща някаква стойност, а и връща "true".
В противен случай ще върне 0, което ще рече "false".

Математическите оператори в pawn са:
    1. + "събиране"
    2. - "изваждане"
    3. * "умножение"
    4. / "деление"
    5. % "за намиране на остатък" (примерно 5/2 = 2,5 и остатък = 1)


Код:
1
2
3
4
5
6
7
 (5+6)                       // връща 11
((5*6)+3)                   // връща 33
((((5+3)/2)*4)-9)           // връща 7
((5*6) % 7)                 // връща 2

(true)                      // връща true
(5.0 + 2.3)                 // връща 7.3 като плаващо число 


Има също така и допълнителни други оператори, които са предназначени за променливите.
Те биват:
    инкрементиращи (увеличаващи)
    декремнтиращи (намаляващи)


От своя страна увеличаващите се делят на два под типа:
    с предварително увеличаване (pre increment)
    с пост (не предварително) увеличение (post increment)



Код:
1
2
3
4
5
 new a = 5
new b = 6
// тук първите две променливи са пост/предаврително увеличаващи оператора
a++          // връща а + 1 => 6 (пост увеличаващи)
++a          // също връща а + 1 => 6  (предварително увеличаващи) 


Разликата между тях е съвсем малка, но много важна.
Те са доста полезни при използването им в циклите в някои определени случаи.
Също така е важно да се знае, че увеличаващите/намалящите оператори не само че ще върнат a+1, но и ще сложат за стойност на променливата a+1.

Ако все още не сте разбрали, сега ще ви обесня с пример:
Код:
1
2
3
 new x = 0
log_amx("Stoinosta na x pri ++ e = %d", x++)
log_amx("Stoinosta na x sled ++ e = %d", x) 

Output-а (изходният вариант) ще изглежда по следния начин:
Stoinosta na x pri ++ e = 1
Stoinosta na x sled ++ e = 2

И ето видяхте сами, че при пост увеличаването, променливата се увеличава след като израза е изчислен.

Пример с предварителното инкрементиране:
Код:
1
2
3
 new x = 0
log_amx("Stoinosta na x pri ++ e = %d", ++x)
log_amx("Stoinosta na x sled ++ e = %d", x) 

Output-а (изходният вариант) ще изглежда по следния начин:
Stoinosta na x pri ++ e = 2
Stoinosta na x sled ++ e = 2

.. и ето пак виждате, че при предварителното увеличаване, променливата се увеличава преди израза да бъде изчислен.

Надявам се че разбрахте разликата, която наистина е много, много тънкичка.
Ако не го разбирате, оставете, не ви трябва да го знаете сега в началото.

Код:
1
 a++ 

Може да се интерпретира и по други начини:
Код:
1
2
3
 a = a + 1
a = a OP y
a OP= x


Също така обърнете внимание и на следните оператори:
Код:
1
2
3
4
 a += 1       // Така слагаме на а стойност а + 1
a -= b       // Така слагаме стойност на а, а - b
a *= 0       // Така умножаваме а с 0
a /= 2       // Така делим а на 2 


Тези начини са съкратения вид на:
Код:
1
2
3
4
 a = a + 1
a = a -b
a = a * 0
a = a / 2


Освен тези оператори, ще срещнете и boolean (булеви) оператори, които ще ви помогнат при логическите операции.
Оператора && (което ще рече "И") взема "левия" и "десния" израз, ако и двата са "true", тогава връща true.

Код:
1
2
3
4
5
6
7
 // Това е false, тъй като 1 означава true, а 0 - false
// И тъй като и двете не правят true, && връща false
(1 && 0)
(1 && 2)                    // Двете числа са "true", следователно израза е верен
(true && false)             //false
(false && false)            //false
(true && true)              //true 


Другият оператор е "ИЛИ" - ||
Той връща TRUE, ако поне единият от всички изрази е TRUE (верен)

Код:
1
2
3
4
5
 (1 || 0)                    //true, тъй като една от стойностите е true
(1 || 2)                    //true
(true || false)             //true
(false || false)            //false
(true || true)              //true 


Има и други оператори, които няма да срещнете и използвате често. Като например "bitwase and" или съкратеното "и" - "&"
& връща дали бинарно късче от нещо се съдържа в друг бинарен код.
С други - технически думи, & прави същото като "и (&&)" операцията, но на всеки бит.
Примерно, да кажем че имате числото 9, което е "1001" в бинарен код.
Ако искате да разберете дали тази последователност съдържа 8 (1000), вие трябва да:

Код:
1
2
3
4
5
6
7
8
 // Така ще върнете 8, което ще рече че 8 се съдържа в 9
(9 & 8)
//4 (00100) не е бит в 16 (10000) и затова ще върне 0.
(16 & 4)
// Следващия оператор който ще разгледаме е "bitwise or" (|)
// Което всъщност е същото като "или ||" оператора и го изпълнява върху всеки бит в двете числа
// По този начил ще вземем 9 (1001) и ще го сравним с 3 (0011), резултата ще бъде в 1011, или 11.
(9 | 3) 


Тези оператори са също много важни, но както казах не се използват често.
Има също така и операторите << и >> - за лява и дясна промяна на битовете към някаква посока.

Код:
1
2
3
4
 // Така ще вземем числото 3 (00011) и ще му обърнем посоката с три места в бинарния си код (11000), което ще рече 24.
(3 << 3)
// Така ще вземем числото 24 (11000) и ще обърнем посоката му с три места (00011), което ще рече 3.
(24 >> 3) 


И последният оператор: "bitwise not":
Код:
1
2
3
4
5
6
7
 // Ще върне false
(!true)
// Ще върне true
(!false)
// Така ще вземем 9 (бинарно: 1001) и ще го направим 6 (бинарно: 0110).
// Това е "bitwise complement" оператора, който изпълнява !(НЕ / БЕЗ) върху всеки бит.
(~(9)) 


Условия

Условията ви позволяват да тествате ако даден израз отговаря на вашето условие, да бъде изпълнен определен код, на базата на решението (в случаите при това дали отговаря или не отговаря израза).

Даа.. доста сложно звучи, но всъщност е супер просто и сега ще се обедите сами !

Така, условията могат да се изразят по два начина:
    1. Чрез IF .. ELSE , както и IF .. ELSE IF .. ELSE
    2. Чрез Switch


Нека започнем с IF:

Тълкуването на IF е следното: "АКО ........ ТОГАВА .....".
If изчислява дали даден израз е TRUE или FALSE.
Ако е TRUE (истина), ще се изпълни определен блок от код, ако ли не ще се изпълни другата част от блока ( но не е длъжно да има и друга част, само ако се посочили ELSE)

Та ето и един пример:
Код:
1
2
3
4
5
6
7
 new a = 1
new b = 1
if ( a + b == 2 ) {
    log_amx("a+b e ravno na 2 !")
} else {
    log_amx("a+b ne e ravno na 2 !")
} 


Ето и още няколко:
Код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 new a = 1
new b = 2
if ( a > b ) {
    log_amx("a e po-golqmo ot b, toest b e po-malko ot a")
} else {
    log_amx("a e po-malko ot b, toest b e po-golqmo ot a")
}

if ( a >= b ) {
    // когато а е по-голямо или равно на b
} else {
    // когато а не е по-голямо или равно на b
}

if ( a <= b ) {
    // когато а е по-малко или равно на b
} else {
    // когато а не е по-малко или равно на b
}

if ( ((a+b) / 2) >= c ) {
    // Кода който ще се изпълни при условие когато а + b, разделени на 2 ще е равно или по-голямо от стойността на променливата c
}

if (a != 4) {
    // когато а е РАЗЛИЧНО от 4
}

if (a >= 5 && a <= 10) {
    // съставихме обхват, при който, ако а е равно или по-голямо от 5 И е равно или по-голямо от 10, да се изпълни някакъв код
} else {
    // Ако ли не.. някакъв друг код
}

// Връща TRUE и за двете стойности (тоест изпълнява кода преди ELSE)
if (a && b) {}
// Връща TRUE ако 7.5 е по-голямо от c
if ( ((5*3)/2) > c) {}
// Винаги ще върне true
if (true) {}
// Никога няма да върне true
if (false) {} 


Ако искате да сравните масиви, тук вече нещата са малко по-особени.
Примерно:
Код:
1
2
3
4
5
 new masiv_a[3]
new masiv_b[3]
if (masiv_a == masiv_b) {
..
} 


Това тук е грешно.
Трябва да е:
Код:
1
2
3
4
5
 if ((masiv_a[0] == masiv_b[0]) && 
    (masiv_a[1] == masiv_b[1]) && 
    (masiv_a[2] == masiv_b[2])) {
        ....
    } 


Очевидно е че, това въобще няма да е удобен начин за сравнение при големи масиви.
След малко ще ви покажа как лесно можете да сравните стрингове и масиви.

Както по-горе бях споменал освен IF - ELSE има и ELSE IF, което допълнително улеснява и убогатява вашите проверки за верни и грешни изрази.
Ето и един примерен код:
Код:
1
2
3
4
5
6
7
 if (a == 6) {
    // код, който да се изпълнява при а = 6
} else if (a > 100 && a < 150) {
    // код, който да се изпълнява при а по-голямо от 100 и по-малко от 150
} else {
    // код, който да се изпълнява при краен случай. Тоест, ако стойността на а не попада никъде в предишните условия
} 


Важно е тук да се отбележи, че ако израза върне TRUE, само и единствено кода, който е предназначен за него израз ще се изпълни и няма да продължи проверката на долу !

Втория начин за изразяване на условия, както писах по-горе е чрез SWITCH
Нека разгледаме и този вариант, който всъщност е по-удачен в някои случаи да се използва, тъй като е и по-бърз за изпълнение, от колкото проверката с if-овете.

Примерен код:
Код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 switch (a)
{
    case 5:
    {
       // място за кода, който ще се изпълни при условие, че стойността на "a" е 5
    }
 
    case 6:
    {
      // място за кода, който ще се изпълни при условие, че стойността на "a" е 6
    }
 
    case 7:
    {
       // място за кода, който ще се изпълни при условие, че стойността на "a" е 7
    }
 
    default:
    {
       // Кода, който ще се изпълни в случай, че "a" не приема никаква стойност, която е описана в switch-а, като отделен случай
    }
} 


Също така за спестяване на код, можете да използвате и няколко стойности за критерий:
Код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 switch (a)
{
    case 3, 4, 5:
    {
       // място за кода, който ще се изпълни при условие, че стойността на "a" е 3, 4 или 5
    }
 
    case 6, 7, 8:
    {
      // място за кода, който ще се изпълни при условие, че стойността на "a" е 6, 7 или 8
    }
 
    case 9, 50, 17:
    {
       // място за кода, който ще се изпълни при условие, че стойността на "a" е 9, 50 или 17
    }
 
    default:
    {
       // Кода, който ще се изпълни в случай, че "a" не приема никаква стойност, която е описана в switch-а, като отделен случай
    }
} 


Нещо друго полезно е, че можете да използвате и обхвати:

Код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 switch (a)
{
    case 0 ... 10:
    {
       // място за кода, който ще се изпълни при условие, че стойността на "a" е между 0 и 10
    }
 
    case 20 ... 30:
    {
      // място за кода, който ще се изпълни при условие, че стойността на "a" е между 20 и 30
    }
 
    case 100 ... 500:
    {
       // място за кода, който ще се изпълни при условие, че стойността на "a" е между 100 и 500
    }
 
    default:
    {
       // Кода, който ще се изпълни в случай, че "a" не приема никаква стойност, която е описана в switch-а, като отделен случай
    }
} 


Трябва да обърнете внимание, че switch не е като if !
Тоест нека приемем че ползваме горният код за обхвата, и че а е със стойност = 448
То тогава няма да се изброяват всеки един случай, докато израза върне TRUE, а направо ще попадне на case 100 .. 500

Ето заради това ви казах че switch е по-удачен и по-бърз в някои случаи, но пък няма толкова възможности, каквито if предлага.

Цикли


Циклите са съществени за всеки един програмен език.
Те ви позволяват да изпълнявате един и същ блок от код - пак, и пак и пак и пак посредством условие, върху което кода ще бъде повтаряно.

В този урок ще ви покажа двата различни цикъла - for и while, като минем първо през for.

Цикълът FOR
Цикълът for е най-широко използваемия от всички други.
Той приема:
    1. Първична стойност (стартова стойност)
    2. Условие до което да спре
    3. и на последно място инкрементиране (увеличаване) на първичната стойност

След това следва тялото на цикъла, в който се поставя кода, който ще се изпълнява X пъти, тоест докато условието не върне FALSE.

Нека сега да ви покажа и едно примерче, за да си имате напредстава:
Код:
1
2
3
4
5
6
 new broiach
new suma
for (broiach=1; broiach<=10; broiach++)
{
   suma += broiach
} 


Може би схванахте, но за всеки случай ще дам и обясненияSmile
Синтаксиса за for е следният:
Код:
1
2
3
4
 for (първоначална стойност; условие; инкрементиране)
  {
    // вашият код
  } 


Това са стъпките, по които следва цикъла:
    Преди първия цикъл да бъде изпълнен, стартира се първоначалното условие.
    След това започва да започва да повтаря кода ви в следните стъпки:
      1. Проверява ако условието все още връща TRUE. Ако е така, продължава операцията, ако ли не - спира цикълът.
      2. Изпълнява кода
      3. Увеличава стойността на брояча с 1
      4. Връща се на стъпка 1ва


Ето и малко обяснения по горните стъпки:
    1. Първият параметър, broiach = 1 - слага стойност на променливата broiach = 1. Това става естествено преди да започне цикълът
    2. Следващата стъпка е да се провери инкрементиращият(увеличаващият) параметър (broiach в случая). Този параметър е от типа пост увеличаващ, така че към брояча ще се добави единица (1) след като целият блок от код бива изпълнен
    3. След това се проверява и условието (дали broiach <=10). В момента е 1 и трябва да влиза в обхвата 1-10 за да продължи операцията
    4. Щом проверката върне TRUE, sum+=broiach се изпълнява (тоест sum променливата приема стойността на broiach като я инкрементира)
    5. Блокът от код се изпълнява и broiach++ инкрементира broiach до стойност 2
    6. Нещата се повтарят отново
    7. Проверява се дали broiach<=10. И така е, сега е 2. sum+=broiach се изпълнява пак и sum вече е приела стойността 3.
    8. Блокът от код е изпълнен и broiach се инкрементира/увеличава до 3.
    9. И тези стъпки се повтарят докато инкрементиращият параметър broaiach стигне 11. Тогава условието няма да връща вече TRUE, а ми FALSE и съответно работата на цикъла е превършена.


Можете също така да обхождате с цикъл цели масиви:
Код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
 sum_of_array(moqMasiv[], размер)
{
   // Бъдете сигурни че сте написали точният размер на масива, за да не го "прелеем" (в миналия урок за масивит съм обяснил този термин)
   new i, sum
 
   // Цикълът ще започне от 0 и ще спред точно, когато стигне целия размер на масива
   // Ако потребителя е написал точния размер на масива,
   // цъкъла ще почне от 0 до {размера}-1
   // Така ще пасне точно според слотовете с масива

   for  (i=0; i<size; i++)
   {
      // Всеки път, когато се изпълнява този цикъл 
      // i ще бъде число от 0 до {размера}-1
      // Добавяме стойността на слота (i) от масив в sum
      // Когато преключи, sum ще съдържа
      // сумата от всички слотове на масива
      sum += moqMasiv[i]
   }
 
   return sum
}
 
new NumberArray[4]
NumberArray[0] = 3
NumberArray[1] = 1
NumberArray[2] = 4
NumberArray[3] = 1
 
new answer = sum_of_array(NumberArray, 4)
//отговора ще бъде 3+1+4+1, или 9 


Ето и функция, която ще служи за сравняване на масиви, дали са еднакви
Код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 bool:compare_arrays(array1[], array2[], size)
{
   new i
   for (i=0; i<size, i++)
   {
      // Ако слота не съвпада, спираме изпълнението на функцията и връщаме false.
      if (array1[i] != array2[i])
      {
         return false
      }
   }
 
   // Ако функцията стигне до тази точка, то връщаме TRUE, тоест масивите са напълно еднакви !
   return true
} 


След като ви обясних действието на цикъла for, стигаме и до цикъла while:

Този начин също е важен и е доста по-лесен за използване от другият цикъл, който разгледахме.
Нарича се както разбрахте "while".
While приема само един параметър, а не 3, както for. Той играе роля на условие.
И тук като при for, докато това условие връща true, кода продължава да се изпълнява.

Вижте и преправеният код от по-горе, само че с while:
Код:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 new i=0
new sum
 
while (++i <= 10)
{
   sum+=i
}
 
sum_of_array(masiv[], razmer)
{
   new i=0, sum
 
   // Изпълняваме цикъла, докато i е по-малък от {размера}
   // i се инкрементриа в края на тялото на цикъла
   while (i++ < size)
   {
      sum += masiv[i]
   }
 
   return sum
}
 
bool:compare_arrays(masiv1[], masiv2[], size)
{
   new i
   while (i++ < size)
   {
      if (masiv1[i] != masiv2[i])
      {
         return false
      }
   }
 
   return true
} 


Директиви за компилатора

Тези директиви ви позволяват да указвате на компилатора, как вашият код да бъде четен.

Код:
1
2
3
4
5
6
7
8
9
 // За да сложите някаква стойност към символ е нужно да напишете
#define SIMVOL STOINOST
// примерно:
 
#define MAX_STRING 250
new String[MAX_STRING]
 
#define INFO "Uroka e napisan ot hateYou specialno za аmxmodxbg.org"
new INFO[MAX_STRING] = INFO


Също така, можете да използвате #define за да промените кода, който компилатора следва
Код:
1
2
3
4
5
6
7
 #if defined LINUX
   // Този код ще бъде компилиран ако е дефиниран LINUX (#define LINUX)
   execute_command("ls -l")
#else
   // А този, ако не е ..
   execute_command("dir")
#endif 


Можете да промените също така, колко памет да използва плугинът ви:
Код:
1
2
3
 #pragma dynamic 4096
// Така ще създадете 16k (което си е и по дифаулт).
// Измерва се в блокове от 4 байтови клетки 


Също така можете да определите и дали е нужно да слагате задължително точка и запетая в края на всяка линия от код (по подразбиране е 0):
Код:
1
 #pragma semicolon 1 


Също така можете да промените и контролният символ, който служи за ескейпване на специалните символи:
Код:
1
2
3
4
5
 #pragma ctrlchar ''
// така ще промените контролният символ на наклонена черта. Също като при ( c/c++/c#/java/php...  и т.н. )
// сега ще трябва да ползвате  вместо ^
// примерно: client_print(id, print_chat, "Uroka e napisan specialno za ^"amxmodxbg.org^" !")
// сега трябва да е: client_print(id, print_chat, "Uroka e napisan specialno za "amxmodxbg.org" !") 





Преписването е забранено.



Сподели |

Коментари (1)

venom1724 на 08.02 2010 в 21:02ч.
Урока е супер. Ако можете да програмирате на c++ ще е лесно да драснете някои плугин. Аз лично мн се занимавам с информатика. Ходя по састезания и такис. Ще пробвам да направя нещо :P. Ако искате някои по специфичен плугин да направите вижте в саита на amx mod x за повече команди или ми кажете да ви хелпна.

Регистрирайте се, за да добавите коментар


Калдейта ЕООД - © 2003-2010. Всички права запазени.
Препоръчваме: IT Новини