Съдържание

 

  1. Въведение в класовете и обектите
  2. Използване на функциите
  3. Как се дефинира клас и създават обекти в С++
  4. Правилата за имена на класове

 

Въведение в класовете и обектите

„Обектно-ориентираното програмиране (ООП) е парадигма в компютърното програмиране, при която една програмна система се моделира като набор от обекти, които взаимодействат помежду си, за разлика от традиционното виждане, в което една програма е списък от инструкции, които компютърът изпълнява. Всеки обект е способен да получава съобщения, обработва данни и праща съобщения на други обекти“ – Wikipedia

Може да си представите обектитe като хора – всеки човек е уникален, той има цвят на косата, очите, височина, тегло… Но всичките попадаме в един клас, класа човек (хомо сапиенс). Класовете много си приличат със структурите в C++, основната разлика e, че по подразбиране при класовете всичко е private, а при структурите public (след малко ще разберете какво значи това).

Как се дефинира клас в С++.

Това става с ключовата дума class. Те се декларират извън обсега на функциите. Сега ще декларираме клас животни. Всяко животно ще има име, години, място на обитаване(суша, море) и предпочитана храна (дали са месоядни, тревопасни или всеядни).

  1. #include <iostream>
  2. #include <string>
  3. class Animal{
  4. public:
  5. string name; //име
  6. int age; // години
  7. string residence; // място на обитаване
  8. string food_type; // предпочитана храна
  9. }
  10. int main(){
  11. return 0;
  12. }

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

  1. #include <iostream>
  2. #include <string>
  3. class Animal{
  4. public:
  5. string name; //име
  6. int age; // години
  7. string residence; // място на обитаване
  8. string food_type; // предпочитана храна
  9. };
  10. int main(){
  11. Animal tiger; // Създаваме обект от клас Animal на име tiger
  12. return 0;
  13. }

Сега можем да зададем стойности на променливите в класа. Това става чрез оператора точка „.“.

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4. class Animal{
  5. public:
  6. string name; //име
  7. int age; // години
  8. string residence; //място на обитаване
  9. string food_type; // предпочитана храна
  10. };
  11. int main(){
  12. Animal tiger;
  13. tiger.name = „Gosho“;
  14. tiger.age = 1;
  15. tiger.residence = „terrestrial“;
  16. tiger.food_type = „carnivorous“;
  17. cout << tiger.name << “ „<<tiger.age<< “ „ <<tiger.residence << “ „<< tiger.food_type;
  18. return 0;
  19. }

 

Използване на функциите

Сега ще се запознаете с полетата на действие в класовете. Те биват public, private и protected.
Когато един член е в public, всичко в програмата има достъп до него и може да го променя.
Когато един член е в полето private, само класът в който е деклариран, има достъп до него, нищо друго няма пряк достъп до него.
Когато нещо е в полето protected, класът в който е деклариран, както и всички класове, които наследяват от него (за наследяване ще учим в следващ урок), могат да го достъпват.
Декларираме поле като напишем името му и след него двоеточие (:) т.е. public: , private:, protected:. По подразбиране всичко в класа е private, това значи, че ако не обозначите полето, в което трябва да действа променливата, тя ще бъде private.
Сега нека да сложим нашите променливи в полето private.

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4. class Animal{
  5. private:
  6. string name; //име
  7. int age; // години
  8. string residence; //място на обитаване
  9. string food_type; // предпочитана храна
  10. };
  11. int main(){
  12. Animal tiger;
  13. return 0;
  14. }

Сега ако опитате да дадете стойности на променливите чрез оператора „.“, няма да се получи, защото само класът има достъп до тях. За да достъпим елементи от полето, ще използваме методите get и set. Те често се използват, за да дават стойности на променливи от полето private.

  1. #include <iostream>
  2. #include <string>
  3. using namespace std;
  4. class Animal{
  5.       private:
  6.             string name; //име
  7.             int age; // години
  8.             string residence; // място на обитаване
  9.             string food_type; // предпочитана храна
  10.      public:
  11.             //Фунцкията, която ще дава стойността на name
  12.             void set_name(string animal_name){
  13.             name = animal_name;
  14.             }
  15.            // функцията, която ще връща стойността на name
  16.            string get_name(){
  17.            return name;
  18.            }
  19.           // Фунцкията, която ще дава стойността на age
  20.           void set_age (int animal_ages){
  21.           age = animal_ages;
  22.           }
  23.          // функцията, която ще връща стойността на age
  24.          int get_age(){
  25.          return age;
  26.          }
  27.         // Фунцкията, която ще дава стойността на residence
  28.         void set_residence(string animal_residence){
  29.         residence = animal_residence;
  30.         }
  31.        // функцията, която ще връща стойността на residence
  32.        string get_residence(){
  33.        return residence;
  34.        }
  35.       // Фунцкията, която ще дава стойността на food_type
  36.       void set_food_type(string animal_food_type){
  37.       food_type = animal_food_type;
  38.       }
  39.      // функцията, която ще връща стойността на food_type
  40.      string get_food_type(){
  41.      return food_type;
  42.      }
  43. };
  44. int main(){
  45. return 0;
  46. }

Сега ще дадем стойности на променливите чрез създадените методи. Те отново се извикват чрез оператора точка „.“.

  1. int main(){
  2.      Animal tiger;
  3.      tiger.set_name(„Tiger“);
  4.      tiger.set_age(1);
  5.      tiger.set_residence(„terrestrial“);
  6.      tiger.set_food_type(„carnivorous“);
  7.      cout << tiger.get_name() << “ „<< tiger.get_age() << “ „ << tiger.get_residence() << “ „ << tiger.get_food_type() << endl;
  8.      return 0;
  9. }

 

Правилата за имена на класове

Общоприето е имената на класовете да започват с главна буква. Правилата за имената на клас са същите като при променливите:
1. Имената са само на латиница или.
2. Няма празни пространства “ “ в името на класа.
3. Името трябва да започва с буква или „_“ не с цифра или друг специален знак.
4. Не може да има специални символи освен „_“.
5. Името на класа не може да е ключова дума от езика С++.

Задачи:
Дефинирайте клас коли(cars), който има следните променливи: марка, модел, година на производство, цвят, тип скоростна кутия(автоматик или ръчна), мощност на двигателя(в конски сили), тип на гориво(бензин/дизел/газ или газ/бензин), тип на мотора(V-образен/редови/боксер), кубатура на двигателя(в кубици и в литри), тегло, колко километра е извървяно с нея и булева променлива жена ли я кара true – да false – не. Всички променливи да са в полето private, въведете тяхната стойност от конзолата и я изведете.

Автор: SYNCHRO