diff options
2 files changed, 348 insertions, 0 deletions
| -rw-r--r-- | Sem. 05/README.md | 196 | ||||
| -rw-r--r-- | Sem. 05/task.cpp | 152 |
diff --git a/Sem. 05/README.md b/Sem. 05/README.md new file mode 100644 index 0000000..063a054 --- /dev/null +++ b/Sem. 05/README.md @@ -0,0 +1,196 @@ +# Член-функции. Конструктори и деструктор. Модификатори за достъп. Капсулация.
+
+## Член-функции.
+Член-функциите са функции, които работят с член-данните на обекта от дадена структура.
+ ```c++
+struct Point
+{
+ int x;
+ int y
+};
+bool isInFirstQuadrant(const Point& p)
+{
+ return p.x >= 0 && p.y >= 0;
+}
+int main()
+{
+ Point p1 = {3, 4};
+ Point p2 = {-9, 8};
+ cout << isInFirstQuadrant(p1) << endl;
+ cout << isInFirstQuadrant(p2) << endl;
+}
+ ```
+
+ Може функцията да бъде член-функция:
+ ```c++
+struct Point
+{
+ int x;
+ int y
+ bool isInFirstQuadrant()
+ {
+ return x >= 0 && y >= 0;
+ }
+};
+
+int main()
+{
+ Point p1 = {3, 4};
+ Point p2 = {-9, 8};
+ cout << p1.isInFirstQuadrant() << endl;
+ cout << p2.isInFirstQuadrant() << endl;
+}
+ ```
+#
+**Член-функциите**:
+
+ - Работят с член-данните на класа.
+ - Извикват се с обект на класа
+
+ - Компилаторът преобразува всяка **член-функция** на дадена структура в
+ обикновена функция с уникално име и един допълнителен параметър
+ –**указател към обекта**.
+
+**Константни член-функции**:
+
+ - Не променят член-данните на структурата.
+ - Оказва се чрез записването на ключовата дума **const** в декларацията и в края на заглавието в дефиницията им
+ - Могат да се извикват от константни обекти.
+## Конструктори и деструктор.
+
+**Жизнен цикъл на обект**:
+ - Създаване на обект в даден scope – заделя се памет и член-данните се инициализират.
+ - Достига се до края на скоупа(област).
+ - Обектът и паметта, която е асоциирана с него се разрушава.
+
+**Конструктор**:
+ - Извиква се веднъж - при създаването на обекта.
+ - Не се оказва експлицитно тип на връщане (връща констатна референция).
+ - Има същото име като класа.
+
+ **Деструктор**:
+ - Извиква се веднъж - при изтриването на обекта.
+ - Не се оказва експлицитно тип на връщане.
+ - Има същото име като класа със симовла '~' в началото.
+
+ ```c++
+
+#include <iostream>
+
+using namespace std;
+
+
+struct Test
+{
+ Test()
+ {
+ cout << "Object is created" <<endl;
+ }
+
+ ~Test()
+ {
+ cout << "Object is destroyed" <<endl;
+ }
+ int a;
+ int b;
+};
+
+int main()
+{
+ while ()
+ {
+ Test t;// Object is created
+ if ()
+ {
+ Test t2; // Object is created
+
+ }// Object is destroyed (t2)
+
+ }//Object is destroyed (t)
+}
+
+ ```
+ ## Капсулация (encapsulation).
+Понякога искаме потребителите да **нямат достъп до всички член-данни и методи на даден клас**.
+Това е така, защото тяхната промяна може да доведе до **неочаквано поведение** на нашата програма. Принципът за **капсулация** ни помага като позволява да определим кои методи и атрибути може да използват потребителите на нашия клас.
+
+ **Модификатор за достъп**:
+
+| Модификатор за достъп: | Достъп: |
+|------------------------|---------------------------------|
+| private | В текущия клас. |
+| protected | В текущия клас и *наследниците. |
+| public | За всеки |
+
+**Пример за get-ъри и set-ъри**
+
+ ```c++
+
+#include <iostream>
+
+using namespace std;
+
+
+struct Student
+{
+private:
+ int grade;
+ int age;
+public:
+ Student(int grade, int age)
+ {
+ setGrade(grade);
+ setAge(age);
+ }
+ int getGrade()
+ {
+ return grade;
+ }
+ int getAge()
+ {
+ return age;
+ }
+ void setGrade(int grade)
+ {
+ if(grade >= 2 && grade <= 6)
+ this->grade = grade;
+ }
+ int setAge(int age)
+ {
+ if(age >= 0)
+ this->age = age;
+ }
+};
+
+int main()
+{
+ while ()
+ {
+ Test t;// Object is created
+ if ()
+ {
+ Test t2; // Object is created
+
+ }// Object is destroyed (t)
+
+ }//Object is destroyed (t2)
+}
+
+ ```
+
+#### Задача
+Реализирайте клас/структура интервал, който представлява интервал [a,b] (задължително а <= b) от реалната права. Нашият интервал ще бъде дискретен - началото и краят му ще бъдат цели числа и ще разглеждаме само точки, които са цели числа. Релизирайте следният интерфейс:
+
+ - Подразбиращ се контруктор, който създава интервала [0,0].
+ - Конструктор, който приема двата параметъра. Ако a<=b, то създава интервала [a,b]. В противен случай, създава [0,0].
+ - Член-функция, която връща дължината на интервала.
+ - Член-функция, която приема число и проверява дали е част от интервала.
+ - Член-функция, която връща броя на простите числа в интервала.
+ - Член-функция, която връща броя на числата в интервала, които са палиндорми.
+ - Член-функция, която връща броя на числата, които нямат повтарящи цифри.
+ - Член-функция, която връща дали началото и края на интервала са степени на 2-ката. ([2,16] - истина)
+ - Член-фунцкия, която приема интервал и връща сечението на текущия интервал с подадения. (Сечението на [1, 5] [3, 7] e [3, 5]).
+ - Член-фунцкия, която приема интервал и връща дали дадения интервал е поддинтервал на дадения.
+
+
+
diff --git a/Sem. 05/task.cpp b/Sem. 05/task.cpp new file mode 100644 index 0000000..589cc61 --- /dev/null +++ b/Sem. 05/task.cpp @@ -0,0 +1,152 @@ +#include <iostream>
+#include <algorithm>
+#include <fstream>
+#include <functional>
+
+using namespace std;
+
+bool isPrime(int n)
+{
+ double temp = sqrt(n);
+ for (int i = 2; i <= temp; i++)
+ {
+ if (n % i == 0)
+ return false;
+ }
+ return true;
+}
+bool isPalindorme(int n)
+{
+ int reversed = 0;
+
+ while (n != 0)
+ {
+ int lastDigit = n % 10;
+ (reversed *= 10) += lastDigit;
+ n /= 10;
+ }
+ return n == reversed;
+}
+bool containsOnlyDistinctNumbers(int n)
+{
+ bool digits[10];
+ for (int i = 0; i < 10; i++)
+ digits[i] = false;
+
+ while (n != 0)
+ {
+ int lastDigit = n % 10;
+ if (digits[lastDigit])
+ return false;
+ digits[n % 10] = true;
+ n /= 10;
+ }
+ return true;
+}
+struct Interval
+{
+private:
+ int a;
+ int b;
+
+ size_t countNumbersInIntervalCondition(bool(*pred)(int)) const
+ {
+ size_t count = 0;
+ for (int i = a; i <= b; i++)
+ {
+ if (pred(i))
+ count++;
+ }
+ return count;
+ }
+public:
+ Interval() : Interval(0, 0) {}
+
+ Interval(int a, int b)
+ {
+ if (a > b)
+ a = b = 0;
+
+ this->a = a;
+ this->b = b;
+ }
+ int getA() const
+ {
+ return a;
+ }
+
+ int getB() const
+ {
+ return b;
+ }
+ void setA(int a)
+ {
+ if (a > b)
+ return;
+ this->a = a;
+ }
+
+ void setB(int b)
+ {
+ if (b < a)
+ return;
+ this->b = b;
+ }
+
+ size_t getLength() const
+ {
+ return b - a + 1;
+ }
+
+ bool isMemberOfInterval(int x) const
+ {
+ return (a <= x && x <= b);
+ }
+
+ size_t calcPrimeNumbersInTheInterval() const
+ {
+ return countNumbersInIntervalCondition(isPrime);
+ }
+
+ size_t calcPalindromicNumbersInTheInterval() const
+ {
+ return countNumbersInIntervalCondition(isPalindorme);
+ }
+
+ size_t calcDiffrentDigitNumbersInTheInverval() const
+ {
+ return countNumbersInIntervalCondition(containsOnlyDistinctNumbers);
+ }
+
+ bool areStartAndEndPowersOfTwo() const
+ {
+ return (a == 0 || (a & a - 1) == 0) && (b == 0 ||(b & b - 1) == 0);
+ }
+
+ Interval intersect(const Interval& other) const
+ {
+ if (b < other.getA() || a > other.getB())
+ return Interval(0, 0);
+
+ int newA = std::max(a, other.getA());
+ int newB = std::min(b, other.getB());
+
+ return Interval(newA, newB);
+ }
+ bool isSubInterval(const Interval& other) const
+ {
+ return a <= other.getA() && b >= other.getB();
+ }
+};
+
+int main()
+{
+ Interval i(1, 11);
+
+ cout << i.calcDiffrentDigitNumbersInTheInverval() <<endl;
+
+ cout << i.getLength()<<endl;
+
+
+}
+
|