OOP Tutorial

    Честопати се појавува одредена ситуација во програмирањето кога податоците или влезот е динамичен по природа, т.е. бројот на податочните ставки постојано се менува за време на извршувањето на програмата. Таква е ситуацијата каде што програмата е развиена за обработка на списоци на вработени во една организација. Списокот расте како што се додаваат имињата и се намалува како што се бришат имињата. Со зголемувањето на името, меморијата одвојува простор на списокот за да примат дополнителни ставки на податоци. Таквите ситуации во програмирањето бараат динамични техники за управување со меморијата.

Постојат два начина преку кои може да се доделат мемории за складирање на податоци. Двата начина се:

    Статичката распределба на меморијата: каде што меморијата за именуваните променливи е распределена од компајлерот. Точната големина и складирањето мора да бидат познати во времето на компајлирање, а за декларацијата на низата, големината треба да биде постојана.
    Динамичка распределба на меморијата: каде што распределбата на меморискиот простор се прави динамично во рамките на програмата и меморискиот сегмент . Во овој случај, точниот простор или бројот на ставката не мора да биде познат од компајлерот однапред. Покажувачите играат голема улога во овој случај.

    Програмерите можат динамично да одвојуваат простор за складирање додека програмата работи, но програмерите не можат да создаваат нови имиња на променливи "во лет", и поради оваа причина, динамичката распределба бара два критериума:

    Создавање на динамичен простор во меморијата
    Зачувување на нејзината адреса во покажувач (за да може да се пристапи до просторот)

    Де-распределбата на меморијата е исто така дел од овој концепт каде што се прави „чистење“ на просторот за променливи или друго складирање на податоци. Работа на програмерот е да распредели динамички креиран простор. За распределување на динамичка меморија, го користиме операторот за бришење. Со други зборови, динамичката алокација на меморијата се однесува на вршење на управување со меморијата за динамичко распределување на меморијата рачно.

    Да се распредели просторот динамично, користете оператор new, проследен со типот што се доделува.

    Еве дел од кодот што покажува употреба на new:

     new int;         //dinamicki alokacira integer tip

new double; // dinamicki alokacira double tip

new int[60]; //dinamicki alokacira niza od 60 elementi od integer tip

Горенаведените декларации не се толку корисни бидејќи распределениот простор нема имиња. Но, линиите напишани подолу се корисни:

    int * p;                  // декларира покажувач р
    p = new int;          // динамички алоцира int за полнење на адресата во р
    double * d;        // декларира покажувач d.
    d = new double; // динамички алоцира double за полнење на адресата во d

Операторот за бришење е потребен за да се ослободи мемориски простор. Синтаксата на користење на ова е:

delete promenliva;

Еве едноставна програма што го покажува концептот на динамичка распределба - алокација на меморијата:

Пример 1

#include <iostream>
using namespace std;

int main()
{
    double * vrednost = NULL;
    vrednost= new double;
    *vrednost= 38184.26;
    cout << "Vrednosta e : " << *vrednost<< endl;
    delete vrednost;
}

Ако сакате да одвоите меморија за низа карактери, т.е. низа од 40 карактери. Користејќи ја истата синтакса, можете динамично да ја распределувате меморијата како што е прикажано подолу.

char * niza = NULL; // Покажувачот иницијализиран со NULL вредност
niza = new char [40]; // Резервира меморија за променливата

Пример 2

#include<iostream>

using namespace std;

