Информатика: Глобални и локални променливи

SCOPE - правила на делокруг / подрачје на важење

Правилата на делокруг (scope) на променливи се однесуваат на видливоста и животниот век на објектот.

Глобални и локални променливи

C++ овозможува декларирање на променливи на два начини:

глобално(надвор од која било функција или блок)
локално (во одредена функција или блок).

Променливите кои се декларираат надвор од било кој блок се нарекуваат глобални променливи, а променливите кои се декларираат во потпрограмите се нарекуваат локални променливи. Самото нивно име ни зборува и за областа во која со нив може да се оперира, т.е. кога тие се достапни (видливи).

Променливите кои се декларирани глобално може да се користат на која било локација во програмата (во која било функција или блок). Од друга страна, променливите кои се декларирани локално може да се користат само во функцијата/блокот во кој се декларирани (и тоа, откако ќе бидат декларирани).

Глобалните променливи се статички и тие живеат цело време додека се извршува програмата.

И локалните променливи можат да се декларираат со зборот static.

На пример: static int broj=n;

static double iznos;

Глобалните променливи живеат од моментот на нивното декларирање, до завршување на извршувањето на програмата. Иницијализација: само еднаш. (ако не се иницијализирани автоматски се иницијализираат на 0 - сите битови 0). Локалните статички променливи живеат од едно до друго повикување на функцијата. При новото повикување на функцијата тие ја имаат состојбата (вредноста) добиена во претходното повикување.

Локалните променливи живеат од моментот на извршување на дефиницијата, до крајот на извршување на блокот (функцијата) во која се дефинирани. Тие се автоматски by default. Автоматските променливи се декларираат со зборот auto.

Пример : auto int a=0 ; // isto so int a=0; во програмскиот јазик C

vo C++ не може да се користи горната декларацијa

( two or more data types in declaration of ‘a’)

auto a=0.5 ; // isto so float a=0.5 во програмскиот јазик C ++

automatic variable is a local variable which is allocated and deallocated automatically when program flow enters and leaves the variable's scope.

There are two separate concepts here

scope, which determines where a name can be accessed - global and local
storage duration, which determines when a variable is created and destroyed - static and auto

Програма со која се демонстрира примена на статички и нестатички променливи

#include <iostream>

using namespace std;

int a=0; //Globalna promenliva

void increase() // Se zgolemuva globalnata promenliva

{

a++;

cout<<"a= "<<a<<endl;

}

/*Se namaluva vrednosta na lokalnata promenliva a.

Globalnata promenliva ja zadrzava svojata vrednost*/

void decrease()

{

//Ova e nezavisna promenliva vo odnos na globalnata a.

int a=0;

a--;

cout<< "a= "<<a<<endl;

}

void nestaticna()

{ //Nestaticnite promenlivi ne ja zadrzuvaat vrednosta pri povik na funkcijata

int s=0;

s++;

cout<< "s= "<<s<<endl;

}

void staticna()

{ /* Statickite promenlive ja zadrzuvat vrednosta pri povik na funkcijata

Inicijalizacija e samo pri povik */

static int s=0;

s++;

cout<<"s= "<< s<<endl;

}

int main()

{ //Lokalni promenlivi za funkcijata main

int i, x=3;

cout<< "x= "<<x<<endl;

for(i=0; i<3; i++)

{

/*Promenlivata vo ovoj blok e nezavisna od nadvoresnata promenlive.

Ovde se koristi promenliva x, lokalna za ovoj blok so vrednsot 5,

dodeka orginalno x i ponataka ima vrednost 3*/

int x=5;

cout<<"x= "<<x<<endl;

}

// Vo ovoj prostor x ima vrednost 3

cout<< "x= "<<x<<endl;

increase();

decrease();

cout<< "a= "<<a<<endl; //Globalna promenliva a

// Demonstracija na nestaticki promenlivi

for(i=0; i<3; i++)

nestaticna();

// Demonstracija na staticki promenlivi

for(i=0; i<3; i++)

staticna();

return 0;

}

Излез

x= 3

x= 5

x= 3

a= 1

a= -1

a= 1

s= 1

s= 2

s= 3

Променливите кои се декларирани во внатрешноста на одреден блок или функција може да имаат исто име со друга променлива (која е дефинирана глобално или во блок). Во тој случај, променливата која е декларирана во внатрешноста (најлокалната променлива) ги крие останатите променливи со исто име. Доколку една локална променлива (promenliva) крие глобална променлива со исто име (promenliva), можеме да го искористиме операторот :: за да пристапиме до содржината на глобалната променлива (::promenliva). Иако C++ ги нуди овие можности, обидувајте се да избегнувате креирање на повеќе променливи со исто име (со тоа програмата станува посложена за разбирање).

