labs-Sasko

#include <iostream>
#include <cstring>
using namespace std;

class Automobile{
    private:
    char *marka; // din al.
    int *reg; // din al.
    int maxBrzina;

    public:
    Automobile(){} // default konstruktor
    Automobile(char *m, int *reg, int mb) // konstruktor so argumenti
    {
        marka = new char [strlen(m)+1];
        strcpy(marka,m);
        this->reg = new int [5];
        for(int i=0;i<5;i++)
            this->reg[i]=reg[i];
        maxBrzina=mb;
    }
    Automobile (const Automobile &a) // copy konstruktor
    {
        marka = new char [strlen(a.marka)+1];
        strcpy(marka,a.marka);
        reg = new int [5];
        for(int i=0;i<5;i++)
            reg[i]=a.reg[i];
        maxBrzina=a.maxBrzina;
    }
    Automobile& operator= (const Automobile &a) // preoptovaruvanje na =
    {
        if(this!=&a)
        {
            delete [] marka;
            delete [] reg;
                marka = new char [strlen(a.marka)+1];
                strcpy(marka,a.marka);
                reg = new int [5];
                for(int i=0;i<5;i++)
                        reg[i]=a.reg[i];
                maxBrzina=a.maxBrzina;
        }
        return *this;
    }

    ~Automobile(){delete [] marka; delete [] reg;}

    int getMaxB()
    {return maxBrzina;}

     bool operator== (const Automobile &a) {
        for(int i = 0; i < 5; ++i) {
        if(reg[i] != a.reg[i])
                return false;
                return true;
    }
  }
  //operator za pecatenje
  friend ostream& operator<< (ostream &out, const Automobile &a) {
    return out << "Marka\t" << a.marka << "\tRegistracija[ " << a.reg[0] << " " << a.reg[1] << " " << a.reg[2] << " " << a.reg[3] << " " << a.reg[4] << " ]";
  }
};


class RentACar{
    private:
    char ime[100];
    Automobile *niza;
    int broj;

    public:
    // default
    RentACar(){}

    // konstruktor so argumenti
    RentACar(char* ime=" ", Automobile *niza=NULL, int br=0)
    {
        strcpy(this->ime,ime);
        for(int i=0;i<br;i++)
            this->niza[i]=niza[i];
        broj=br;
    }

    // so eden argument
    RentACar(const char *ime)
    {
        strcpy(this->ime, ime);
        niza=NULL;
        broj=0;
    }

    // copy
    RentACar(const RentACar &a)
    {
        strcpy(ime,a.ime);
        for(int i=0;i<a.broj;i++)
            niza[i]=a.niza[i];
        broj=a.broj;
    }

    // preoptovaruvanje na =
    RentACar& operator= (const RentACar &a)
    {
        if(this!=&a){
            delete [] niza;
            strcpy(ime,a.ime);
        for(int i=0;i<a.broj;i++)
            niza[i]=a.niza[i];
        broj=a.broj;
        }
           return *this;
    }

    // += za dodavanje nov avtomobil
    RentACar& operator+= (const Automobile &a) {
    if(broj == 0) {
      niza = new Automobile[1];
      niza[0] = a;
      broj++;
    }
    else {
      Automobile *temp = niza;
      niza = new Automobile[broj+1];
      for(int i = 0; i < broj; ++i) {
        niza[i] = temp[i];
      }
      delete [] temp;
      niza[broj] = a;
      broj++;
    }
    return *this;
  }

    // -= za otstranuvanje
     RentACar& operator-= (const Automobile &a) {
    Automobile *temp = new Automobile[broj];
    int novBroj = 0;
    for(int i = 0; i < broj; ++i) {
      if(!(niza[i]==a)) {
        temp[novBroj] = niza[i];
        novBroj++;
      }
    }
    delete [] niza;
    niza = temp;
    broj = novBroj;
    return *this;
  }

    // destruktor
    ~RentACar(){delete [] niza;}

    // f-ja
      void pecatiNadBrzina(int maxBrzina) {
        for(int i = 0; i < broj; ++i) {
                if(niza[i].getMaxB() > maxBrzina) {
        cout << niza[i] << endl;
      }
    }
  }

};

int main()
{
   RentACar agencija("FINKI-Car");
   int n;
   cin>>n;

   for (int i=0;i<n;i++)
   {
        char marka[100];
        int regisracija[5];
        int maximumBrzina;

        cin>>marka;

        for (int i=0;i<5;i++)
                cin>>regisracija[i];

        cin>>maximumBrzina;

        Automobile nov=Automobile(marka,regisracija,maximumBrzina);

        //dodavanje na avtomobil
        agencija+=nov;

   }
    //se cita grehsniot avtmobil, za koj shto avtmobilot so ista registracija treba da se izbrishe
    char marka[100];
    int regisracija[5];
    int maximumBrzina;
    cin>>marka;
    for (int i=0;i<5;i++)
    cin>>regisracija[i];
    cin>>maximumBrzina;

    Automobile greshka=Automobile(marka,regisracija,maximumBrzina);

    //brishenje na avtomobil
    agencija-=greshka;
    cout << "FINKI-Car" << endl;
    agencija.pecatiNadBrzina(150);

    return 0;
}




