| CATEGORII DOCUMENTE |
In mod uzual, cand intr-un program se creeaza o instanta obiect a unei clase, atunci se vor atribui valori initiale datelor membru ale acelui obiect. Pentru simplificarea procesului de initializare a membrilor obiectelor declarate, limbajul C++ accepta declararea si utilizarea unei functii speciale, numita functie constructor, care se executa automat la creearea unei instante a clasei din care face parte functia.
Structura generala a unei clase cu functie constructor este data mai jos:
class nume_clasa
// declararea datelor publice
// declararea si sau descrierea functiilor publice
private:
// declararea datelor private
// declararea si/sau descrierea functiilor private
protected:
// declararea datelor protejate
// declararea si/sau descrierea functiilor protejate
}
Observatii:
numele functiei constructor trebuie sa fie acelasi cu numele clasei la care este atasata
descrierea efectiva a functiei constructor se poate face in corpul clasei respective sau, ulterior, in afara clasei, declararea prototipului sau fiind obligatorie in interiorul clasei, ca mai jos:
nume_clasa:: nume_clasa (parametri_formali)
transmiterea parametrilor efectivi, la apelarea unei functii constructor, se face in partea executabila a programului astfel:
nume_clasa nume_functie(parametri_efectivi);
parametrii efectivi transmisi pot fi utilizati pentru initializarea unui obiect creat in partea executabila a programului sau pentru initializarea membrilor clasei respective.
functia constructor se executa automat cand, in program, se creeaza o instanta a clasei respective
- prin definitie, functia constructor nu returneaza nici o valoare, deci numele sau nu poate fi precedat de nici un tip
la compilare se va apela functia constructor numai atunci cand in program se declara un obiect al clasei corespunzatoare. Momentul real, in care compilatorul apeleaza codul functiei constructor, este dictat de tipul clasei si de locul din cadrul programului. Cand in program se creaza mai multe obiecte in aceeasi instructiune, apelarea si executarea functiilor constructor se va face in ordinea declararii acestora, adica de la stanga la dreapta. De asemenea, functia constructor a unei instante locale se va executa cand, in partea executabila a programului, se va intalni instructiunea de declarare a unui obiect al clasei respective.
cand exista ambiguitati intre datele clasei si parametrii functiei constructor, cum ar fi utilizarea acelorasi identificatori, se procedeaza la calificarea datelor clasei cu ajutorul operatorului de rezolutie ::, ca mai jos:
nume_clasa::nume_data;
- functiile constructor admit si valori implicite ale parametrilor formali, care, in lipsa transmiterii de parametri efectivi de catre o instanta a clasei respective, sunt utilizate pentru initializarea datelor clasei.
Se considera fisele de materiale dintr-un depozit cu materiale de constructii cu informatiile: cod material, un intreg cuprins intre 10000 si 99999; denumire material, un sir de 20 caractere maxim; unitatea de masura in multimea (bc, kg, ml, mp, mc, l, hl); pretul, un numar real si pozitiv; cantitatea din stoc, un numar real si pozitiv si valoarea, calculata ca produs intre cantitate si pret. Prin intermediul unei clase, in care s-a declarat o functie constructor, sa se initializeze datele referitoare la fiecare material din magazie: codul, denumirea si unitatea de masura de tip public, iar pretul, cantitatea si valoarea de tip privat. Prin intermediul unei functii membru te tip public sa se afiseeze datele publice: codul, denumirea si unitatea de masura iar prin intermediul unei functii private sa se afiseze si celelalte date private.
// definirea clasei material
#include<iostream.h>
#include<string.h>
class material
;
int cod_material;
char denumire[20];
char unitate_masura[2];
void afiseaza_fisa(void)
;
void afiseaza_date_publice()
;
private:
double pret_material;
double cantitate_stoc;
double valoare_stoc;
void afiseaza_date_private()
;
};
void main()
}
Rezultatele executiei acestui program, mai jos afisate, arata cum se transmit parametri efectivi functiei constructor material, cum se initializeaza datele publice si private si cum se apeleaza, pentru afisarea datelor initializate, functiile publice si private definite in clasa material.
codul materialului:20000
denumirea materialului:fier*beton*fi16
unitatea de masura:kg
pretul materialului:22.55
cantitatea din stoc:200
Informatii de nomenclator de materiale:
=========================================
codul materialui: 20000
denumirea materialului: fier*beton*fi16
unitatea de masura: kg
====================================
Informatii specifice materialului:
====================================
pretul materialului:22.55
cantitatea din stoc:200
valoarea stocului:4510
====================================
continuati?(d/n):d
codul materialului:30000
denumirea materialului:ciment*alb
unitatea de masura:bc
pretul materialului:16
cantitatea din stoc:150
Informatii de nomenclator de materiale:
====================================
codul materialui: 30000
denumirea materialului: ciment*alb
unitatea de masura: bc
Informatii specifice materialului:
====================================
pretul materialului:16
cantitatea din stoc:150
valoarea stocului:2400
====================================
continuati?(d/n):n
Deoarece, identificarorii datelor, declarate in interiorul clasei, sunt diferiti de identificatorii parametrilor formali ai functiei constructor, nu exista ambiguitati in folosirea acestora, fara calificarea lor cu ajutorul operatorului de rezolutie ::. In functia afiseaza_date_publice() nu s-a folosit calificarea datelor membre (cod_material, denumire, unitate_masura), in schimb, in functia afiseaza_date_private() s-a folosit calificarea cu ajutorul operatorului de rezolutie ::, desi nu era necesara, neexistand ambiguitati de calificare a datelor (material::pret_material, material::cantitate_stoc, material::valoare_stoc).
#include<iostream.h>
#include<iomanip.h>
// definirea clasei dobanda
class dobanda
// descrierea functiei constructor in afara clasei
dobanda::dobanda(double s0, double p, int n)
// descrierea functiei calcul_dobanda in afara clasei
void dobanda::calcul_dobanda(int k)
// descrierea functiei afiseaza_rezultat in afara clasei
void dobanda::afiseaza_rezultat(int k)
;
// descrierea functiei afiseaza_linie in afara clasei
void dobanda::afiseaza_linie(int m)
// descrierea functiei principale main
void main()
else
while((ws0<100000)||(ws0>1000000));
do
while((wp<10)||(wp>100));
do
while((wn<5)||(wn>20));
//apelarea functiei constructor cu parametri expliciti
dobanda explicita(ws0,wp,wn);
}
cout<<'n continuati?(d/n):';
cin>>r;
}
In urma executarii acestui program, s-au obtinut urmatoarele rezultate, care scot in evidenta: declararea prototipurilor tuturor functiilor, in corpul clasei, inclusiv a functiei constructor cu parametri formali impliciti, descriera tuturor functiilor in afara clasei, apelarea functiei constructor cu si fara parametri efectivi expliciti.
tip depozit implicit(s0=100000,p=10%,n=10 ani)?(d/n):d
tip depozit implicit(s0=100000,p=10%,n=10 ani)
suma depusa=100000 dobanda=10% perioada=10 ani
=====================================
anul suma cumulata dobanda cumulata
=====================================
1 110000.00 10000.00
2 121000.00 21000.00
3 133100.00 33100.00
4 146410.00 46410.00
5 161051.00 61051.00
6 177156.10 77156.10
7 194871.71 94871.71
8 214358.88 114358.88
9 235794.77 135794.77
10 259374.25 159374.25
=====================================
continuati?(d/n):d
tip depozit implicit(s0=100000,p=10%,n=10 ani)?(d/n):n
tip depozit explicit(s0<>100000,p<>10%,n<>10 ani)
suma initiala depusa (100000<=s0<=1000000):1000000
dobanda anuala % (10<=p<=100):100
perioada depozitului (5<=n<=20):8
suma depusa=1000000.00 dobanda=100.00% perioada=8 ani
=====================================
anul suma cumulata dobanda cumulata
=====================================
1 2000000.00 1000000.00
2 4000000.00 3000000.00
3 8000000.00 7000000.00
4 16000000.00 15000000.00
5 32000000.00 31000000.00
6 64000000.00 63000000.00
7 128000000.00 127000000.00
8 256000000.00 255000000.00
=====================================
continuati?(d/n):d
tip depozit implicit(s0=100000,p=10%,n=10 ani)?(d/n):d
tip depozit implicit(s0=100000,p=10%,n=10 ani)
suma depusa=100000.00 dobanda=10.00% perioada=10 ani
=====================================
anul suma cumulata dobanda cumulata
=====================================
1 110000.00 10000.00
2 121000.00 21000.00
3 133100.00 33100.00
4 146410.00 46410.00
5 161051.00 61051.00
6 177156.10 77156.10
7 194871.71 94871.71
8 214358.88 114358.88
9 235794.77 135794.77
10 259374.25 159374.25
=====================================
continuati?(d/n):n
2. Alocarea memoriei prin functiile constructor. Controlul alocarii memoriei.
Dupa cum s-a precizat, functiile constructor permit intializare datelor membre, inclusiv a datelor de tip tablouri, matrici. In cazul initializarii tablourilor, functiile constructor pot aloca memoria necesara tablourilor, putand controla modul in care s-a realizat alocarea de memorie ceruta. Alocarea memoriei necesare pentru tablouri de caractere se poate face simultan cu testarea modului in care s-a realizat efectiv alocarea, printr-o constructie de forma:
if (nume_functie_constructor::nume_tablou = new char[numar_octeti] == 0)
Constructia de mai sus, poate fi folosita pentru alocarea si verificarea alocarii pentru mai multe variabile de tip tablou, de tip caracter, in acelasi timp, ca mai jos:
..............................
nume_functie_constructor::nume_tablou1 = new char[numar_octeti1];
nume_functie_constructor::nume_tablou12= new char[numar_octeti2];
...............................
nume_functie_constructor::nume_tabloun = new char[numar_octetin];
if ((nume_functie_constructor::nume_tablou1 &&
(nume_functie_constructor::nume_tablou2 &&
.....................
(nume_functie_constructor::nume_tabloun ) == 0)
Pentru alocarea memoriei, pentru oricare tipuri de tablouri, prin intermediul pointerilor la tablouri, se poate folosi functia de alocare dinamica malloc.
nume_functie_constructor::pointer_tablou1 = (tip_componenta1*)malloc(n*sizeof(tip_componenta1));
nume_functie_constructor::pointer_tablou2 = (tip_componenta2*)malloc(n*sizeof(tip_componenta2));
nume_functie_constructor::pointer_tabloun = (tip_componentan*)malloc(n*sizeof(tip_componentan));
iar verificarea alocarii necesarului de memorie se poate face asemanator ca la tablourile de siruri, prezentata mai sus.
if((!nume_functie_constructor::pointer_tablou1) ||
(!nume_functie_constructor::pointer_tablou2) ||
...................
(!nume_functie_constructor::pointer_tabloun) == 0)
Problema 3
Se da o matrice dreptunghiulara de n linii si m coloane, unde m reprezinta numarul de tipuri de produse fabricate intr-o uzina, iar n numarul de tipuri de materiale folosite la fabricarea acestora. Un element al matricei a[i,j] reprezinta cantitatea, in aceeasi unitate de masura, din materialul i consumat pentru produsul j. Un vector de m componente contine numarul de produse fabricate din fiecare tip. Se cere sa se determine un vector de n componente care sa contina cantitatile totale, din fiecare tip de material, consumate pentru realizarea fabricatiei celor m tipuri de produse. Cunoscandu-se, apoi, intr-un vector, costurile unitare de materiale pe fiecare tip de material, sa se calculuze valoarea fiecarui tip de material consumat si valoarea totala a tuturor materialelor consumate. Pentru rezolvarea acestei aplicatii se va folosi o clasa adecvat definita care contine o functie constructor ce va initializa datele membre de tip pointeri la tablouri si va calcula si afisa cele cerute in problema. Se vor folosi parametri formali si efectivi de tip pointer, pentru transmiterea lor intre functia principala si functia constructor, utilizanduse, din acest motiv, alocarea dinamica de memorie si verificarea alocarii memoriei dinamice necesara tablourilor.
#include<iostream.h>
#include<iomanip.h>
#include<malloc.h>
#include<stdlib.h>
#define nmax 20
#define mmax 20
int i,j;
// definirea clasei consunuri
class consumuri
// descrierea functiei constructor consumuri in afara clasei
consumuri::consumuri(int n, int m, double *pc, double *pp, double *pv)
consumuri::n=n;
consumuri::m=m;
// initializarea matricei consumurilor specifice
for(i=0;i<n;i++)
for(j=0;j<m;j++) consumuri::pc[i*m+j]=pc[i*m+j];
// initializarea vectorului produselor fabricate
for(i=0;i<m;i++) consumuri::pp[i]=pp[i];
// initializarea vectorului costurilor unitare ale materialelor folosite
for(i=0;i<n;i++) consumuri::pv[i]=pv[i];
cout<<'n matricea consumurilor de materiale pe produse';
cout<<'n================================n';
afiseaza_matrice_consumuri(n,m);
cout<<'n=================================';
cout<<'n vectorul produselor fabricate';
cout<<'n ================================n';
afiseaza_vector_produse(m);
cout<<'n ================================n';
cout<<'n vectorul costurilor unitare pe materialen';
cout<<'n =================================';
afiseaza_vector_costuri_unitare(n);
cout<<'n =================================';
calcul_consumuri(n,m);
cout<<'n vectorul materialelor consumate';
cout<<'n ================================n';
afiseaza_vector_consumuri(n);
cout<<'n =================================';
calcul_costuri_materiale(n);
cout<<'n vectorul costurilor totale pe materiale';
cout<<'n =================================';
afiseaza_vector_costuri_materiale(n);
cout<<'n =================================';
// descrierea functiei calcul_consumuri
// in afara clasei cu ajutorul pointerilor
void consumuri::calcul_consumuri(int n,int m)
}
// descrierea functiei calcul_costuri_materiale
//in afara clasei cu ajutorul pointerilor
void consumuri::calcul_costuri_materiale(int n)
// descrierea functiei afiseaza_matrice_consumuri
//in afara clasei cu ajutorul pointerilor
void consumuri::afiseaza_matrice_consumuri(int n, int m)
cout<<'n';
}
}
// descrierea functiei afiseaza_vector_produse
// in afara clasei cu ajutorul pointerilor
void consumuri::afiseaza_vector_produse(int m)
}
// descrierea functiei afiseaza_vector_consumuri
// in afara clasei cu ajutorul pointerilor
void consumuri::afiseaza_vector_consumuri(int n)
}
// descrierea functiei afiseaza_vector_consturi_unitare
// in afara clasei cu ajutorul pointerilor
void consumuri::afiseaza_vector_costuri_unitare(int n)
}
// descrierea functiei afiseaza_vector_costuri_materiale
// in afara clasei cu ajutorul pointerilor
void consumuri::afiseaza_vector_costuri_materiale(int n)
cout<<'n valoare totala costuri materiale='<<consumuri::costotal;
}
// descrierea functiei principale main()
void main()
while(r=='d')
while((m<1)||(m>20));
do
while((n<1)||(n>20));
//citirea matricii consumurilor specifice de materiale pe produs
for(i=0;i<n;i++)
for(j=0;j<m;j++)
cout<<'n matricea consumurilor:n';
for(i=0;i<n;i++)
cout<<'n';
}
for(i=0;i<m;i++)
for(i=0;i<n;i++)
//apelarea functiei constructor, consumuri, cu parametri expliciti
consumuri functie_consumuri(n,m,ptrc,ptrp,ptrv);
cout<<'n continuati?(d/n):';
cin>>r;
}
Rezultatele executiei programului sunt afisate in continuare, putandu-se usor observa, modul in care, unei functii constructor, i se transmit parametri efectivi de tip pointeri la tablouri, alocarea dinamica de memorie pentru tablourile pointate ale functiei principale main, cat si pentru datele membre, de tip pointeri la tablouri, ale clasei corespunzatoare si verificarea alocarii memoriei pentru tablourile aplicatiei.
numarul de produse fabricate,m(1<=m<=20):3
numarul de materiale folosite,n(1<=n<=20):2
materialul 0 din produsul 0 =1
materialul 0 din produsul 1 =2
materialul 0 din produsul 2 =3
materialul 1 din produsul 0 =4
materialul 1 din produsul 1 =5
materialul 1 din produsul 2 =6
matricea consumurilor:
1 2 3
4 5 6
numarul de bucati fabricate din produsul 0 =1
numarul de bucati fabricate din produsul 1 =2
numarul de bucati fabricate din produsul 2 =3
costul unitar al materialului 0 =1
costul unitar al materialului 1 =2
functia constructor consumuri
matricea consumurilor de materiale pe produse
=============================================
1.000 2.000 3.000
4.000 5.000 6.000
==============================================
vectorul produselor fabricate
=============================================
1.00 2.00 3.00
=============================================
vectorul costurilor unitare pe material
=============================================
1.00 2.00
==============================================
vectorul materialelor consumate
=============================================
14.00 32.00
==============================================
vectorul costurilor totale pe materiale
=============================================
14.00 64.00
valoare totala costuri materiale=78.00
==============================================
continuati?(d/n):d
numarul de produse fabricate,m(1<=m<=20):2
numarul de materiale folosite,n(1<=n<=20):3
materialul 0 din produsul 0 =6
materialul 0 din produsul 1 =5
materialul 1 din produsul 0 =4
materialul 1 din produsul 1 =3
materialul 2 din produsul 0 =2
materialul 2 din produsul 1 =1
matricea consumurilor:
4.00 3.00
2.00 1.00
numarul de bucati fabricate din produsul 0 =1
numarul de bucati fabricate din produsul 1 =2
costul unitar al materialului 0 =1
costul unitar al materialului 1 =2
costul unitar al materialului 2 =3
functia constructor consumuri
matricea consumurilor de materiale pe produse
=============================================
6.000 5.000
4.000 3.000
2.000 1.000
==============================================
vectorul produselor fabricate
=============================================
1.00 2.00
=============================================
vectorul costurilor unitare pe materiale
=============================================
1.00 2.00 3.00
==============================================
vectorul materialelor consumate
=============================================
16.00 10.00 4.00
==============================================
vectorul costurilor totale pe materiale
=============================================
16.00 20.00 12.00
valoare totala costuri materiale=48.00
==============================================
continuati?(d/n):n
3. Supraincarcarea functiilor constructor si a functiilor membre
Dupa cum s-a invatat, functia constructor este o metoda speciala a claselor care se executa automat cand se creeaza diverse instante ale unui obiect. Supraincarcarea functiilor presupune declararea si definirea unor functii cu acelasi nume, astfel incat, in functie de parametrii transmisi, la compilare, sa se poata decida care dintre functiile cu acelasi nume sa fie adresata. Ca orice functie in C++ si functiile constructor pot fi supraincarcate si adresate. Daca o functie constructor este supraincarcata, atunci, la creearea unei instante a unui obiect, se va executa totdeauna prima functie constructor, cea de-a doua executandu-se cand prima nu poate fi executata din diferite motive, ca de exemplu, transmiterea eronata a parametrilor.
Problema 4
Se considera un vector care contine numarul variabil de perechi de pantaloni (p[20]), care se pot produce intr-o fabrica de confectii, costurile fixe necesare producerii acestor produse (cf), costul de productie variabil pe unitatea de produs (cp) si pretul de vanzare pe piata a acestui produs (pv). Se cere, utilizandu-se o functie constructor intr-o clasa adecvat definita, vectorul costurilor totale (ct), vectorul veniturilor obtinute prin vanzarea produselor (vt), vectorul profiturilor realizate si determinarea punctului critic care desparte zona pierderilor de zona de zona profitului. Se va utiliza supraincarcarea functiei constructor cu o a doua functie care sa afiseze un mesaj de eroare in cazul in care, functiei constructor principale, nu i se transmit toti parametrii necesari rezolvarii aplicatiei. De asemenea, se va utiliza tehnica pointerilor pentru vectorii utilizati, alocarea dinamica a memoriei necesare si verificarea alocarii corecte a volumului de memorie necesar.
#include<iostream.h>
#include<iomanip.h>
#include<malloc.h>
#include<stdlib.h>
#define nmax 20 //nr maxim de variante de productie
int i,j;
// definirea clasei cost_venit
class cost_venit
// descrierea primei functii constructor, de baza.
// cost_venit in afara clasei
cost_venit::cost_venit (int n, int *p, double cf, double cp, double pv)
// initializarea numarului cu variantele cantitatilor de fabricat
cost_venit::n=n;
// initializarea datei cu costurile fixe
cost_venit::cf=cf;
// initializarea datei cu costurile unitare pe produs
cost_venit::cp=cp;
// initializarea datei cu preturile unitare pe produs
cost_venit::pv=pv;
// initializarea vectorului cu cantitatile de fabricat
for(i=0;i<n;i++) cost_venit::p[i]=p[i];
cout<<'n=================================';
// lansarea functiei de ordonare vector de produse
ordonare_vector_produse(n);
cout<<'n vectorul produselor fabricate';
cout<<'n ================================n';
afiseaza_vector_produse(n);
cout<<'n ================================n';
cout<<'n datele produselor cf,cp,pv ';
cout<<'n ================================n';
afiseaza_date_produse();
cout<<'n ================================n';
calcul_costuri_produse(n);
cout<<'n vectorul costurilor totale pe produse';
cout<<'n =======================================n';
afiseaza_vector_costuri(n);
cout<<'n =================================';
calcul_venituri_produse(n);
cout<<'n vectorul veniturilor totale pe produse';
cout<<'n =======================================n';
afiseaza_vector_venituri(n);
cout<<'n =================================';
cout<<'n vectorul profitului total pe nr de produse';
cout<<'n =======================================n';
afiseaza_vector_profit(n);
cout<<'n =================================';
determinare_max_produse(n);
calcul_punct_critic(n);
// supraincarcarea functiei constructor prin declararea
// celei de-a doua functie constructor in afara clasei
cost_venit::cost_venit(void)
// descrierea functiei calcul_costuri_produse
//in afara clasei cu ajutorul pointerilor
void cost_venit::ordonare_vector_produse(int n)
}
}
void cost_venit::determinare_max_produse(int n)
void cost_venit::calcul_costuri_produse(int n)
// descrierea functiei calcul_venituri_produse
//in afara clasei cu ajutorul pointerilor
void cost_venit::calcul_venituri_produse(int n)
// descrierea functiei afiseaza_vector_produse
// in afara clasei cu ajutorul pointerilor
void cost_venit::afiseaza_vector_produse(int n)
}
// descrierea functiei afiseaza_vector_costuri
//in afara clasei cu ajutorul pointerilor
void cost_venit::afiseaza_vector_costuri(int n)
}
// descrierea functiei afiseaza_vector_profit
//in afara clasei cu ajutorul pointerilor
void cost_venit::afiseaza_vector_profit(int n)
}
// descrierea functiei afiseaza_vector_venituri
//in afara clasei cu ajutorul pointerilor
void cost_venit::afiseaza_vector_venituri(int n)
}
// descrierea functiei calcul_punct_critic
//in afara clasei cu ajutorul pointerilor
void cost_venit::calcul_punct_critic(int n)
}
if(!ok)
else
}
// descrierea functiei afiseaza_punct_critic
//in afara clasei cu ajutorul pointerilor
void cost_venit::afiseaza_punct_critic()
void cost_venit::afiseaza_date_produse()
void main()
while(r=='d')
while((n<1)||(n>20));
do
while((cf<10000)||(cf>1000000));
do
while((cp<10)||(cp>100));
do
while((pv<100)||(pv>300));
//citirea vectorului cu cantitatile posibile de fabricat
for(i=0;i<n;i++)
cout<<'n variantele cantitatile de fabricat:n';
for(i=0;i<n;i++) cout<<ptrp[i]<<' ';
//apelarea functiei constructor, consumuri, cu parametri expliciti
cost_venit f_cost_venit(n,ptrp,cf,cp,pv);
// apelarea fara parametri a functiei constructor supraincarcata
cost_venit f_cost_venit_vida;
cout<<'n continuati?(d/n):';
cin>>r;
}
In urma executarii acestui program se obtin rezultatele afisate mai jos, care ilustreaza modul in care se realizeaza supraincarcarea functiei constructor, alocarea dinamica de memorie pentru vectorii folositi precum si verificarea alocarii memoriei necesare acestora. Apelarea functiei constructor cu parametri efectivi valizi, determina initializarea datelor membre, obtinerea si afisarea rezultatelor, iar apelarea eronata a functiei constructor, in cazul de fata fara specificarea parametrilor efectivi, antreneaza executarea celei de-a doua functii constructor, care va afisa mesajul de eroare corespunzator 'lista parametrilor efectivi eronata'.
numarul de variante de fabricate,n(1<=n<=20):4
cheltuielile fixe ale fabricii(10000<<cf<<1000000):20000
costurile unitare de productie (10<<cp<<100):40
preturile unitare de vanzare (100<<cp<<300):200
cantitatea de fabricat din varianta 0 =200
cantitatea de fabricat din varianta 1 =50
cantitatea de fabricat din varianta 2 =150
cantitatea de fabricat din varianta 3 =100
variantele cantitatile de fabricat:
200 50 150 100
functia constructor cost_venit
=================================
vectorul produselor fabricate
================================
50 100 150 200
================================
datele produselor cf,cp,pv
=======================================
cheltuielile fixe ale fabricii:20000.00
costul de productie pe produs :40.00
pretul de vanzare al produsului:200.00
vectorul costurilor totale pe produse
=======================================
=======================================
vectorul veniturilor totale pe produse
=======================================
10000.000 20000.000 30000.000 40000.000
=======================================
vectorul profitului total pe nr de produse
==========================================
-12000.000 -4000.000 4000.000 12000.000
==========================================
nr maxim de produse de fabricat:200
afisarea punctului critic
=================================
punctul critic este atunci cand:
nr produse =125
costurile totale =25000.000
veniturile totale =25000.000
=================================
lista parametrilor efectivi eronata
continuati?(d/n):d
numarul de variante de fabricate,n(1<=n<=20):5
cheltuielile fixe ale fabricii(10000<<cf<<1000000):50000
costurile unitare de productie (10<<cp<<100):50
preturile unitare de vanzare (100<<cp<<300):100
cantitatea de fabricat din varianta 0 =150
cantitatea de fabricat din varianta 1 =200
cantitatea de fabricat din varianta 2 =50
cantitatea de fabricat din varianta 3 =100
cantitatea de fabricat din varianta 4 =250
variantele cantitatile de fabricat:
150 200 50 100 250
functia constructor cost_venit
=================================
vectorul produselor fabricate
=======================================
50 100 150 200 250
=======================================
datele produselor cf,cp,pv
================================
cheltuielile fixe ale fabricii:50000.00
costul de productie pe produs :50.00
pretul de vanzare al produsului:100.00
vectorul costurilor totale pe produse
=================================================
=================================================
vectorul veniturilor totale pe produse
=================================================
5000.000 10000.000 15000.000 20000.000 25000.000
=================================================
vectorul profitului total pe nr de produse
==========================================================
-47500.000 -45000.000 -42500.000 -40000.000 -37500.000
==========================================================
nr maxim de produse de fabricat:250
nu exista punct critic
la structura aleasa fabrica inregistreaza pierderi
lista parametrilor efectivi eronata
continuati?(d/n):n
In limbajul C++, exista posibilitatea supraincarcarii functiilor membre, prin folosirea acelorasi identificatori pentru mai multe functii, care urmeaza sa fie apelate si executate, la un anumit moment de timp. Inlaturarea ambiguitatilor legate de apelarea functiilor supraincarcate se poate face prin diferentierea parametrilor efectivi cum ar fi: numar diferit de parametri, tipuri diferite de parametri, etc..
Se considera o factura care contine mai multe materiale: cod material, un numar natural cuprins intre 1000 si 9999, denumirea materialului, un sir alfanumeric de carcatere, unitatea de masura in multimea (bc,kg,ml,mp,mc,etc), cantitatea si pretul. Prin intermediul unei clase, in care sunt definite doua functii cu acelasi nume sa se ordoneze elementele facturii dupa cod si sa se calculeze factura, adica sa se determine valoarea fiecarui material si TVA aferent precum si valoarea totala fara TVA si TVA total. Pentru inlaturarea ambiguitatii cu privire la functia apelata se va folosi un pointer declarat la functii care trebuie sa difere prin parametri.
#include<iostream.h>
#include<iomanip.h>
int i;
struct tipfact
class facturare
struct tipfact factura[20];
//void factura_ordonare (int n)
void f_factura (int n) //a doua functie cu acelasi nume
}
}
void calculeaza_factura(int n)
}
void afiseaza_factura(int n)
}
void main(void)
while((n<1)||(n>20));
for(i=0;i<n;i++)
while((f.cod<1000)||(f.cod>9999));
cout<<'n denumire material '<<i<<':';
cin>>f.denumire;
cout<<'n unitate de masura (bc,kg,mp,ml,mc) '<<i<<':';
cin>>f.umas;
cout<<'n cod pret '<<i<<':';
cin>>f.pret;
cout<<'n cantitate material '<<i<<':';
cin>>f.cant;
//obfactura.factura_citita(f,i);
// se aleleaza functia pentru inregistrarea unui rand al facturii
obfactura.f_factura(f,i);
}
// obfactura.factura_ordonare(n);
// se aleleaza functia pentru ordonarea dupa coduri a produselor facturii
obfactura.f_factura(n);
cout<<'n factura furnizor ';
cout<<'n ==========================================';
cout<<'n cod denumire umas pret cant valoare tva ';
cout<<'n =========================================n';
// se apeleaza functia de calcul a facturii
obfactura.calculeaza_factura(n);
// se apeleaza functia de afisare a facturii
obfactura.afiseaza_factura(n);
cout<<'n ==========================================';
cout<<'n continuati facturarea?(d/n):';
cin>>r;
}
In urma executarii acestui program sau obtinut rezultatele afisate mai jos, care pun in evidenta elementele de calcul ale unei facturi, cat, mai ales, modul de supraincarcare si utilizare a unor functii membre, inlaturandu-se ambiguitatile legate de folosirea acelorasi identificatori, prin utilizarea de parametri efectivi de apel diferiti ca numar sau ca tip.
numarul de pozitii din factura (1<=n<=20):2
cod material 0 (1000-9999):500
denumire material 0:var
unitate de masura (bc,kg,mp,ml,mc) 0:kg
pret art 0:0.85
cantitate material 0:255.00
cod material 1 (1000-9999):300
denumire material 1:ciment
unitate de masura (bc,kg,mp,ml,mc) 1:kg
pret art 1:0.55
cantitate material 1:375.85
factura furnizor
====================================================
cod denumire umas pret cant valoare tva
====================================
300 ciment kg 0.85 255.00 216.75 41.18
500 var kg 0.55 375.85 206.72 39.28
====================================
continuati facturarea?(d/n):d
numarul de pozitii din factura (1<=n<=20):
cod material 0 (1000-9999):
denumire material 0:
unitate de masura (bc,kg,mp,ml,mc) 0:
cod pret 0:
cantitate material 0:
cod material 1 (1000-9999):
denumire material 1:
unitate de masura (bc,kg,mp,ml,mc) 1:
cod pret 1:
cantitate material 1:
cod material 2 (1000-9999):
denumire material 2:
unitate de masura (bc,kg,mp,ml,mc) 2:
cod pret 2:
cantitate material 2:
factura furnizor
=======================================
cod denumire umas pret cant valoare tva
=======================================
100 lapte hl 255.56 45.26 11566.65 2197.66
300 unt bc 2.50 35.00 87.50 16.63
700 mere kg 2.55 34.75 88.61 16.84
========================================
continuati facturarea?(d/n):n
Probleme propuse:
1. Sa se proiecteze si sa se implementeze o clasa pentru standardul ISBN (International Standard Book Number). Un obiect al acestei clase este un numar ISBN unic asociat unei carti sau reviste, format din 10 cifre zecimale grupate in patru parti de dimensiune variabila:
grupul sau identificatorul de tara, pentru identificarea tarii editurii care a publicat cartea sau revista; in mod uzual toate editurile dintr-o anumita tara sau regiune geografica au acelasi numar de grup;
identificatorul de editura, pentru identificarea editurii in cadrul grupului de edituri;
identificatorul de titlu, pentru identificarea titlului unei carti sau reviste editata de editura respectiva;
cifra de control, care este intotdeauna formata dintr-o singura cifra.
Spre deosebire de celelalte grupuri, cigra de control poate sa fie atat o cifra zecimala, dar si litera X. Aceasta corespunde numarului 10 si se datoreaza modului de determinare al cifrei de control: ea este valoarea modulo 11 din numarul obtinut prin concatenarea tuturor celor 10 cifre. Clasa va avea ca data membru un sir de carcatere ce reprezinta un ISBN, utilizand caracterul '-' pentru separarea celor patru grupuri. Ea va trebui sa contina cel putin urmatoarele functii membru:
un constructor, in cazul specificarii doar a primelor trei grupuri, cifra de control fiind generata automat;
un constructor, in cazul specificarii complete a ISBN-ului, ca un sir de 13 caractere;
o functie care verifica validitatea cifrei de control;
o functie de afisare a ISBN-ului.
2. Sa se proiecteze si sa se implementeze o clasa pentru reprezentarea cartilor dintr-o biblioteca. Pentru fiecare carte trebuie specificate:
titlul cartii
autorul (autorii);
editura;
numarul de ISBN (sir de caractere);
anul aparitiei;
pretul.
Sa se scrie un program care creeaza un tablou cu cartile dintr-o biblioteca si permite operatia de cautare a unor carti in functie de: tittlu, editura, sau ISBN. Functiile clasei vor fi alese astfel incat sa permita operatiile mentionate.
3. Sa se proiecteze si sa se implementeze o clasa pentru gestionarea datelor calendaristice. O data calendaristica este un sir de caractere de forma <zi>/<luna>/<an> si poate fi transformata intr-un intreg reprezentand numarul zilei respective din anul curent (data "1/ianuarie/2002" are asociat numarul 1). Sa se prevada functii membru specifice pentru urmatoarele operatii:
crearea unei date calendaristice plecand de la sirul de caractere aferent;
crearea unei date calendaristice plecand de la numarul zilei asociate;
verificarea validitatii unei date calendaristive;
modificarea zilei, lunii sau a anului unei date calendaristice;
accesul la zilua, luna sau a anului unei date calendaristice;
afisarea unei zile claendaristice.
Sa se scrie un program care permite crearea, consultarea si modificarea unei agende electronice cu activitatile dintr-o saptamana. Nu se vor specifica decat datele calendaristice, nu si activitatile asociate.
|
Politica de confidentialitate | Termeni si conditii de utilizare |
Vizualizari: 1712
Importanta: 
Termeni si conditii de utilizare | Contact
© SCRIGROUP 2024 . All rights reserved
