Иницилиализиране на променливи

Иницилиазиране - присвояване на начална стойност на променливи.

За променливите може да се разпредели динамична памет:

В C чрез стандартни функции

В С++ чрез стандартни функции и чрез операции за разпределение и освобождаване на динамична памет.

Всяка променлива може да бъде инициализирана при нейното дефиниране по следния начин:

        име_на_тип име_на_променлива = израз;

Променлива се инициализира като след името й се постави символ за присвояване и желаната начална стойност:

        double pi = 3.1415927;

Ако за променливата се разпределя памет в областта за статични данни, то изразът трябва да бъде константен.

Ако паметта се заделя в програмния стек, то изразът може да бъде произволен.

Ако променливата е вътрешна пресмятането на израза е всеки път, а static int i=5; става веднъж и след това променливата е инициализирана.

Ако вътршната променлива е автоматична, то тя се инициализира всеки път, когато се извиква функцията.

Ако за променлива се отделя памет в областта за статични данни, то тя запазва своите стойности докато не се промени явно с израз на присвояване. Примерно вътрешните статични промелниви се инициализират само 1 път и запазват своята стойност само веднъж. Ако се налога тази стойност да се промени става чрез израз за присвояване.

Вътрешните променливи могат да се иницилиазират при дефиниция или чрез израз за присвояване.

Пример:

        void f1(int x, int y)
        {
                int i=1;
                int j = x*y;
                ............
        }

Еквивалентно на:

        void f1(int x, int y)
        {
                int i;
                int j;
                i=1;
                j=x*y;
                ........
        }

Note

Препоръчва се ползването на 1вия вариант.

Той е по-четим и разбираем. А и компилаторът създава по-ефективна програма, която работи по-ефективно.

Масивите могат да бъдат инициализирани при тяхното дефиниране с помоща на списък от начални стойности на елементите. Списъкът се поставя в {}.

        int list[5] = { 0, 1, 2, 3, 4};

Еквивалентно на:

        int list[] = {0,1,2,3,4};

Подреждането на началните стойности съответства на реда за разполагане на елементи на масиви в оперативната памет.

        int mat[3][3] = { 0,1,2,3,4,5,6,7,8 };

Възможно е да се направи инициализиране по редове:

        int mat[3][3] = {
                                                {0,1,2},
                                                {3,4,5},
                                                {6,7,8},
                                        };

Кодът от предните два примера е напълно еквивалентен.

Инициализиране на символен масив - общо правило - чрез списък от символи:

        char name[6]={'P','E','T','E','R','\0'};

Възможно е и инициализация от следния вид:

        char name[6] = "PETER";
        // еквивалентно с:
        // char name[] = "PETER";

В този случай:

1. не се използват "{}"
2. не се задава '\0' ( нулев бит ). Той се добавя автоматично от компилатора.

Последнота налага следното правило:

Броят на елементите на масива трябва да е поне с 1 по-голям от броя на символите в низовите константи.

Ако броят на началните стойности е по-малък от броя на елементите на масива, то останалите 'неизползвани' елементи се анулират.

Ако броят на началните стойности е по-голям от броя на елементите на масива, то получавам съобщение за грешка.

Възможно е броят на елементите да не се задава. В този случай компилаторът приема, че броя на елементите е равен на броя на началните стойности.

При многомерни масиви може да не се зададе само първата размерност.

В C++ чрез ключовата дума const може да се дефинира променлива от тип const. Тя задължително се инициализира при дефинирането й и тази стойност не може да бъде променяна.

Примери:

        const double eps=0.001;
        const double pi=3.14
        const int initial = 100;
        const int array[] = {1,2,3};
        
        void f( const int a)
        {
                // Тяло на функцията;
        }

Note

Формален параметър на функция може да се декларира от тип const!

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

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

C++ дава възможност по този начин ясно да се заяви, че нещо не може ( бива ) да се случва.