Уредување на дом
Во оваа задача е потребно да уредите даден дом со маси. Креирајте класа Masa со следниве
атрибути:
должина (целобројна вредност)
ширина (целобројна вредност)
конструктор со и без параметри и метода pecati().
Креирајте класа Soba која содржи:
маса (објект од класата Маса)
должина на собата (целобројна вредност)
ширина на собата (целобројна вредност)
конструктор со и без параметри и метода pecati() во која се повикува и pecati() за објектот Masa.
Креирајте класа Kukja со атрибути:
соба (објект од класата Soba)
адреса (низа од 50 знаци), и соодветни методи.
конструктор со и без параметри, деструктор и метода pecati() во која се повикува и pecati() за
објектот Soba.
//vasiot kod ovde
#include <iostream>
#include <cstring>
using namespace std;
class Masa{
 private:
 int dolzhina;
 int shirina;
 public:
 Masa(){}
 Masa(int s,int d){
 dolzhina=d; shirina=s;
 }
 void pechatim(){
 cout<<"Masa: "<<shirina<<" "<<dolzhina;
 }
};
class Soba{
 private:
 Masa m;
 int dolzhina;
 int shirina;
 public:
 Soba(){}
 Soba(int s,int d,Masa mas){
 shirina=s; dolzhina=d; m=mas;
 }
 void pechatis(){
 cout<<"Soba: "<<shirina<<" "<<dolzhina<<" "; m.pechatim(); cout<<" ";
 }
};
class Kukja{
 private:
 Soba s;
 char adresa[50];
 public:
 Kukja(){}
 Kukja(Soba sob,char *a){
 strncpy(adresa,a,50);
 s=sob;
 }
 ~Kukja(){}
 void pecati(){
 cout<<"Adresa: "<<adresa<<" "; s.pechatis(); cout<<endl;
 }

};
int main(){
 int n;
 cin>>n;
 for(int i=0;i<n;i++){
 int masaSirina,masaDolzina;
 cin>>masaSirina;
 cin>>masaDolzina;
 Masa m(masaSirina,masaDolzina);
 int sobaSirina,sobaDolzina;
 cin>>sobaSirina;
 cin>>sobaDolzina;
 Soba s(sobaSirina,sobaDolzina,m);
 char adresa[30];
 cin>>adresa;
 Kukja k(s,adresa);
 k.pecati();
}

 return 0;
}
Договор
Да се дефинира класа Potpisuvac во која се чуваат информации за:
име (низа од максимум 20 знаци)
презиме (низа од максимум 20 знаци)
ЕМБГ (низа од максимум 14 знаци)
За класата да се дефинира copy конструктор, default конструктор и конструктор со аргументи.
Да се дефинира класа Dogovor, во која се чуваат информации за:
број на договор (int),
категорија на договор (низа од 50 знаци),
поле од 3 потпишувачи на договорот (објекти од класата Potpisuvac) Во класата да се додаде
метод кој ќе проверува дали постојат два исти потпишувачи (имаат ист ЕМБГ).
#include <iostream>
#include <cstring>
using namespace std;
class Potpisuvac
{
//vasiot kod ovde
 private:
 char ime[20];
 char prezime[20];
 char embg[14];
 public:
 Potpisuvac(const Potpisuvac &p){
  strncpy(ime,p.ime,20);
 strncpy(prezime,p.prezime,20);
 strncpy(embg,p.embg,14);
 }
 Potpisuvac(char *i="no name",char *p="no surname",char *e="no embg"){
 strncpy(ime,i,20);
 strncpy(prezime,p,20);
 strncpy(embg,e,14);
 }
 char* getEmbg(){
 return embg;
 }
};
class Dogovor
{
 //vasiot kod ovde
 private:
 int brNaDog;
 char kategorija[50];
 Potpisuvac potpisuvaci[3];
 public:
 Dogovor(){}
 Dogovor(int br,char *k,Potpisuvac *p){
 brNaDog=br;
 strncpy(kategorija,k,50);
 potpisuvaci[0]=p[0];
 potpisuvaci[1]=p[1];
 potpisuvaci[2]=p[2];
 }
 bool proverka(){
 for(int i=0;i<3;i++){
 for(int j=i+1;j<3;j++){
 if(strcmp(potpisuvaci[i].getEmbg(),potpisuvaci[j].getEmbg())==0){
 return true;
 }
 }
 }
 return false;
 }
};
int main()
{
 char embg[13], ime[20], prezime[20], kategorija[20];
 int broj, n;
 cin >> n;
 for(int i = 0; i < n; i++){
 cin >> embg >> ime >> prezime;
 Potpisuvac p1(ime, prezime, embg);
 cin >> embg >> ime >> prezime;
 Potpisuvac p2(ime, prezime, embg);
 cin >> embg >> ime >> prezime;
 Potpisuvac p3(ime, prezime, embg);
 cin >> broj >> kategorija;
 Potpisuvac p[3];
 p[0] = p1; p[1] = p2; p[2] = p3;
 Dogovor d(broj, kategorija, p);
 cout << "Dogovor " << broj << ":" << endl;
 if(d.proverka() == true)
 cout << "Postojat potpishuvaci so ist EMBG" << endl;
 else
 cout << "Ne postojat potpishuvaci so ist EMBG" << endl;
 }
 return 0;
}
Фабрика
Креирајте класа Rabotnik која во себе содржи:
ime (низа од максимум 30 знаци)
prezime (низа од максимум 30 знаци)
plata (целобројна вредност)
За оваа класа да се креираат default конструктор и конструктор со аргументи. Да се
имплементираат и следните методи:
getPlata() која ја враќа платата на работникот
pecati() која ги печати името, презимето и платата.
Креирајте класа Fabrika во која има:
rabotnik [100] (низа од вработени)
brojVraboteni (целобројна вредност)
Во класта имплементирајте ги следните методи:
pecatiVraboteni() ги пречати сите вработени
pecatiSoPlata(int plata) ги печати сите вработени со плата поголема или еднаква на дадената во
аргументот (int plata).
Во главната функција се внесуваат податоци за n вработени. Притоа прво се несува n, па
податоците за сите n вработени. Во последниот ред се чита минималната плата.
На излез да се прикажат прво сите вработени, а потоа само оние со поголема плата од
минималната. Треба да се корисатат методите pecatiVraboteni и pecatiSoPlata!
#include <iostream>
#include <cstring>
using namespace std;
class Rabotnik{
 private:

