diff options
feat!: Update dunbar after inline brace character swap
1 files changed, 56 insertions, 56 deletions
| -rw-r--r-- | src/teaching/upp-2025/cpp-pitfalls/index.du | 112 |
diff --git a/src/teaching/upp-2025/cpp-pitfalls/index.du b/src/teaching/upp-2025/cpp-pitfalls/index.du index 3f04b01..8a6936b 100644 --- a/src/teaching/upp-2025/cpp-pitfalls/index.du +++ b/src/teaching/upp-2025/cpp-pitfalls/index.du @@ -54,12 +54,12 @@ if (condition) else myvar = false; -Стойността на `[condition]` е булева сама по себе си, добрата практика е директно да запишем стойността: +Стойността на [`condition`] е булева сама по себе си, добрата практика е директно да запишем стойността: ```c++ myvar = condition; -Като `[condition]` е какъвто и да е булев израз. +Като [`condition`] е какъвто и да е булев израз. [$br2] @@ -73,7 +73,7 @@ bool f() { return false; } -Коректното е просто да върнем `[condition]`, тя е булева: +Коректното е просто да върнем [`condition`], тя е булева: ```c++ bool f() { @@ -146,8 +146,8 @@ std::cout << ((double)x / y); // едното вече е с плаваща за ```c++ a || b || c || d -Ако `[a]` е истина, тогава другите няма да се изпълнят, защото тяхната стойност не е от значение, общия израз ще си остане истина. -Аналогично, ако `[a]` е лъжа, но `[b]` е истина, тогава `[c]` и `[d]` няма да се изпълнят. +Ако [`a`] е истина, тогава другите няма да се изпълнят, защото тяхната стойност не е от значение, общия израз ще си остане истина. +Аналогично, ако [`a`] е лъжа, но [`b`] е истина, тогава [`c`] и [`d`] няма да се изпълнят. [$br2] @@ -155,7 +155,7 @@ a || b || c || d a && b && c && d Напълно еквивалентно работи и "или". -Ако `[a]` е лъжа, тогава другите няма да се изпълнят, защото общия израз ще си остане лъжа. +Ако [`a`] е лъжа, тогава другите няма да се изпълнят, защото общия израз ще си остане лъжа. [$br2] @@ -169,14 +169,14 @@ if (condition1 && ((myvar += 5) == 8)) ```c++ if (condition1 && f()) -И в двата случая, ако `[condition1]` е лъжа, тогава присвояването и извикването на функцията няма да се изпълнят. +И в двата случая, ако [`condition1`] е лъжа, тогава присвояването и извикването на функцията няма да се изпълнят. Дали това е желан ефект или не зависи от кода. ## Undefined behaviour C++ наследява идеята от C, че някои неща в стандарта на езика не са дефинирани. -Тоест, какво ще се случи зависи от имплементацията на компилатора (това което превръща кода в `[.exe]`) и често се срещат разлики. +Тоест, какво ще се случи зависи от имплементацията на компилатора (това което превръща кода в [`.exe`]) и често се срещат разлики. ### Приоритет на скоби спрямо аритметични оператори @@ -190,14 +190,14 @@ C++ наследява идеята от C, че някои неща в стан int x = 9; int y = (x += 5) * (x += 1) * (x -= 8); -Има два начина да се изчисли стойността на `[y]`: +Има два начина да се изчисли стойността на [`y`]: :ordered 1. Първо изчисляваме всички изрази в скобите и след това изпълняваме умноженията. .p - Тоест, първо правим `[x += 5]`, после `[x += 1]` и след това `[x -= 8]`. - Това променя стойността на `[x]` на 7 и стойността на `[y]` се свежда до `[x * x * x = 343]` + Тоест, първо правим [`x += 5`], после [`x += 1`] и след това [`x -= 8`]. + Това променя стойността на [`x`] на 7 и стойността на [`y`] се свежда до [`x * x * x = 343`] 2. Първо изчисляваме умноженията. Това означава, че първо "слагаме" скоби около умноженията; израза се изпълнява все едно е: @@ -206,17 +206,17 @@ int y = (x += 5) * (x += 1) * (x -= 8); ((x += 5) * (x += 1)) * (x -= 8) .p - *[(Умножението е ляво асоциативно)]* + [*(Умножението е ляво асоциативно)*] .p - Тоест, първо правим `[x += 5]` и след това `[x += 1]`. - Стойността на `[x]` е 15 и в големите скоби изчисляваме `[x * x = 225]`. + Тоест, първо правим [`x += 5`] и след това [`x += 1`]. + Стойността на [`x`] е 15 и в големите скоби изчисляваме [`x * x = 225`]. Сега израза се свежда до: ```c++ 225 * (x -= 8) - Изпълнява се `[x -= 8]`, `[x]` става 7, и `[y]` се свежда до `[225 * 7 = 1575]`. + Изпълнява се [`x -= 8`], [`x`] става 7, и [`y`] се свежда до [`225 * 7 = 1575`]. Първия метод се изпълнява от компилатора на Visual Studio, втория метод от gcc (много популярен C++ компилатор под Linux/MacOS). @@ -224,7 +224,7 @@ int y = (x += 5) * (x += 1) * (x -= 8); ## Масиви и матрици .important -Всички неща, които важат за статично-заделени масиви (`[int arr[5];]`), важат и за статично-заделени матрици (`[int mat[5][6];]`)! +Всички неща, които важат за статично-заделени масиви ([`int arr[5];`]), важат и за статично-заделени матрици ([`int mat[5][6];`])! ### Връщане на масиви @@ -252,11 +252,11 @@ int main() { } // b се освобождава } -Като цяло, няма особено значение дали говорим за къдравите скоби на функция, на `[if]`, на цикъл, ... +Като цяло, няма особено значение дали говорим за къдравите скоби на функция, на [`if`], на цикъл, ... [$br2] -Затова следното е =[грешно]=: +Затова следното е [=грешно=]: ```c++ int* f() { @@ -264,18 +264,18 @@ int* f() { return arr; } -`[arr]` е адрес в паметта (индекс, позиция, ..., която посочва клетка в паметта), някакво число. +[`arr`] е адрес в паметта (индекс, позиция, ..., която посочва клетка в паметта), някакво число. -След като функцията свърши изпълнение и се върне стойността, ще сме "стигнали" къдравата скоба и `[arr]` ще бъде освободено. +След като функцията свърши изпълнение и се върне стойността, ще сме "стигнали" къдравата скоба и [`arr`] ще бъде освободено. Може да зачитате, че стойностите се унищожават в този момент. Обаче, адреса сам по себе си е число, което си се връща и ние можем да работим с него както си искаме. -Тоест, =[C++ няма да ни се скара, че използваме масив, въпреки че той е, на практика, унищожен!]= +Тоест, [=C++ няма да ни се скара, че използваме масив, въпреки че той е, на практика, унищожен!=] [$br2] -Ако искаме действително да върнем масив от стойности, трябва да го създадем в =[обхвата в който функцията се извиква и да го подадем като аргумент.]= +Ако искаме действително да върнем масив от стойности, трябва да го създадем в [=обхвата в който функцията се извиква и да го подадем като аргумент.=] Например: ```c++ @@ -303,7 +303,7 @@ int arr1[3] = { 1, 2, 3 }; ```c++ int arr2[3] = { 0 }; -Обаче, ако примерно се опитаме да напълним масива с единици, тогава следното =[няма]= да проработи: +Обаче, ако примерно се опитаме да напълним масива с единици, тогава следното [=няма=] да проработи: ```c++ int arr3[3] = { 1 }; @@ -312,10 +312,10 @@ int arr3[3] = { 1 }; Инициализацията чрез къдрави скоби работи по следния начин: всички елементи в масива се попълват спрямо подадените елементи в къдравите скоби. -=[Ако в къдравите скоби има по-малко елементи отколкото е голям масива, останалите елементи се попълват с нули!]= +[=Ако в къдравите скоби има по-малко елементи отколкото е голям масива, останалите елементи се попълват с нули!=] -Тоест, в `[arr2]` ние попъляваме първия елемент да е нула, и останалите стават нули по подразбиране. -В `[arr3]` попълваме първия елемент да е единица и останалите стават нули по подразбиране. +Тоест, в [`arr2`] ние попъляваме първия елемент да е нула, и останалите стават нули по подразбиране. +В [`arr3`] попълваме първия елемент да е единица и останалите стават нули по подразбиране. Това навява на мисълта, дали не можем в C++ да пропуснем записването на първия елемент, когато искаме всичко да е нула? Можем! @@ -334,33 +334,33 @@ for (int i = 0; i < 3; i++) ### Масиви с неконстантен размер -=[Не]= позволяваме в този курс да правите такива неща: +[=Не=] позволяваме в този курс да правите такива неща: ```c++ int size; std::cin >> size; int arr[size]; -Въпреки че това *[може]* да се компилира и да работи. +Въпреки че това [*може*] да се компилира и да работи. Причината е защото този тип масиви се наричат [url https://en.wikipedia.org/wiki/Variable-length_array VLA]. -И в =[C++ VLA-ове не са позволени!]= +И в [=C++ VLA-ове не са позволени!=] Въпреки това, много компилатори ги поддържат, главно защото много C++ компилатори са и C компилатори (и VLA-ове са позволени в C). -=[Единствения]= коректен метод да създадем масив, чиито размер не знаем предварително, е чрез динамича памет. +[=Единствения=] коректен метод да създадем масив, чиито размер не знаем предварително, е чрез динамича памет. ### Тип на матрици (int[7][3] vs int(*)[3] vs int**) ```c++ int mat[7][3]; -Какъв е типа на `[mat]`? +Какъв е типа на [`mat`]? -От една страна е `[int[7][3]]`. -Но какъв е типа като указател, тоест когато няма въведени редове =[и]= колони? +От една страна е [`int[7][3]`]. +Но какъв е типа като указател, тоест когато няма въведени редове [=и=] колони? -Отговорите са два: `[int(*)[3]]` и `[int*]`. +Отговорите са два: [`int(*)[3]`] и [`int*`]. Ето защо. [$br2] @@ -371,29 +371,29 @@ int mat[7][3]; ```c++ int arr[14]; -Тогава в паметта се *[използва]* (заделя) =[последователност]= от клетки, която побира 14 `[int]` стойности. +Тогава в паметта се [*използва*] (заделя) [=последователност=] от клетки, която побира 14 [`int`] стойности. -Също да си припомним, че `[arr]` е указател към първата от тези клетки. +Също да си припомним, че [`arr`] е указател към първата от тези клетки. -На кратко, това означава че `[arr]` е адрес (индекс, позиция, ..., число което посочва в коя клетка на паметта се намираме). +На кратко, това означава че [`arr`] е адрес (индекс, позиция, ..., число което посочва в коя клетка на паметта се намираме). Финално припомняме, че индексирането в масив е същото като отместване на адреса. -Т.е. `[arr[6]]` е еквивалентно на `[*(arr + 6)]`. +Т.е. [`arr[6]`] е еквивалентно на [`*(arr + 6)`]. -На кратко, ние преместваме нашия адрес (индекс в паметта) напред с 6 позиции и с `[*]` дереферираме (прочитаме стойността на подадения адрес). +На кратко, ние преместваме нашия адрес (индекс в паметта) напред с 6 позиции и с [`*`] дереферираме (прочитаме стойността на подадения адрес). -Това означава, че =[всички елементи в масива е нужно да бъдат поставени последователно в паметта]=. +Това означава, че [=всички елементи в масива е нужно да бъдат поставени последователно в паметта=]. [$br2] -Двумерните масиви =[работят по същия начин!]= +Двумерните масиви [=работят по същия начин!=] -В декларацията на `[mat]`, в паметта се заделя последователност от клетки в паметта, равна на размера на матрицата. -Тоест `[7 * 3 = 21]` =[последователни]= *[позиции]* в паметта. +В декларацията на [`mat`], в паметта се заделя последователност от клетки в паметта, равна на размера на матрицата. +Тоест [`7 * 3 = 21`] [=последователни=] [*позиции*] в паметта. -Тогава, `[mat[2][1]]` на какво е еквивалентно? +Тогава, [`mat[2][1]`] на какво е еквивалентно? -Отговорът е `[*(mat + 2 * 7 + 1)]`. +Отговорът е [`*(mat + 2 * 7 + 1)`]. Нашата таблица е разположена като последователност от клетки, където първо имаме клетките от първи ред, след това от втория ред и так. нат. @@ -411,21 +411,21 @@ int nums[3][2] = { ``` 8 92 20 50 7 45 -Как извеждаме елемента `[nums[2][1]]`? -Това е последната стойност в матрицата, `[45]`. +Как извеждаме елемента [`nums[2][1]`]? +Това е последната стойност в матрицата, [`45`]. Щом искаме трети ред (втори по индекс), значи трябва да пропуснем първите два реда. -Това са общо 4 числа, как го сметнахме? `[Два реда * брой колони на ред = 2 * 2]`. +Това са общо 4 числа, как го сметнахме? [`Два реда * брой колони на ред = 2 * 2`]. Сега сме на последния ред, искаме втория елемент (първи по индекс), значи отиваме на следващия елемент. -Така показахме, че `[nums[2][1]]` е еквивалентно на `[*(nums + 2 * 2 + 1)]`. +Така показахме, че [`nums[2][1]`] е еквивалентно на [`*(nums + 2 * 2 + 1)`]. [$br2] -Това трябва да поражда въпрос: не можем ли да използваме `[nums]` като едномерен масив и да напишем `[nums[2 * 2 + 1]]`? +Това трябва да поражда въпрос: не можем ли да използваме [`nums`] като едномерен масив и да напишем [`nums[2 * 2 + 1]`]? Можем! -Затова е смислено да преобразуваме `[int[3][2]]` към `[int*]`. +Затова е смислено да преобразуваме [`int[3][2]`] към [`int*`]. Единствения проблем, е че употребата става неприятна. Например: @@ -440,7 +440,7 @@ void f(int* matrix) { [$br2] Забелязваме, че ако C++ знае броя колони, би трябвало да може да направи сам тази сметка с пропускането на редове. -От там се поражда `[int(*)[2]]` като смислено преобразуване на `[int[3][2]]`. +От там се поражда [`int(*)[2]`] като смислено преобразуване на [`int[3][2]`]. Това е най-обикновен указател, обаче му даваме броя колони (и с това, подсказваме че ще работим с матрица). С такъв тип указател можем да използваме синтаксиса с двете квадратни скоби. @@ -458,12 +458,12 @@ void g(int (*matrix)[2]) { Очевиден проблем, е че броя колони трябва да бъде константен (зададен в типа), ако искаме да ползваме двата чифта квадратни скоби. Няма ли начин да ги използваме с неконстантен брой колони? -Отговорът е =[не!]= +Отговорът е [=не!=] -Изкушаващо е да използваме `[int**]`, но този тип обозначава нещо друго: указател към указател. +Изкушаващо е да използваме [`int**`], но този тип обозначава нещо друго: указател към указател. -Ако имаме `[int** x]`, то тогава `[x[2][1]]` =[няма]= да бъде еквивалентно на `[*(x + 2 * колони + 1)]`! -Ще бъде еквивалентно на `[*(*(x + 2) + 1)]`! +Ако имаме [`int** x`], то тогава [`x[2][1]`] [=няма=] да бъде еквивалентно на [`*(x + 2 * колони + 1)`]! +Ще бъде еквивалентно на [`*(*(x + 2) + 1)`]! Това защо е така ще разберем когато учим динамична памет. Тогава, матриците ни няма да бъдат последователност от елементи, ами ще бъдат последователност от (указатели към) масиви. |