int main() {

        int x, n;

        cout << "Kolku elementi ima nizata?" << "\n";

        cin >>n;

        int *arr = new int(n);

        cout << "Napolnete ja nizata so " << n << " celi broevi" << endl;

        for (x = 0; x < n; x++) {

               cin >> arr[x];

        cout << "Vie gi vnesovte slednite celi broevi : ";

        for (x = 0; x < n; x++) {

               cout << arr[x] << " ";

        cout << endl;

        delete [] arr;

        return 0;

Пример 3

#include <iostream>

using namespace std;

int main() {

    int num;

    cout << "Vnesete broj na ucenici : ";

    cin >> num;

    float* ptr;

    // memoriska alokacija na num - broj na  float memoriski lokacii za vnes

    ptr = new float[num];

    cout << "Vnesete gi prosecite na ucenicite ." << endl;

    for (int i = 0; i < num; ++i) {

        cout << "Ucenik " << i + 1 << ": ";

        cin >> *(ptr + i);

    cout << "\nPrikaz na prosecite na ucenicite ." << endl;

    for (int i = 0; i < num; ++i) {

        cout << "Ucenik " << i + 1 << " :" << *(ptr + i) << endl;

    // Osloboduvanje - brisenje na memorijata

    delete[] ptr;

    return 0;

Динамичка алокација (распределување) на меморија со користење на класи, конструктор и деструктор

#include <iostream>
using namespace std; 

class stud {
public:
    stud()
    {
        cout << "Konstruktor " << endl;
    }
    ~stud()
    {
        cout << "Destruktor " << endl;
    }
};

int main()
{
    stud * S = new stud[6];
    delete[] S;
}

Конструкторот ќе биде повикан шест пати бидејќи распределуваме меморија на шест објекти од класата „stud“. Исто така, деструкторот ќе биде повикан шест пати за време на секој од овие објекти.

Пример

// C++ dynamicka alokacija na klasa - objekt so koristenje na pointer kon objekt
#include <iostream>
using namespace std;
class zid // deklaracija na klasa
    {
        int dolzina; // dve privatni promenlivi clenovi na klasata
        int sirina;
    public:
        zid(); // Default konstruktor deklaracija
        void set_vrednosti(int nova_dolzina, int nova_sirina); // dve funkcii - metodi
        int get_povrsina();
    };
zid::zid() // Default konstruktor
{
    dolzina = 8; //Default konstruktorot im dava pocetni vrednosti na promenlivite na objektot
    sirina = 8;
}
void zid::set_vrednosti(int nova_dolzina, int nova_sirina) // metod-funkcija dava vrednosti na promenlivite na objektot dobieni od main
{
    dolzina = nova_dolzina;
    sirina = nova_sirina;
}
int zid::get_povrsina() // ovoj metod - funkcija presmetuva vrednosti na povrsinata na klasata zid
{
    return (dolzina * sirina);
}
int main()
{
    // Deklariranje na tri objekti od tip-klasa zid
    zid mal_zid, sreden_zid, golem_zid;
    // a pointer kon objekt od tip-klasa zid
    zid *point;
    mal_zid.set_vrednosti(5, 7); // overriding na default konstruktor so davanje vrednosti na promenlivite na objektite mal i golem zid
    golem_zid.set_vrednosti(15, 20);
    point = new zid;       //gi koristi default vrednostite obezbedeni od konstruktorot na ovoj nov objekt pokazuvan od pointer
    cout<<"Za mal_zid.vrednosti(5, 7): ";
    cout<<"Povrsinata na mal_zid e "<<mal_zid.get_povrsina()<<endl<<endl;
    cout<<"Koristen default konstruktor so vrednosti sreden_zid.vrednosti(8, 8): ";
    cout<<"Povrsinata na sreden_zid e "<<sreden_zid.get_povrsina()<<endl<<endl;
    cout<<"Za golem_zid.vrednosti(15, 20): ";
    cout<<"Povrsinata na golem_zid e "<<golem_zid.get_povrsina()<<endl<<endl;
    cout<<"Za vrednosti od default konstruktor , point->get_povrsina(): ";
    cout<<"Nova povrsina na zid "<<point->get_povrsina()<<endl<<endl;
    cout<<"Za novi vrednosti, point->vrednosti(12, 12): ";
    // novi vrednosti go override konstruktorot
    point->set_vrednosti(12, 12);
    cout<<"Nova povrsina na zid "<<point->get_povrsina()<<endl<<endl;
    delete point;
    point = NULL;
    return 0;
}

OOП Динамичка алокација (распределување) на меморија. Оператор new