 char ime[30];
 char prezime[30];
 int plata;

 public:

 Rabotnik(const Rabotnik &r){
 strncpy(ime,r.ime,30);
 strncpy(prezime,r.prezime,30);
 plata=r.plata;
 }
 Rabotnik(char *ime="no name",char*prezime="no surname",int plata=0){
 strncpy(this->ime,ime,30);
 strncpy(this->prezime,prezime,30);
 this->plata=plata;
 }
 int getPlata(){
 return plata;
 }
 void pecati(){
 cout<<ime<<" "<<prezime<<" "<<plata<<endl;
 }
 void setIme(char *ime){
 strncpy(this->ime,ime,30);
 }
 void setPrezime(char *prezime){
 strncpy(this->prezime,prezime,30);
 }
 void setPlata(int plata){
 this->plata=plata;
 }
};
class Fabrika{
 private:

 Rabotnik rabotnik[100];
 int brojVraboteni;

 public:
 Fabrika(){}
 Fabrika(int n,Rabotnik *r){
 for(int i=0;i<n;i++){
 rabotnik[i]=r[i];
 }
 brojVraboteni=n;
 }

 void pecatiVraboteni(){
 for(int i=0;i<brojVraboteni;i++){
 rabotnik[i].pecati();
 }
 }
 void pecatiSoPlata(int min){
 for(int i=0;i<brojVraboteni;i++){
 if(rabotnik[i].getPlata()>=min){
 rabotnik[i].pecati();
 }
 }
 }
};
int main(){
 int n;
 cin>>n;
 Rabotnik rabotnici[100];
 for(int i=0;i<n;i++){
 char ime[30],prezime[30];
 int plata;
 cin>>ime>>prezime>>plata;
 rabotnici[i].setIme(ime);
 rabotnici[i].setPrezime(prezime);
 rabotnici[i].setPlata(plata);
 }
 int minimalna;
 cin>>minimalna;
 Fabrika f(n,rabotnici);
 cout<<"Site vraboteni:"<<endl;
 f.pecatiVraboteni();
 cout<<"Vraboteni so plata povisoka od "<<minimalna<<" :"<<endl;
 f.pecatiSoPlata(minimalna);
 return 0;
}
Паркинг
Да се дефинира класа ParkingPlac во која се чуваат податоци за:
Адреса на плацот (низа од знаци, максимум 20),
Идентификациски број на плацот (динамичка низа од знаци),
Цена за паркирање за 1 час (цел број),
Заработка на паркинг плацот (цел број)
За потребите на класата да се имплементираат :
соодветни конструктори и деструктор, и потребните get-функции (погледнете ги повиците во main
функцијата)
функција pecati() за печатење на податоците за еден паркинг плац во следниот формат:
идентификациски_број адреса - X denari, ако X е заработката на паркинг плацот X не е 0
идентификациски_број адреса , ако X =0
функција platiCasovi(int casovi) која на заработката ја додава платената вредност за дадениот број
на часови.
функција daliIstaAdresa(ParkingPlac p) во која се споредува дали дадениот паркинг плац е на иста
адреса како паркинг плацот p.
Во дадената main функција прво се внесуваат n паркинг плацеви. Потоа се внесуваат m плаќања и
на крај се печатат сите паркинг плацеви од низата кои имаат иста адреса со дадениот паркинг
плац (објектот pCentar).
include<iostream>
//вашиот код
#include<cstring>
using namespace std;
class ParkingPlac{
 private:
 char adress[20];
 char *id;
 int priceph;
 int profit;
 public:
 ParkingPlac(char *adress=" ",char *id=" ",int priceph=0){
 this->priceph = priceph;
 strncpy(this->adress,adress,20);
 this->id = new char[strlen(id)];
 strncpy(this->id,id,strlen(id));
 this->profit=0;
 }
 ParkingPlac(const ParkingPlac &p){
 strncpy(this->adress,p.adress,20);
 this->priceph = p.priceph;
 this->profit = p.profit;
 this->id=new char[strlen(p.id)];
 strncpy(this->id,p.id,strlen(p.id));

 }
 ~ParkingPlac(){
 delete [] id;
 }
 ParkingPlac& operator=(const ParkingPlac& p){
 strncpy(adress,p.adress,20);
 strncpy(id,p.id,strlen(p.id));
 profit=p.profit;
 priceph=p.priceph;
 return *this;
 }
 void platiCasovi(int h){
 profit+=h*priceph;
 }
 bool daliIstaAdresa(ParkingPlac p){
 if(strcmp(adress,p.adress)==0) return true;
 else return false;
 }
 char* getId(){
 return id;
 }
 void pecati(){
 cout<<id<<" "<<adress;
 if(profit!=0) cout<<" - "<<profit<<" denari"<<endl;
 }

};
int main(){
ParkingPlac p[100];
int n,m;
char adresa[50],id[50];
int brojcasovi,cenacas;
cin>>n;
for (int i=0;i<n;i++){
 cin.get();
cin.getline(adresa,50);
cin>>id>>cenacas;
ParkingPlac edna(adresa,id,cenacas);

 //povik na operatorot =
 p[i]=edna;
}

//plakjanje
cin>>m;
for (int i=0;i<m;i++){
cin>>id>>brojcasovi;

 int findId=false;
 for (int j=0;j<n;j++){
 if (strcmp(p[j].getId(),id)==0){
 p[j].platiCasovi(brojcasovi);
 findId=true;
 }
 }
if (!findId)
 cout<<"Ne e platen parking. Greshen ID."<<endl;
}
 cout<<"========="<<endl;
 ParkingPlac pCentar("Cvetan Dimov","C10",80);
for (int i=0;i<n;i++)
 if (p[i].daliIstaAdresa(pCentar))
 p[i].pecati();
}
DVD
Да се дефинира класата Film во која се чуваат информации за:
име на филмот (динамички алоцирано поле од знаци)
мемориската зафатнина на филмот изразена во MB
жанр на филмот кој може да биде: акција, комедија или драма (енумерација zanr)
Да се обезбедат сите потребни методи за класата за правилно функционирање на програмата.
Дополнително за оваа класа да се дефинира функцијата:
pecati() - функција во која ќе се печатат одделени со цртичка(-): мемориска зафатнина на филмот
со постфикс MB и името на филмот во наводници.
Да се креира класата DVD во која се чуваат информации за :
низа од филмови снимени на DVD-то (Поле од најмногу 5 објекти од класата Film )
број на филмови снимени на DVD-то
меморискиот капацитет на DVD-то (во MB)
Да се обезбедат сите потребни методи за класата за правилно функционирање на програмата.
Дополнително за оваа класа да се дефинираат методите:
dodadiFilm (Film f) - со кој се додава филмот f на DVDто, но само ако има доволно преостанато
место (земајќи го предвид меморискиот капацитет на DVD-то и мемориската зафатнина на
снимените филмови) и притоа да има помалку од 5 филмови на DVD-то.
pecatiFilmoviDrugZanr(zanr z) – со кој се печатат информациите за сите филмови кои НЕ се од
жанрот zanr (акција, комедија или драма).
#include <iostream>
#include <cstring>
using namespace std;
enum zanr{action,comedy,drama};
class Film{

 private:

 char *name = new char [50];
 int size;
 zanr genre;

 public:

 Film(char *name=" ",int size=0, zanr genre=zanr(0)){
 strncpy(this->name,name,50);
 this->size=size;
 this->genre=genre;
 }

 Film(const Film &f){
 strncpy(name,f.name,50);
 size=f.size;
 genre=f.genre;
 }

 Film& operator=(const Film &f){
 strncpy(this->name,f.name,50);
 this->size=f.size;
 this->genre=f.genre;
 return *this;
 }

 ~Film(){
 delete [] name;
 }

 void pecati(){
 cout<<size<<"MB"<<"-\""<<name<<"\"";
 cout<<endl;
 }

 int getSize(){
 return size;
 }

 zanr getZanr(){
 return genre;
 }
};
class DVD{

 private:

 Film f[5];
 int num;
 int capacity;

 public:

 DVD(){}

 DVD(Film *f,int num,int capacity){
 this->num=num;
 this->capacity=capacity;
 for(int i=0;i<5;i++){
 this->f[i]=f[i];
 }
 }

 DVD(const DVD &d){
 for(int i=0;i<5;i++){
 f[i]=d.f[i];
 }
 num=d.num;
 capacity=d.capacity;
 }

 void dodadiFilm(Film f){
 if(num<5){
 if(capacity>=f.getSize()){
 this->f[num]=f;
 ++num;
 capacity-=f.getSize();
 }
 }

 }

 DVD(int capacity){
 this->capacity=capacity;
 num=0;
 }

 void pecatiFilmoviDrugZanr(zanr z){
 for(int i=0;i<num;i++){
 if(z!=f[i].getZanr()){
 f[i].pecati();
 }
 }
 }

 Film getFilm(int i){
 return f[i];
 }

