В предишния урок се запознахме с променливите в C++. В този урок ще се запознаем с един по-специален тип променливи, наречени константи. Тези така наречени константи са променливи, които след като приемат дадена стойност, тя не може да бъде променяна. Тоест константата остава с тази стойност до края на изпълнението на програмата.

Декларация

Константите в C++ се декларират посредством ключовата дума const. Пример:

  1. const double PI = 3.14159265359;

Внимание: Константите трябва да се инициализират едновременно с декларацията им. Тоест едновременно с декларацията на константата, трябва да определите и стойността й. Следният код би довел до грешка при компилиране:

  1. const double PI;
  2. PI = 3.14159265359;

 

За какво са полезни константите?

На пръв поглед използването на константи може да изглежда безсмислено – питате се: „Какво ми пречи да използвам обикновени променливи и просто да не променям стойността им?“. Отговорът на въпроса е, че използването на променливи за константни стойности е ОПАСНО! Защо? Защото в един по-голям проект, в който нямате ясен поглед над целия код, може да се случи така, че някой неволно да промени тази „константа“ и след това всеки, който я използва, ще има проблеми, защото не получава очакваната стойност. Последствията са много загубено време в търсене на грешката. Когато променливата е декларирана като константа, дори някъде в кода някой да се опитата неволно да промени стойността, компилаторът ще изкара грешка при опит за компилация и грешката ще може да бъде отстранена на момента.

Дефинирани константи

Другият тип константи са дефинираните константи. Те се дефинират посредством ключовата дума define. Пример:

  1. #define PI 3.14159265359
  2. #define SEPARATOR „–„
  3. #define TABULATOR ‘\t’

Тези константи работят на съвсем друг принцип. Те не заемат място в паметта на компютъра. #define директивата не е C++ израз, тя е всъщност директива към предпроцесора (програма, която извършва предварителна обработка на информацията по време на компилацията).

Всъщност единственото нещо, което предпроцесора прави, когато срещне #define директива, е буквално да замести всяка поява на нейния идентификатор (в примера PI, SEPARATOR и TABULATOR) със стойността, с която те са дефинирани (съответно 3.14159265359, „–“ и ‘\t’).

В тази програма използваме дефинираните по-горе константи:

  1. //Лице и периметър на кръг с радиус 8
  2. #include <iostream>
  3. using namespace std;
  4. #define PI 3.14159265359
  5. #define SEPARATOR „–„
  6. #define TABULATOR ‘\t’
  7. int main ()
  8. {
  9.   double radius = 8;
  10.   double area, perimeter;
  11.   perimeter = 2 * PI * radius;
  12.   area = PI * radius * radius;
  13.   cout << TABULATOR;
  14.   cout << perimeter;
  15.   cout << SEPARATOR;
  16.   cout << area;
  17.   return 0;
  18. }

След като предпроцесорът си свърши работата, нашата програма изглежда по следния начин непосредствено преди компилация:

  1. //…
  2. // Тук е включена iostream библиотеката
  3. using namespace std;
  4. int main ()
  5. {
  6.   double radius = 8;
  7.   double area, perimeter;
  8.   perimeter = 2 * 3.14159265359 * radius;
  9.   area = 3.14159265359 * radius * radius;
  10.   cout << ‘\t’;
  11.   cout << perimeter;
  12.   cout << „–„;
  13.   cout << area;
  14.   return 0;
  15. }

Автор: Михаил Михайлов