#include <iostream>

using namespace std;

int promenliva;                           //globalna promenliva

int main()

{

      int a = 10, b = 20, c = 30;         //lokalni promenlivi

      if (b > a)

{

            int d;                        //lokalna promenliva

            d = a+b;                      //vidliva samo vo ovoj blok

            cout << d << endl;            //pechati '30'

}

      //promenlivata 'd' ne e vidliva tuka

      int promenliva;

      promenliva = 10;                    //lokalna promenliva

      ::promenliva = 100;                 //globalna promenliva

      cout << promenliva << endl;         //pechati '10'

      cout << ::promenliva << endl;       //pechati '100'

      return 0;

}

Локални променливи

ПРоменлви кои се декларирани во функцијата
се користат само за наредби кои се во функцијата
Се креираат кога се влезе во нивниот простор (scope), a се уништуваат кога се излезе од него
меморискиот простор е алоциран (одреден, одвоен) во текот на извршување на програмата

Глобални променливи

променливи декларирани надвор од сите блокови
видливи се на сите програмски нивоа
се дефинираат само еднаш
доколку не е доделена вредност се иницијализирани на почетна вредност 0
пристапни се секаде во програмата

- Меморискиот простор е резервиран пред извршување на програмата

Бидејќи локалниот scope го поништува глобалниот, променлива со исто име како и глобална променлива оневозможува пристап на глобалната променлива во локалниот простор

Пример за локални и глобални варијабли

Грешка !!!

#include <iostream>

using namespace std;
void Potprogram()
{

int i=5;

}

int main()
{ Potprogram();
cout <<i;
return 0;
}

Што ќе се прикаже

b=4 a=1 b=2 c=3

11113311 177117

#include <iostream> float average( int num1, int num2 ); /* declaring function named average */ int main(){ using namespace std; int num1, num2; float c; cout << "Enter first number" << endl; cin >> num1; cout << "Enter second number" << endl; cin >> num2; c = average( num1, num2 ); /* calling the function average and storing its value in c*/ cout << "Average is " << c << endl; return 0; } float average( int num1, int num2 ) /* function */ { float avg; /* declaring local variable */ avg = ( num1 + num2 )/2.0; return avg; /* returning the average value */ }

Функции кои не враќаат вредност (void)

без параметри

# include <iostream>
using namespace std;
void prime();
int main()
{ // No argument is passed to prime()
prime();
return 0;
}
// Return type of function is void because value is not returned.
void prime()
{
int num, i, flag = 0;
cout << "Enter a positive integer enter to check: ";
cin >> num;
for(i = 2; i <= num/2; ++i)
{
if(num % i == 0)
{
flag = 1;
break;
}
}
if (flag == 1)
cout << num << " is not a prime number.";
else
cout << num << " is a prime number.";
}
со параметри

void prime(int n);

int main()

// Argument num is passed to the function prime()

// There is no return value to calling function.

void prime(int n)

Функции кои враќаат вредност

без параметри

int prime();

int main()

// No argument is passed to prime()

// Return type of function is int

int prime()

со параметри

int prime(int n);

int main()

// Argument num is passed to check() function

/* This function returns integer value. */

int prime(int n)

The call by pointer method of passing arguments to a function copies the address of an argument into the formal parameter. Inside the function, the address is used to access the actual argument used in the call. This means that changes made to the parameter affect the passed argument.

To pass the value by pointer, argument pointers are passed to the functions just like any other value. So accordingly you need to declare the function parameters as pointer types as in the following function swap(), which exchanges the values of the two integer variables pointed to by its arguments.

// function definition to swap the values.

void swap(int *x, int *y)

{

int temp;

temp = *x; /* save the value at address x */

*x = *y; /* put y into x */

*y = temp; /* put x into y */

return;

}

To check the more detail about C++ pointers, kindly check C++ Pointers chapter.

For now, let us call the function swap() by passing values by pointer as in the following example:

#include <iostream>

using namespace std;

// function declaration

void swap(int *x, int *y);

int main ()

{

// local variable declaration:

int a = 100;

int b = 200;

cout << "Before swap, value of a :" << a << endl;

cout << "Before swap, value of b :" << b << endl;

/* calling a function to swap the values.

* &a indicates pointer to a ie. address of variable a and

* &b indicates pointer to b ie. address of variable b.

swap(&a, &b);

cout << "After swap, value of a :" << a << endl;

cout << "After swap, value of b :" << b << endl;

return 0;

}

When the above code is put together in a file, compiled and executed, it produces the following result:

Before swap, value of a :100

Before swap, value of b :200

After swap, value of a :200

After swap, value of b :100

Информатика

Глобални и локални променливи

Calling a function inside another

No comments: