1.

Sa se dezvolte o aplicatie de gestiune a sarcinilor pe care le au de indeplinit angajatii

unei companii. Pentru fiecare task se cunosc urmatoarele elemente: id-ul si prioritatea
taskului(un numar natural de o cifra) si numarul de zile asociat taskului, iar pentru
fiecare angajat se cunoaste un id, lista de taskuri asociate acestuia si task-ul la care
lucreaza acesta in prezent.

Cerinte:
(a) Sa se modeleze comportamentul unui task, incluzand functii de citire si afisare al
acestuia.
(b) Sa se modeleze comportamentul unui angajat, incluzand functii de citire si afisare al
acestuia, dar si de atribuire, adaugare si stergere de task-uri.
(c) Sa se creeze un meniu cu ajutorul caruia managerul de atribuie si verifica sarcinile
angajatilor.
(d) Indicatii:

1. Se va crea un vector de n angajati(n citit de la tastatura) care nu vor avea task-uri

asociate.
2. Se va citi id-ul unui angajat si unui informatiile unui task, iar task-ul citit va fi atribuit
angajatului cu id-ul citit. Se va folosi functia de citire definita la punctul anterior.
3. Se vor afisa informatiile tuturor angajatilor folosind functiile de afisare definite la
punctul anterior.

Task.h
#pragma once
#include<iostream>
struct task
{
int id_task;
int prioritate;
int nr_zile;
void citire_task();
void afisare_task();
void actualizare_task(int p, int zile);
};

Task.cpp
#include "Task.h"
void task::citire_task()
{
std::cout << "Id task=";
std::cin >> this->id_task;
std::cout << "Prioritate= ";
std::cin >> this->prioritate;
std::cout << "Numar zile= ";
std::cin >> this->nr_zile;
} void task::afisare_task()
{
std::cout << "Id=" << this->id_task;
std::cout << " Prioritate= " << this->prioritate;
std::cout << " Numar zile= " << this->nr_zile << std::endl;
}

void task::actualizare_task(int p, int zile)

{
this->prioritate = p;
this->nr_zile = zile;
}

Angajat.h
#pragma once
#include "Task.h"
struct angajat
{
int id;
int nr_task = 0;
task taskuri[100];
task task_curent;
void adauga_task(task tasknou);
void afisare_task_curent();
void afisare_taskuri();
void atribuire_task();
void eliminare_task();
};

Angajat.cpp
#include "Angajat.h"
void angajat::adauga_task(task tasknou)
{
this->taskuri[this->nr_task] = tasknou;
this->nr_task++;
atribuire_task();
}
void angajat::afisare_task_curent()
{
std::cout << "Angajatul cu id-ul: " << this->id << " lucreaza la task-ul:
";
this->task_curent.afisare_task();
}
void angajat::afisare_taskuri()
{
std::cout << "Angajatul cu id-ul: " << this->id << " are asociate taskurile \n";
for (int i = 0; i < this->nr_task; i++)
this->taskuri[i].afisare_task();
}

void angajat::atribuire_task()
{
task max = this->taskuri[0];
for (int i = 1; i<this->nr_task; i++)
{
if (max.prioritate < taskuri[i].prioritate)
max = taskuri[i];
 }
this->task_curent = max;

void angajat::eliminare_task()
{
int poz = -1;
for (int i = 0; i<this->nr_task; i++)
{
if (task_curent.id_task == taskuri[i].id_task)
poz = i;
}
for (int i = poz + 1; i < this->nr_task; i++)
{
taskuri[i - 1] = taskuri[i];
}
nr_task--;
this->atribuire_task();
}

Main.cpp
#include "Angajat.h"
#include "Task.h"
void main()
{
angajat angajati[50];
for (int i = 0; i < 10; i++)
{
angajat a;
a.id = i;
angajati[i] = a;
}
while (true)
{
std::cout << "0.Exit." << std::endl;
std::cout << "1.adauga task" << std::endl;
std::cout << "2.afisare task_curent" << std::endl;
std::cout << "3.afisare taskuri" << std::endl;
std::cout << "4.eliminare task" << std::endl;
int option = 0;
std::cin >> option;
if (option == 0)
break;
else
if (option == 1)
{
int angajat_id;
std::cout << "angajat id= ";
std::cin >> angajat_id;
task t;
t.citire_task();
angajati[angajat_id].adauga_task(t);
}
else if (
 option == 2)
{
int angajat_id;
std::cout << "angajat id= ";
std::cin >> angajat_id;
angajati[angajat_id].afisare_task_curent();
}
else if (
option == 3)
{
int angajat_id;
std::cout << "angajat id= ";
std::cin >> angajat_id;
angajati[angajat_id].afisare_taskuri();
}
else if (
option == 4)
{
int angajat_id;
std::cout << "angajat id= ";
std::cin >> angajat_id;
angajati[angajat_id].eliminare_task();
}
}
system("pause");
}
2. Aplicatie animale .Sa se modeleze comportamentul unui animal de companie.
Se vor citi din fisier mai multe animate de companie folosind operatorul de citire si se va supraincarca
operatorul ! pentru a modifica campul de sunet.
Animal.h
#pragma once
#include <fstream>
enum Sound
{
MIAU,
HAM
};
struct Animal

{
int id;
int varsta;
double greutate;
Sound sound;
void citire_animal(std::ifstream &f);
void citire(std::ifstream& f, Animal& p);
friend std::istream& operator>>(std::istream& f, Animal& p);
Animal operator!();
Animal operator=(Animal A);

};
Animal.cpp
#include "Animal.h"

void Animal::citire_animal(std::ifstream&f)
{
f >> this->id;
f >> this->varsta;
f >> this->greutate;
this->sound = Sound::MIAU;
}
void Animal:: citire(std::ifstream& f, Animal& p)
{

f >> p.id;
f >> p.varsta;
f >> p.greutate;
p.sound = Sound::MIAU;
}
Animal Animal::operator!()
{
this->sound = Sound::HAM;
return *this;
}
Animal Animal::operator=(Animal A)
{
this -> greutate=A.greutate;
this -> sound=A.sound;
this -> varsta=A.varsta;
return *this;
}
std::istream& operator>>(std::istream& f, Animal& p)
{
f >> p.id;
f >> p.varsta;
f >> p.greutate;
p.sound = Sound::MIAU;
return f;
}

animale.txt
5
1 2 1.7
2 1 0.5
3 1 0.7
4 2 1.8
5 3 2.3

Main.cpp
#include <iostream>
#include "Animal.h"

int main()
{
Animal animale[10];
int l;
std::ifstream f("animale.txt");
f >> l;
for (int i = 0; i < l; i++)
{
//pufi[i].citire_animal(f);
//pufi[i].citire(f, pufi[i]);
f >> animale[i];

}
for (int i = 0; i < l; i++)
{
std::cout << animale[i].id << std:: endl;
}
Animal x;
x = !animale[0];
std::cout << x.sound<<std::endl;
}

3. Aplicatie numere complexe

Nrcomplex.h
#pragma once
#include <fstream>
struct Nrcomplex
{
int re;
int im;
friend std::istream& operator>>(std::istream& f, Nrcomplex& n);
Nrcomplex operator!();
Nrcomplex operator=(Nrcomplex x);
};

Nrcomplex.cpp
#include "Nrcomplex.h"

std::istream& operator>>(std::istream& f, Nrcomplex& n)

{
f >> n.im;
f >> n.re;
return f;
}
Nrcomplex Nrcomplex::operator!()
{
this->im = 0;
return *this;
}
Nrcomplex Nrcomplex::operator=(Nrcomplex x)
{
this->im = x.im;
this->re = x.re;
 return *this;
}

Main.cpp
#include <iostream>
#include "Nrcomplex.h"
int main()
{

Nrcomplex numar1;
Nrcomplex numar2;
std::cin >> numar1;
numar2 = !numar1;
std::cout << numar2.re << std::endl;
std::cout << numar2.im << std::endl;
}