Scrigroup - Documente si articole

Username / Parola inexistente      

Home Documente Upload Resurse Alte limbi doc  


AccessAdobe photoshopAlgoritmiAutocadBaze de dateC
C sharpCalculatoareCorel drawDot netExcelFox pro
FrontpageHardwareHtmlInternetJavaLinux
MatlabMs dosPascalPhpPower pointRetele calculatoare
SqlTutorialsWebdesignWindowsWordXml

Declararea si utilizarea functiilor de clasa speciale

calculatoare

+ Font mai mare | - Font mai mic



DOCUMENTE SIMILARE

Trimite pe Messenger
Wap
Utilizare de programe utilitare specializate pe diferite domenii
Subiecte rezolvate la informatica economica
DESPRE APLICATIILE INFORMATICII IN MEDICINA
LUCRARE DE OBTINERE A ATESTATULUI IN INFORMATICA - OPERATII CU POLINOAME
SUBIECTE + RASPUNSURI INFORMATICA
Avantajele sistemului informatic
Elemente generale Lotus Notes
Proiect MS
Guvernarea electronica si economia digitala


Declararea si utilizarea functiilor de clasa speciale

1. Functiile constructor

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.

Problema 1

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).

Problema 2

Se considera o suma s0=100000 depusa initial la o banca, cu dobanda 10% pe o perioada de 10 ani. Sa se determine, dupa fiecare an suma cumulata si dobanda cumulata, utilizandu-se o clasa cu functie constructor corespunzatoare avand parametri impliciti dati (s0=100000, p=10% si n=10 ani), care sa permita, totodata, obtinerea rezultatelor pentru orice suma s0 (100000<=s0<=1000000), orice dobanda p (10<<p<=100) si pentru orice perioada n (5<=n<=20).

#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..

Problema 5

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



DISTRIBUIE DOCUMENTUL

Comentarii


Vizualizari: 1065
Importanta: rank

Comenteaza documentul:

Te rugam sa te autentifici sau sa iti faci cont pentru a putea comenta

Creaza cont nou

Termeni si conditii de utilizare | Contact
© SCRIGROUP 2022 . All rights reserved

Distribuie URL

Adauga cod HTML in site