 int getBroj(){
 return num;
 }

};
int main() {
 // se testira zadacata modularno
 int testCase;
 cin >> testCase;
 int n, memorija, kojzanr;
 char ime[50];
 if(testCase == 1) {
 cout << "===== Testiranje na klasata Film ======" << endl;
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 f.pecati();
 } else if(testCase == 2) {
 cout << "===== Testiranje na klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 for (int i=0; i<n; i++)
 (omileno.getFilm(i)).pecati();
 } else if(testCase == 3) {
 cout << "===== Testiranje na metodot dodadiFilm() od klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 for (int i=0; i<omileno.getBroj(); i++)
 (omileno.getFilm(i)).pecati();
 } else if(testCase == 4) {
 cout << "===== Testiranje na metodot pecatiFilmoviDrugZanr() od klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 cin>>kojzanr;
 omileno.pecatiFilmoviDrugZanr((zanr)kojzanr);
 } else if(testCase == 5) {
 cout << "===== Testiranje na metodot pecatiFilmoviDrugZanr() od klasata DVD ======" << endl;
 DVD omileno(50);
 cin>>n;
 for (int i=0; i<n; i++) {
 cin >> ime;
 cin >> memorija;
 cin >> kojzanr; //se vnesuva 0 za AKCIJA,1 za KOMEDIJA i 2 za DRAMA
 Film f(ime,memorija,(zanr)kojzanr);
 omileno.dodadiFilm(f);
 }
 cin>>kojzanr;
 omileno.pecatiFilmoviDrugZanr((zanr)kojzanr);
 }
 return 0;
}
Пицерија
Да се дефинира класа Пица за која ќе се чуваат податоци за:
име на пицата (низа од 15 знаци)
цена (цел број)
состојки (динамички алоцирана низа од знаци)
намалување на цената во проценти (цел број) - ако пицата не е на промоција намалувањето има
вредност нула, во спротивно, вредност поголема од нула и не поголема од 100.
За потребите на оваа класа да се креираат потребните конструктори и да се напише соодветен
деструктор. Дополнително за оваа класа да се дефинира функцијата:
pecati() - функција во која ќе се печатат податоците за пицата во следниот формат: име - состојки,
цена.
istiSe(Pica p) - функција за споредба на две пици според состојките :
Да се дефинира класа Picerija во која се чуваат (5 поени):
име (низа од максимум 15 знаци)
динмички алоцирана низа од објекти од класата Pica
број на пици (цел број)
За потребите на оваа класа да се дефинираат потребните конструктори и да се напише соодветен
деструктор. Да се имплементираат и следниве методи:
dodadi (Pica P) - за додавање нова пица во пицеријата, но само ако не постои иста во низата (нема
пица со исти состојки со пицата што треба да се додаде).
void piciNaPromocija() - се печатат сите пици од пицеријата што се на промоција во формат : име -
состојки, цена, цена со попуст.
#include <iostream>
#include <cstring>
using namespace std;
//Vasiot kod tuka
class Pica
{
private:
 char name[15];
 char *ing;
 int price, dis;
public:
 Pica(const char *name="", const int price=0, const char *ing="", const int dis=0)
 {
 strcpy(this->name, name);
 this->price=price;
 this->ing=new char[strlen(ing)+1];
 strcpy(this->ing, ing);
 this->dis=dis;
 }
 Pica(const Pica &p)
 {
 strcpy(name, p.name);
 price=p.price;
 ing=new char[strlen(p.ing)+1];
 strcpy(ing, p.ing);
 dis=p.dis;
 }
 Pica &operator=(const Pica &p)
 {
 if(this!=&p)
 {
 strcpy(name, p.name);
 price=p.price;
 delete [] ing;
 ing=new char[strlen(p.ing)+1];
 strcpy(ing, p.ing);
 dis=p.dis;
 }
 return *this;
 }
 ~Pica()
 {
 delete [] ing;
 }
 void pecati()
 {
 cout<<name<<" - "<<ing<<", "<<price;
 }
 bool istiSe(Pica p)
 {
 return strcmp(ing, p.ing)==0;
 }
 const int getPrice() {return price;}
 const int getDis() {return dis;}
};
class Picerija
{
private:
 char name[15];
 Pica *pc;
 int countP;
public:
 Picerija(const char *name)
 {
 strcpy(this->name, name);
 countP=0;
 }
 Picerija(const Picerija &p)
 {
 strcpy(name, p.name);
 countP=p.countP;
 pc=new Pica[countP];
 for(int i=0; i<countP; i++)
 {
 pc[i]=p.pc[i];
 }
 }
 Picerija &operator=(const Picerija &p)
 {
 if(this!=&p)
 {
 strcpy(name, p.name);
 countP=p.countP;
 delete [] pc;
 pc=new Pica[countP];
 for(int i=0; i<countP; i++)
 {
 pc[i]=p.pc[i];
 }
 }
 return *this;
 }
 ~Picerija()
 {
 delete [] pc;
 }
 void dodadi(Pica p)
 {
 bool notSame=true;
 for(int i=0; i<countP; i++)
 {
 if(pc[i].istiSe(p))
 {
 notSame=false;
 break;
 }
 }
 if(notSame)
 {
 Pica *tmp=new Pica[countP+1];
 for(int i=0; i<countP; i++)
 {
 tmp[i]=pc[i];
 }
 if(countP>0)
 delete [] pc;
 pc=tmp;
 pc[countP++]=p;
 }
 }
 void setIme(const char *name) {strcpy(this->name, name);}
 const char *getIme() {return name;}
 void piciNaPromocija()
 {
 for(int i=0; i<countP; i++)
 {
 if(pc[i].getDis())
 {
 pc[i].pecati();
 cout<<" "<<pc[i].getPrice()-(pc[i].getPrice()*pc[i].getDis())/100<<endl;
 }
 }
 }
};
int main () {
 int n;
 char ime[15];
 cin >> ime;
 cin >> n;
 Picerija p1(ime);
 for(int i = 0; i < n; i++){
 char imp[100];
 cin.get();
 cin.getline(imp,100);
 int cena;
 cin >> cena;
 char sostojki[100];
 cin.get();
 cin.getline(sostojki,100);
 int popust;
 cin >> popust;
 Pica p(imp,cena,sostojki,popust);
 p1.dodadi(p);
 }
 Picerija p2 = p1;
 cin >> ime;
 p2.setIme(ime);
 char imp[100];
 cin.get();
 cin.getline(imp,100);
 int cena;
 cin >> cena;
 char sostojki[100];
 cin.get();
 cin.getline(sostojki,100);
 int popust;
 cin >> popust;
 Pica p(imp,cena,sostojki,popust);
 p2.dodadi(p);
 cout<<p1.getIme()<<endl;
 cout<<"Pici na promocija:"<<endl;
 p1.piciNaPromocija();
 cout<<p2.getIme()<<endl;
 cout<<"Pici na promocija:"<<endl;
 p2.piciNaPromocija();
return 0;
}
Матрица
Да се напише класа за матрица. Во класата се чуваат елементите од матрицата од тип float
(матрица со максимална димензија [10]x[10]) и големината на матрицата (број на редици и
колони). За оваа класа да се преоптоварат следните оператори:
оператор + за собирање матрица со број
оператор - за одземање на матрици
оператор * за множење на матрици
операторот >> за внесување на елементите на матрицата
операторот << за печатење на елементите на матрицата
Во главната функција да се креираат објекти A, B и C со подразбирливиот конструктор на класата
Matrica. Од стандарден влез да се прочитаат нивните вредности. Да се отпечати вредноста на
изразот A-(B*C)+2 на стандарден излез.
Да се претпостави дека секогаш матриците ќе бидат квадратни со ист број на редици и колони.
//vashiot kod ovde
#include <iostream>
#include <cstring>
using namespace std;
class Matrica{

private:

 float matrix[10][10];
 int rows;
 int columns;

public:

 Matrica(){}

