Summary Files Commits Branches @commit @diff @stats
path: root / src / teaching / upp-2025 / cpp-pitfalls
diff options
context:
space:
mode:
Commit88a5b49611a0a4d1eb47ba86b9123159443ce4cb (patch)
Author
 Syndamia <kamen@syndamia.com>
2025-12-23 22:54:20 +0200
Committer
 Syndamia <kamen@syndamia.com>
2025-12-23 22:54:20 +0200
Files22ce3c36887f506898cc7636a80abf245ae240e7 /src/teaching/upp-2025/cpp-pitfalls
syndamia.com-88a5b49611a0a4d1eb47ba86b9123159443ce4cb.tar
syndamia.com-88a5b49611a0a4d1eb47ba86b9123159443ce4cb.tar.gz
syndamia.com-88a5b49611a0a4d1eb47ba86b9123159443ce4cb.zip
Parent0be8d4b427a0f0944552769edc9a080dbaf79cee (diff)
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.du112
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)`]!
Това защо е така ще разберем когато учим динамична памет.
Тогава, матриците ни няма да бъдат последователност от елементи, ами ще бъдат последователност от (указатели към) масиви.