 Matrica(int rows,int columns){
 this->rows=rows;
 this->columns=columns;
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 this->matrix[i][j]=0;
 }
 }

 }

 friend istream& operator>>(istream &input,Matrica &m){
 input>>m.rows>>m.columns;
 for(int i=0;i<m.rows;i++){
 for(int j=0;j<m.columns;j++){
 input>>m.matrix[i][j];
 }
 }
 return input;
 }

 friend ostream& operator<<(ostream &output,Matrica &m){
 for(int i=0;i<m.rows;i++){
 for(int j=0;j<m.columns;j++){
 output<<m.matrix[i][j]<<" ";
 }
 output<<endl;
 }
 return output;
 }

 Matrica& operator+(int a){
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 matrix[i][j]+=a;
 }
 }
 return *this;
 }

 Matrica& operator-(Matrica &b){
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 this->matrix[i][j]-=b.matrix[i][j];
 }
 }
 return *this;
 }

 Matrica operator*(Matrica &b){
 Matrica newmatrica(this->rows,this->columns);
 for(int i=0;i<rows;i++){
 for(int j=0;j<columns;j++){
 for(int k=0;k<columns;k++){
 newmatrica.matrix[i][j]+=this->matrix[i][k]*b.matrix[k][j];
 }
 }
 }
 return newmatrica;
 }

};
int main()
{
 Matrica A,B,C;
 cin>>A>>B>>C;
 Matrica D=B*C;
 Matrica R=A-D+2;
 cout<<R;
}
Планинарско друштво
Да се креира класа за претставување на планинарско друштво во која ќе се чуваат информации за
името на друштвото (динамички алоцирана низа од знаци), број на поминати тури (цел број) и
број на членови во планинарското друштво (цел број). За оваа класа да се напише:
оператор + за собирање на две друштва што како резултат враќа друштво со број на членови
еднаков на збирот од членовите од двете друштва, а останатите атрибути на резултантното
друштво ги добиваат вредностите на соодветните атрибути од друштвото со поголем број на
членови
оператори >, < за споредба во однос на бројот на членови во планинарските друштва
оператор << за печатење на информациите за планинарското друштво
Да се напише функција што на влез прима низа од планинарски друштва и вкупен број на друштва
во низата и го печати планинарското друштво што има најголем број на членови .
#include <iostream>
#include <string.h>
using namespace std;
class PlDrustvo{

private:

 char *ime;
 int brojTuri;
 int clenovi;

public:

 PlDrustvo(){
 ime=NULL;
 brojTuri=0;
 clenovi=0;
 }


 PlDrustvo(char *ime,int brojTuri,int clenovi){
 this->ime=new char [strlen(ime)+1];
 strcpy(this->ime,ime);
 this->brojTuri=brojTuri;
 this->clenovi=clenovi;
 }

 PlDrustvo(const PlDrustvo& p){
 this->ime=new char [strlen(p.ime)+1];
 strncpy(this->ime,p.ime,strlen(p.ime)+1);
 this->brojTuri=p.brojTuri;
 this->clenovi=p.clenovi;
 }

 PlDrustvo& operator=(const PlDrustvo &p){
 if(this!=&p){
 delete [] this->ime;
 this->ime=new char [strlen(p.ime)+1];
 strcpy(this->ime,p.ime);
 this->brojTuri=p.brojTuri;
 this->clenovi=p.clenovi;
 }
 return *this;
 }

 PlDrustvo operator+(const PlDrustvo &p){
 PlDrustvo p1;
 if(*this>p){
 delete [] p1.ime;
 p1.ime=new char [strlen(this->ime)+1];
 strncpy(p1.ime,this->ime,strlen(this->ime)+1);
 p1.brojTuri=this->brojTuri;
 p1.clenovi=this->clenovi+p.clenovi;
 } else {
 delete [] p1.ime;
 p1.ime=new char [strlen(p.ime)+1];
 strncpy(p1.ime,p.ime,strlen(p.ime)+1);
 p1.brojTuri=p.brojTuri;
 p1.clenovi=this->clenovi+p.clenovi;
 }
 return p1;
 }

 ~PlDrustvo(){
 delete [] ime;
 }

 friend ostream& operator<<( ostream& output,PlDrustvo &p){
 output<<"Ime: "<<p.ime<<" Turi: "<<p.brojTuri<<" Clenovi: "<<p.clenovi<<endl;
 return output;
 }

 bool operator<(const PlDrustvo& p){
 return this->clenovi<p.clenovi;
 }

 bool operator>(const PlDrustvo& p){
 return this->clenovi>p.clenovi;
 }


};
void najmnoguClenovi(PlDrustvo* drustva,int n){
 PlDrustvo max=drustva[0];
 for(int i=1;i<n;i++){
 if(drustva[i]>max){
 max=drustva[i];
 }
 }
 cout<<"Najmnogu clenovi ima planinarskoto drustvo: "<<max;
}
int main()
{
 PlDrustvo drustva[3];
 PlDrustvo pl;

 for (int i=0;i<3;i++)
 {
 char ime[100];
 int brTuri;
 int brClenovi;
 cin>>ime;
 cin>>brTuri;
 cin>>brClenovi;

 PlDrustvo p(ime,brTuri,brClenovi);

 drustva[i] = p;
 }

 pl = (drustva[0] + drustva[1]);

 cout<<pl;


 najmnoguClenovi(drustva, 3);

 return 0;
}
Автомобил
Да се напише класа Automobile во која се чуваат информации за марката на автомобилот
(динамички алоцирана низа од знаци), регистрација (динамички алоцирана низа од 5 цели броја)
и максимална брзина (цел број). За класата да се обезбедат set и get методите што се користат и
да се преоптоварат следните оператори:
оператор == за споредување на два автомобила според регистрацијата
оператор << за печатење на податоци на автомобил во формат Marka:име Registracija:[x y z k l]
Да се напише класа RentACar за агенција за измајмување возила во која се чуваат информација за
името на агенцијата (низа од 100 знци), низа од автомобили (динамички алоациана низа од
објекти од класата Automobile) и број на автомобили со кој располага (цел број). Во класата
RentACar да се напише конструктор со еден аргумент за иницијализација на името на агенцијата.
При секое додавање на нов автомобил, динамички алоцираната низа да го зголемува капацитетот
за 1 елемент. Во оваа класа да се преоптоварат операторите:
+= за додавање на нов автомобил во агенцијата и
-= за отстранување на даден автомобил од агенцијата (оној со иста регистрација).
Да се напише main функција во која се инстанцира објект од класата RentACar. Во овој објект да се
додадат сите автомобили чии информации се читаат од тастатура со операторот +=. Меѓутоа,
откриено е дека во внесувањето на податоците има грешка затоа што при обид да се додаде нов
автомобил во агенцијата, увидено е дека таа регистрација веќе постои. Во последниот ред од
влезот дадени се инфромации тој автомобил. Потребно е да се избрише автомобилот што
претходно е погрешно внесен и да се додаде новиот.
На излез да се отпечатат името на агенцијата и листа на автомобили што таа ги изнајмува, а чија
максимална брзина е поголема од 150. Последново да се направи со функција
_pecatiNadBrzina(int max)_ што треба да се дефинира во класата RentACar.
#include<iostream>
#include<cstring>
using namespace std;
class Automobile
{
private:
 char *marka;
 int *registracija;
 int maks_brzina;
public:
 Automobile(const char *m="", const int *reg=0, int maksb=0)
 {
 marka = new char[strlen(m)+1];
 strcpy(marka,m);
 registracija = new int[5];
 if(reg==0)
 {
 for(int i=0;i<5;i++)
 {
 registracija[i]=0;
 }
 }
 else
 {
 for(int i=0;i<5;i++)
 {
 registracija[i]=reg[i];
 }
 }
 maks_brzina=maksb;
 }
 Automobile(const Automobile &a)
 {
 marka = new char[strlen(a.marka)+1];
 strcpy(marka,a.marka);
 registracija = new int[5];
 for(int i=0;i<5;i++)
 {
 registracija[i]=a.registracija[i];
 }
 maks_brzina=a.maks_brzina;
 }
 Automobile &operator =(const Automobile &a)
 {
 if(this==&a)return *this;
 delete [] marka;
 marka = new char[strlen(a.marka)+1];
 strcpy(marka,a.marka);
 registracija = new int[5];
 for(int i=0;i<5;i++)
 {
 registracija[i]=a.registracija[i];
 }
 maks_brzina=a.maks_brzina;
 return *this;
 }
 ~Automobile(){delete [] marka; delete [] registracija;}
 bool operator ==(const Automobile &a)
 {
 bool flag=true;
 for(int i=0;i<5;i++)
 {
 if(registracija[i]!=a.registracija[i])
 flag=false;
 }
 return flag;
 }
 friend ostream &operator <<(ostream &out, const Automobile &a)
 {
 out<<"Marka\t";
 out<<a.marka<<""<<"\tRegistracija[ ";
 for(int i=0;i<5;i++)
 {
 out<<a.registracija[i]<<" ";
 }
 out<<"]"<<endl;
 }
 int get_brzina()
 {
 return maks_brzina;
 }
};
class RentACar
 {
 private:
 char ime[100];
 Automobile *av;
 int broj_alto;
 public:
 RentACar(const char *im="", const Automobile *avt=0, int br_al=0)
 {
 av = new Automobile[br_al];
 strcpy(ime,im);
 for(int i=0;i<br_al;i++)
 {
 av[i] = avt[i];
 }
 broj_alto=br_al;
 }
 RentACar (const RentACar &rc)
 {
 strcpy(ime,rc.ime);
 av = new Automobile[rc.broj_alto];
 for(int i=0;i<rc.broj_alto;i++)
 {
 av[i] = rc.av[i];
 }
 broj_alto=rc.broj_alto;
 }
 RentACar &operator +=(const Automobile &a)
 {
 Automobile *temp;
 temp = new Automobile [broj_alto+1];
 for(int i=0;i<broj_alto;i++)
 {
 temp[i] = av[i];
 }
 temp[broj_alto]=a;
 delete [] av;
 av=temp;
 broj_alto++;
 return *this;
 }
 RentACar &operator -=(const Automobile &a)
 {
 Automobile *temp;
 int brojac=0;
 for(int i=0;i<broj_alto;i++)
 {
 if(av[i]==a)brojac++;
 }
 temp = new Automobile[broj_alto-brojac];
 int b=0;
 for(int i=0;i<broj_alto;i++)
 {
 if(!(av[i]==a))
 {
 temp[b]=av[i];
 b++;
 }
 }
 delete [] av;
 av=temp;
 broj_alto=broj_alto-brojac;
 return *this;
 }
 void pecatiNadBrzina(int maks)
 {
 for(int i=0;i<broj_alto;i++)
 {
 if(av[i].get_brzina()>maks)
 cout<<av[i];
 }
 }
 };
int main()
{
 RentACar agencija("FINKI-Car");
 int n;
 cin>>n;
cout<<"FINKI-Car"<<endl;
 for (int i=0;i<n;i++)
 {
 char marka[100];
 int regisracija[5];
 int maximumBrzina;
 cin>>marka;
 for (int i=0;i<5;i++)
 cin>>regisracija[i];
 cin>>maximumBrzina;
 Automobile nov=Automobile(marka,regisracija,maximumBrzina);
 //dodavanje na avtomobil
 agencija+=nov;
 }
 //se cita grehsniot avtmobil, za koj shto avtmobilot so ista registracija treba da se izbrishe
 char marka[100];
 int regisracija[5];
 int maximumBrzina;
 cin>>marka;
 for (int i=0;i<5;i++)
 cin>>regisracija[i];
 cin>>maximumBrzina;
 Automobile greshka=Automobile(marka,regisracija,maximumBrzina);
 //brishenje na avtomobil
 agencija-=greshka;
 agencija.pecatiNadBrzina(150);
 return 0;
}
Недвижнина
Да се развие класа Nediviznina за коjа се чуваат следниве информации:
адреса (динамички алоцирана низа од знаци)
квадратура (цел боj)
цена за квадрат (цел боj)
За оваа класа да се имплементираат соодветните конструктори и следните методи:
cena() коj ќе jа ваќа цената на недвижнината (квадратура * цена-за-квадрат)
pecati() коj ќе ги испечати сите информации за истата
danokNaImot() коj го ваќа данокот што се плаќа за недвижнината, а истиот се пресметува како 5%
од цената на недвижнината.
Од оваа класа да се изведе класа Vila за коjа дополнително се чува данок на луксуз (цел боj, пр.
10%). За оваа класа да се преоптоварат методите:
pecati()
danokNaImot() со тоа што пресметаниот данок се зголемува процентуално за данокот на луксуз.
И за двете класи треба да се преоптовари operator >>.
//Vasiot kod ovde....
#include <iostream>
#include <cstring>
using namespace std;
class Nedviznina{
protected:
 char *adresa;
 int kv,cena;
public:
 Nedviznina(){
 adresa=new char[0];
 }
 //copy
 Nedviznina(const Nedviznina &n){
 adresa=new char[strlen(n.adresa)+1];
 strcpy(adresa,n.adresa);
 kv=n.kv;
 cena=n.cena;
 }
 //operator =
 Nedviznina& operator=(const Nedviznina &n){
 if(this!=&n){
 delete [] adresa;
 adresa=new char[strlen(n.adresa)+1];
 strcpy(adresa,n.adresa);
 kv=n.kv;
 cena=n.cena;
 }
 return *this;
 }
 //destructor
 ~Nedviznina(){
 delete [] adresa;
 }
 //metodi
 int Cena(){
 return kv*cena;
 }
 void pecati(){
 cout<<adresa<<", Kvadratura: "<<kv<<", Cena po Kvadrat: "<<cena<<endl;
 }
 float danokNaImot(){
 return (float)kv*cena*5/100;
 }
 char *getAdresa(){
 return adresa;
 }
 //operator >>
 friend istream& operator>>(istream &in,Nedviznina &n){
 in>>n.adresa;
 in>>n.kv;
 in>>n.cena;
 return in;
 }
};
class Vila:public Nedviznina{
private:
 int danok;
public:
 Vila(){}
 //metodi
 void pecati(){
 cout<<adresa<<", Kvadratura: "<<kv<<", Cena po Kvadrat: "<<cena<<", Danok na luksuz:
"<<danok<<endl;
 }
 float danokNaImot(){
 return Nedviznina::Cena()*(5+danok)/100;
 }
 //operator >>
 friend istream& operator>>(istream &in,Vila &v){
 return in>>v.adresa>>v.kv>>v.cena>>v.danok;
 }
};
int main(){
 Nedviznina n;
 Vila v;
 cin>>n;
 cin>>v;
 n.pecati();
 cout<<"Danok za: "<<n.getAdresa()<<", e: "<<n.danokNaImot()<<endl;
 v.pecati();
 cout<<"Danok za: "<<v.getAdresa()<<", e: "<<v.danokNaImot()<<endl;
 return 0;
}
Спортски екипи
Да се дефинира класа Ekipa за коjа се чуваат следниве информации:
името на екипата (низа од наjмногу 15 знаци)
броj на порази
броj на победи
За оваа класа да се дефинира метод pecati() коjа ги печати податоците за екипаta. Од оваа класа
да се изведe новa класa, FudbalskaEkipa.
За фудбалската екипа дополнително се чуваат информации за:
вкупниот броj на црвени картони
вкупниот броj жолти картони
броjот на нерешени натпревари
За фудбалската екипа да се преоптовари методот pecati(), така што покрај останатите
информации, ќе се испечатат и бројот на нерешени резултати и вкупен број на поени во формат:
Име на екипа, броj на победи, броj на порази, броj на нерешени натпревари и вкупен броj на
поени (за победа фудбалската екипа добива 3 поени, додека за нерешен резултата, 1 поен);
//Vasiot kod ovde
#include <iostream>
#include <cstring>
using namespace std;
class Ekipa{
protected:
 char ime[15];
 int porazi;
 int pobedi;
public:
 Ekipa(char ime[15]="",int pobedi=0,int porazi=0){
 strcpy(this->ime,ime);
 this->pobedi=pobedi;
 this->porazi=porazi;
 }
 ~Ekipa(){}
 void pecati(){
 cout<<"Ime: "<<ime<<" Pobedi: "<<pobedi<<" Porazi: "<<porazi;
 }
};
class FudbalskaEkipa:public Ekipa{
private:
 int crveni;
 int zolti;
 int nereseni;
public:
 FudbalskaEkipa(char ime[15]="",int pobedi=0,int porazi=0,int crveni=0,int zolti=0,int
nereseni=0):Ekipa(ime,pobedi,porazi){
 this->crveni=crveni;
 this->zolti=zolti;
 this->nereseni=nereseni;
 }
 FudbalskaEkipa(const FudbalskaEkipa &k):Ekipa(ime,pobedi,porazi){
 crveni=k.crveni;
 zolti=k.zolti;
 nereseni=k.nereseni;
 }
 ~FudbalskaEkipa(){}
 void pecati(){
 int poeni;
 poeni=(pobedi*3)+(1*nereseni);
 cout<<"Ime: "<<ime<<" Pobedi: "<<pobedi<<" Porazi: "<<porazi<<" Nereseni: "<<nereseni<<" Poeni:
"<<poeni<<endl;
 }
};
int main(){
char ime[15];
int pob,por,ck,zk,ner;
cin>>ime>>pob>>por>>ck>>zk>>ner;
FudbalskaEkipa f1(ime,pob,por,ck,zk,ner);
f1.pecati();
return 0;
}