Documente Academic
Documente Profesional
Documente Cultură
Explicatii C & C++
Explicatii C & C++
C+
PO
Curs
Programarea Orientat Obiect
++
POO
2010 - 2011
07.05.15
C+
PO
1. Redactarea programelor C
1.1. Generaliti
Mediul Borland C a fost extins la Visual C i C++ Builder, adaptate programrii
orientate obiect i interfeei grafice Windows 95. Limbajul C a fost extins la C++ permind
aplicarea conceptelor programrii prin abstractizarea datelor i programrii orientate spre
obiecte.
Fiierele surs pot avea extensia C, CP, sau CPP.
07.05.15
# include specificator_fiier
# include <specificator_fiier>
#include <stdio.h>;
#include <iostream.h>;
C+
PO
// nlocuiete Pi cu 3.141592
1.3. Funcii
O funcie este format dintr-un antet i un bloc (corp). Ea poate fi apelat dac a
fost definit n ntregime sau doar antetul su.
Antetul unei funcii are urmtorul format:
Tip Nume (List_parametri_formali)
unde:
07.05.15
// Cmmdc(a,b)
// Cmmdc(b,a Mod b);
// cmmdc(a,b)
// rest 0;
C+
PO
int (Z [-215,215-1]),
short (Z [-215,215-1]),
long (Z [-231,231-1]),
unsigned (N [0,216-1]),
Constantele numerice pot fi zecimale (123, 123Long, 111long), octale (077), hexa
(0xabba, 0Xfac), sau flotante (2.71828, 6.023e23, 6.023E23).
Constantele de tip caracter pot fi afiabile ('A', '0', '"') sau funcionale
('\b'=Backspace, '\r'=Return, '\n'=Newline, '\''=Apostrof, '\\'=Backslash, '\v'=Verticaltab,
'\f'=Salt de pagin, '\0'=Null.
Constantele de tip ir de caractere se scriu ntre ghilimele ("Mesaj").
Declararea variabilelor simple se face astfel:
Tip List_identificatori_de_variabile;
Exemplu:
int i, j;
float x,y;
char c;
Exemple:
07.05.15
float x[100];
int a[2,2];
a[0][0]=1;
a[1][0]=3;
a[0][1]=2;
a[1][1]=4;
C+
PO
2. Variabile
Variabilele pot fi statice sau dinamice, locale sau globale.
// variabil extern
07.05.15
C+
PO
Exemplu:
VLocale.Cpp:
#include <stdio.h>;
#include "Sursa.h";
void main (void)
{ int n;
printf(" Dati un numar < 256 : "); scanf("%d",&n);
printf(" Valoarea in Hexa este ");
Print_Hexa(n);
// Print_Byte(n/256); Print_Byte(n%256);
!?
scanf ("\n");
}
Sursa.h:
static int Cifra_Hexa (int s)
{
static int c;
if (s<10) c=s+'0';
else c=s+'A'-10;
// c=s+'0'+7
return c;
}
static void Print_Byte(int b)
{
static int H = b / 16;
static int h = b % 16;
printf("%c%c",Cifra_Hexa(H),Cifra_Hexa(h));
}
void Print_Hexa(int z)
{
static int HH = z / 256; Print_Byte(HH);
static int hh = z % 256; Print_Byte(hh);
}
07.05.15
...
C+
PO
07.05.15
C+
PO
3. Expresii
O expresie este format din operanzi, operatori i paranteze pentru prioritate, i
are o valoare i un tip. Asocierea operatorilor se face de la stnga la dreapta, cu excepia
operatorilor unari i de atribuire, care se asociaz de la dreapta la stnga.
Operanzii pot fi: constante, constante simbolice, variabile simple sau structurate
(tablouri, structuri, sau elemente ale acestora), funcii sau apeluri de funcii.
3.1. Operatori
Operatorii, n ordinea descresctoare a prioritii sunt urmtorii:
(
)
(unar) + (unar)
*
/
+
<<
>>
<
<=
==
!=
&
^
|
&&
||
?: (ternar)
=
*=
,
[
]
* (unar) & (unar)
%
>=
>
/=
%=
+=
++
(tip) sizeof
^=
|=
07.05.15
// 13 / 5 = 2
// 13%5 = 3
C+
PO
// == 1
// == 0
Deoarece nu exist tipul boolean, valoarea fals este reprezentat prin 0, iar
adevrat prin orice valoare diferit de 0.
Operaii pe bii se pot realiza utiliznd urmtorii operatori:
~ (complementul fa de FFFF, schimb fiecare bit), << (deplasare la stnga),
>> (deplasare la dreapta), & (And bit cu bit), ^ (Xor bit cu bit), | (Or bit cu bit).
Exemplu:
// ASCII
#include <stdio.h>;
#include <conio.h>;
int Cifra(int c)
// cifra hexa: 01...9AB...F
{
if (c<10) return c
| '0';
else
return (c-9) | '@';
}
int c;
void main (void)
{ textbackground(BLUE); textcolor(WHITE); clrscr();
do { printf(" Dati un caracter #Esc : "); c=getch();
printf(" ... Hexa = %c%c \n",Cifra(c>>4),Cifra(c&0xF)); }
while (c!=0x1B);
}
07.05.15
C+
PO
avnd semnificaia:
Var = Var Expresie;
Exemple:
v = e = 2.7181828;
x += dx; y = dy;
n <<= k;
// v = (e = 2.7181828);
// x = x+dx; y = y dy;
// n = n*2k
forma prefixat:
++ operand ;
respectiv operand ;
operand ;
forma postfixat:
operand ++;
respectiv
Exemple:
a = ++b;
a = b ;
// b=b+1;
// a=b;
a=b;
b=b1;
07.05.15
// a Div b = 2.00
// a / b = 2.40
C+
PO
charint,
b)
floatdouble,
c)
(double,*)(double,double)=double,
d)
(long,*)(long,long)=long,
e)
(unsigned,*)(unsigned,unsigned)=unsigned.
Operatorii condiionali ?
Expresie1 ? Expresie2
: Expresie3
Valoarea expresiei rezultat este Expresie2 dac Expresie1 este nenul, altfel este Expresie3 .
Exemplu:
Max = a>b ? a : b;
Operatorul virgul permite gruparea mai multor expresii ntr-una singur, aceasta
avnd valoarea ultimei expresii:
Expresie1 , Expresie2 , ...
, Expresien ;
Exemplu:
float x0,y0,r, x, y;
printf(" Dati C(x0,y0,r) = "); scanf("%f %f %f",&x0,&y0,&r);
// Cercul C
printf(" Dati P(x,y)
= "); scanf("%f %f", &x, &y
);
// Punctul P
printf(" %s",((x-=x0, y-=y0, x*=x, y*=y, x+y)==r*r) ? "P e pe C" : "P nu e pe C");
07.05.15
10
C+
PO
4.
Operaii de intrare/ieire
[f]
unde:
[]
[m]
[.n]
[ l]
[f]
d
o
x
X
u
c
s
f
e
E
g
G
Funcia printf returneaz numrul de octei afiai dac operaia a decurs corect, iar
n caz contrar -1 (EOF):
if (EOF = = printf (Control , List_Expresii)) ... eroare ... ;
07.05.15
11
C+
PO
Exemplu:
short Zi=1; char Luna[]="Ianuarie"; unsigned An=2003;
float Ina=1.8;
printf(" Zi:%d, Luna:%3.3s., An:%u \n",Zi,Luna,An); // Zi:1, Luna:Ian., An:2003
printf(" Inaltime(m):%4.2f \n",Ina);
// Inaltime(m):1.80
[*]
[m]
[ l]
[f]
[ f ] , unde:
- un caracter opional,
- precizeaz lungimea maxim a cmpului,
- conversia se va efectua din format intern long,
- determin tipul conversiei precizat prin unul din urmtoarele caractere:
d
o
x
X
u
c
s
f
Adresele variabilelor de intrare sunt date prin operatorul de adrese & plasat naintea
identificatorului fiecrei variabile (simple!): [&] Variabil
Exemplu:
short Zi; char Luna[13]; unsigned An; float Ina;
scanf(" %d %s %u %f ", &Zi, Luna, &An, &Ina);
07.05.15
12
C+
PO
getchar
putchar
getchar
putchar
// se termin cu .
LLiIt TeErReE
mMiIcCiI
iInN
LLiIt TeErReE
MMAARRII..
// se termin cu .
LITERE MICI IN LITERE MARI. // S-a tastat: Litere mici in Litere MARI.
07.05.15
13
C+
PO
5.
Instruciuni
// Atribuire:
v=Expresie;
// Apel de funcie:
f(p1, p2,... , pn);
// Incrementri/Decrementri (Pre/Post fixate)
{
Declaraii
Instruciuni
}
Exemplu:
{
int i;
f (i);
} ;
07.05.15
//
// Dup } nu se pune ;
14
C+
PO
5.4. Instruciunea If
Structura alternativ cu una sau dou ramuri poate fi scris astfel:
if (expresie) instructiune1;
[ else instructiune2; ]
Exemplu:
P(x,y) I-ul Cadran (Dac x sau y este negativ se schimb semnul )
float x, y;
printf(" Dati P(x,y) = "); scanf("%f %f", &x,&y); // Punctul P
if (x>0) if (y<0) y=-y;
// C4 else_; (instruciunea vid)
else { x=-x;
// C2 sau C3
(x)
if (y<0) y=-y;
// C3
(y)
}
printf(" x=%5.2f, y=%5.2f \n", x,y) ;
}
// trebuie pus pentru C1 instruciunea vid: else_;
{
[ break; ]
[ break; ]
07.05.15
// O1 o O2
// Ctrl/Z
15
C+
PO
Exemplu:
// Nr.Zile / lun \\
#include <iostream.h>
#include <conio.h>
void main (void)
{ int l,a;
cout << " Dati anul : "; cin >> a;
cout << " Numar de zile ... " << endl;
for (l=1; l<=12; l++) {
cout << l << " : ";
switch (l) {
case 2 : cout << (a&3 ? 28 : 29); break;
case 4 :
case 6 :
case 9 :
case 11 : cout <<
30 ; break;
default : cout <<
31 ;
}
cout << endl;
}
// break;
getche();
07.05.15
// c!=0
16
C+
PO
if (expr) break;
{ ...
... }
{ ...
... }
07.05.15
17
C+
PO
while (expr1)
if (expr2) goto et;
{ ...
... }
...
et: ...
// instruciune
O funcie poate fi utilizat doar dac a fost definit sau cel puin a fost declarat
prototipul ei ntr-una din urmtoarele moduri:
Tip_ funcie
b) Tip_ funcie
c) Tip_ funcie
d) Tip_ funcie
a)
Apelul implicit pentru variabile simple (de baz) este prin valoare, iar pentru
tablouri prin referin. Apelul prin referin se obine prin intermediul variabilelor de tip
pointer i a operatorului de adres &.
Revenirea dintr-o funcie se poate realiza fie prin instruciunea return, fie automat
dup ultima instruciune a funciei (situaie n care nu se returneaz nici o valoare):
return [ expresie ] ;
fiind returnat valoarea expresiei (dac exist).
Ex. 1:
#include <graphics.h> #include <math.h>
int u1,v1, u2,v2;
float a, b, c, d ;
int u (float x) { return ((x-a)/(b-a)*(u2-u1)+u1); }
int v (float y) { return ((y-d)/(c-d)*(v2-v1)+v1); }
void InitGraf(void)
{ int Gd = DETECT, Gm; initgraph(&Gd, &Gm, "c:\\Bc\\Bgi"); }
void ViewPort(int x1,int y1,int x2,int y2)
{u1=x1; v1=y1; u2=x2; v2=y2; /*rectangle(u1,v1,u2,v2);*/ }
void Window(float x1,float y1,float x2,float y2)
{ a=x1; d=y1; b=x2; c=y2; }
void Rectangle(float x1,float y1,float x2,float y2) { rectangle(u(x1),v(y1),u(x2),v(y2)); }
void Bar(float x1,float y1,float x2,float y2)
{ bar(u(x1),v(y1),u(x2),v(y2)); }
void Linie(float x1,float y1,float x2,float y2)
{ line(u(x1),v(y1),u(x2),v(y2)); }
void Muta(float x,float y)
{ moveto(u(x),v(y)); }
void Trag(float x,float y)
{ lineto(u(x),v(y)); }
void Rot(float &x,float &y, float x0, float y0, float Alfa) {
float xp;
xp=(x-x0)*cos(Alfa)-(y-y0)*sin(Alfa)+x0;
y =(x-x0)*sin(Alfa)+(y-y0)*cos(Alfa)+y0;
x = xp; }
Ex. 2:
// Ultima cifr nenul a lui n! \\
#include <iostream.h>;
#include <conio.h>;
int Sf (int& f, int k)
{ int p=0;
07.05.15
18
C+
PO
Ex. 3:
// Calc. AB, AB \\
#include <iostream.h>;
#include <conio.h>;
int Card(int A[])
{
return A[0];
}
int Apart (int x, int A[])
{
for (int i=1; i<=Card(A); i++) if (x==A[i]) return 1; return 0;
}
void n (int A[], int B[], int C[])
{
C[0]=0;
for (int i=1; i<=Card(A); i++) if (Apart(A[i],B)) C[++C[0]]=A[i];
}
void u (int A[], int B[], int C[])
{ int i;
for (i=0; i<=Card(B); i++) C[i]=B[i];
for (i=1; i<=Card(A); i++) if (!Apart(A[i],B)) C[++C[0]]=A[i];
}
void Tip (char *Mult, int A[])
{ int i; cout << Mult << '{' ;
for (i=1; i<=Card(A); i++) cout << A[i] << ",";
cout << "\b}" << endl;
}
void main (void)
{
clrscr();
int A[]={5, 1,3,5,7,9};
Tip (" A : ",A);
int B[]={5, 1,2,3,4,5};
Tip (" B : ",B);
int AuB[10]; u (A,B,AuB); Tip (" AuB = ",AuB);
int AnB[10]; n (A,B,AnB); Tip (" AnB = ",AnB);
getche();
}
07.05.15
19
C+
PO
6. Pointeri
O variabil p de tip pointer conine adresa unei variabile a crei valoare se obine
utiliznd operatorul * (*p = valoarea variabilei de la adresa coninut n p).
Adresa unei variabile v se poate obine prin operatorul & (&v = adresa variabilei v),
deci putem atribui unui pointer p adresa unei variabile v astfel:
p = &v;
int Cifra(int c)
{ if (c<10) return c | '0'; else return (c-9)|'@'; }
void Cifre(int b)
{ printf("%c%c",Cifra(b>>4),Cifra(b&0xF)); }
void main (void)
{ int *Pointer_Int; void *p; unsigned *Pointer_Word; int x;
printf(" Dati x : "); scanf("%d",&x);
p=Pointer_Int=&x; Pointer_Word=(unsigned *) p;
printf(" x =%u \n",*Pointer_Word);
printf(" |x|=%d \n",sizeof *Pointer_Word);
printf(" |&x|=%d \n",sizeof Pointer_Word);
printf("*(&x)=");
Cifre(*Pointer_Word>>8); Cifre(*Pointer_Word&0xFF);
printf("\n");
}
getch();
Date:
Rezultate :
Dati x : 43962
x =43962
|x| =2
|&x|=2
*(&x)=ABBA
Date:
Dati x : -1
Rezultate : x = 65535
|x| =2
|&x|=2
*(&x)=FFFF
07.05.15
20
C+
PO
6.2.1.
Incrementare / Decrementare
Var_Pointer ;
Exemplu:
int Zile[]={31,28,31,30,31,30,31,31,30,31,30,31 }; int *Pointer_Int; int Luna;
// 0,1,...,11
printf(" Dati luna (1-12):"); scanf("%d",&Luna);
Pointer_Int=&Zile[Luna]; Pointer_Int--;
// &Zile[Luna-1]
printf(" Nr.Zile =%d \n",*Pointer_Int);
6.2.2.
6.2.3.
Comparare
Doi pointeri ale elementului aceluiai tablou pot fi comparai utiliznd operatorii
relaionali. Valoarea NULL marcheaz faptul c un pointer nu refer nici un element.
... p1
< p2 ... ;
... p1
= = p2 ... ;
... p1
!= p2 ... ;
... p
= = NULL ...;
Exemplu:
int Zile[]={0,31,29,31,30,31,30,31,31,30,31,30,31 }; int *luna; int Zi,Luna,An, NrZile;
printf(" Zi, Luna, An : "); scanf("%d %d %d",&Zi,&Luna,&An);
if (An&3) Zile[2]=28; if ((Zi>Zile[Luna]) || (Luna>12)) luna=NULL; else luna=Zile;
if (luna!=NULL) { NrZile=Zi; do NrZile+=*(luna++); while (luna<Zile+Luna);
printf(" A %d zi a anului \n",NrZile);
}
else
printf(" Data calendaristica incorecta! \n");
6.2.4.
Diferen
07.05.15
21
C+
PO
Exemplu:
// Operaii cu pointeri \\
#include <iostream.h>
#include <conio.h>
clrscr();
getche();
Exemplu:
#include <stdio.h>;
#include <malloc.h>;
#include <conio.h>;
int Cifra(int c)
void Cifre(int b)
#include "Crt.Cpp";
{ if (c<10) return c | '0'; else return (c-9)|'@'; }
{ printf("%c%c",Cifra(b>>4),Cifra(b&0xF)); }
free(Pointer_Word);
getch();
07.05.15
22
C+
PO
Numele unei funcii fiind un pointer la acea funcie, ea poate fi parametru actual, i
evident trebuie descris ca parametru formal:
...
Exemplu:
// Pointeri la func ii (1) \\
#include <graphics.h>
#include <conio.h>
float Sin (float x)
float Sqr (float x)
#include <stdlib.h>
#include <math.h>
{ return sin (x); }
{ return pow (x,2);}
#include <stdio.h>
#include "Graf.h"
float Cos (float x)
float Sqrt(float x)
#define Pi 3.1415926
{ return cos (x); }
{ return sqrt(x); }
void main(void)
{
InitGraph ();
getch(); closegraph();
}
<iostream.h>
<stdio.h>
<conio.h>
<math.h>
07.05.15
cos,
Cos
tan };
Tg "};
clrscr();
clrscr();
getch();
23
C+
PO
ArgV[0]
- pointer la Nume_Program (!),
ArgV[1]
- pointer la primul parametru,
...
#include <stdlib.h>;
// Calendar 2003
else printf (" Dati in linia de comada ziua si luna (din 2003) ! \n");
}
//
>Calendar 15 3
Valoare ] ;
sau
#include <conio.h>;
6.7. S t i va
07.05.15
24
C+
PO
Prin stiv nelegem o list cu disciplina Last In First Out pentru care vom defini
urmtoarele trei funcii:
Push - adaug un element n stiv,
Pop
- extrage un element din stiv,
Clear - iniializarea stivei (stiv vid),
Vida
- verific dac stiva este vid:
// Fact.Cpp \\
// Stiva.h \\
#include <stdio.h>
#include <conio.h>
#include "Stiva.h"
void main(void)
#define DimMax 13
static int Stiva[DimMax];
void Push(int x)
static Next=0;
if (Next<DimMax) Stiva[Next++]=x;
else printf(" Depasire stiva \n");
}
int Pop()
{
if (Next>0) return Stiva[--Next];
else { printf(" Stiva vida \n"); return 0; }
}
void Clear()
int Vida()
{ Next=0; }
{
7. Recursiviate
Exist posibilitatea de a defini o funcie prin ea nsi (recursiv).
Exemplu:
#include <conio.h>
#include <iostream.h>
#define Max (x,y) (x>y ? x : y)
int a[100];
int Maxim(int n)
{
}
void main(void)
{
07.05.15
25
C+
PO
8. Tipuri de date
Exist posibilitatea de a defini noi tipuri de date i chiar de a le denumi.
tip Denumire_Tip ;
Exemplu:
typedef int Integer ;
Integer i,j;
int Zile[]={31,28,31,30,31,30,31,31,30,31,30,31};
int Zi,Luna,luna;
printf(" Zi, Luna : "); scanf("%d %d",&Zi,&Luna);
for (luna=1; luna<Luna; luna++) Zi+=Zile[luna-1];
Zi_Sapt=Luni; Zi=(Zi+1)%7; while (Zi--) Zi_Sapt++;
if (Zi_Sapt<Sambata) Zi_Lucratoare=True;
else
Zi_Lucratoare=False;
if (Zi_Lucratoare)
printf(" Este o zi lucratoare \n");
else
printf(" Este o zi libera \n");
getch();
// sau Zi_Sapt=Zi_Sapt+1;
07.05.15
26
C+
PO
Punct O = { 0, 0 }; Cerc C;
printf(" \n Cerc : "); scanf("%f %f %f",&C.Centru.x,&C.Centru.y,&C.Raza);
printf(" \n C(x0,y0,r)= %5.2f %5.2f %5.2f",C.Centru.x,C.Centru.y,C.Raza);
if (Sqr(C.Centru.x-O.x)+Sqr(C.Centru.y-O.y)<=Sqr(C.Raza)) printf(" \n C contine O");
else printf(" \n C nu cont.O");
getch();
}
sau
Var_Ref >Component;
Exemplu:
...
07.05.15
27
C+
PO
sau
Var_Ref >Component;
Exemplu:
...
union U { float
Real;
long unsigned Hexa; } x;
int Cifra(int c)
void Cifre(int b)
void Print(unsigned x)
07.05.15
28
C+
PO
07.05.15
29
C+
PO
Exemplu:
// List simpl ordonat cresctor \\
#include <iostream.h>
#include "Crt.Cpp"
typedef int Info;
struct Elem;
typedef Elem* Lista;
struct Elem {Info Inf; Lista Urm;};
int Citit(Info& inf)
{ cin >> inf; return inf; }
void Ado(Lista& L, Info inf)
{
if (L && (L->Inf<inf)) Ado(L->Urm,inf);
//
else {Lista Nou=new Elem; Nou->Inf=inf; Nou->Urm=L; L=Nou;}
//sau
else {Elem el={inf,L}; Lista Nou = new Elem (el); L=Nou;}
}
void Cre(Lista& L)
{
Info El; L=NULL;
while (Citit(El)) Ado(L,El); }
void Tip(Lista L)
{
if (L) {cout << L->Inf << ','; Tip(L->Urm); } cout << "\b."; }
void main (void)
{
ClrScr();
Lista L;
cout << " Lista : "; Cre (L);
cout << " Lista = "; Tip (L);
Readln();
}
07.05.15
30
C+
PO
<stdio.h>
<alloc.h>
<string.h>
<iostream.h>
<graphics.h>
<conio.h>
TInf Inf ;
Nod* Ls;
Nod* Ld;
// Radacin \\
// Sub.St, Sub.Dr
} ;
typedef Nod* Arb;
int Citit(TInf &Inf)
{
cin >> Inf; return (Inf[0]!='.'); }
void Gen(Arb &A)
{
TInf Inf; int Lung=sizeof(Nod);
if (Citit(Inf)) { A=(Arb) malloc(Lung);
strcpy (A->Inf,Inf);
// A->Inf=Inf;
cout << " Mama lui " << Inf << " : "; Gen(A->Ls);
cout << " Tatal lui " << Inf << " : "; Gen(A->Ld); }
else A=NULL;
}
void Repr_Grafic(Arb A, int u1, int v1, int u2, int v2, int p)
{
int m;
if (A!=NULL) { m=(u1+u2)/2;
if (v1>20) lineto(m,v1-13);
ellipse(m,v1,0,360,31,13);
outtextxy(m,v1,A->Inf);
moveto(m-2,v1+13);
Repr_Grafic(A->Ls,u1,v1+p,m,v2,p);
// St
moveto(m+2,v1+13);
Repr_Grafic(A->Ld,m,v1+p,u2,v2,p); }
// Dr
}
int Max (int a, int b)
{
return (a>b ? a : b); }
int Adi(Arb A)
{
if (A==NULL) return -1; else return Max(Adi(A->Ls),Adi(A->Ld))+1; }
void main (void)
{ Arb A;
cout << " Arbore genealogic ascendent pentru : "; Gen (A);
int Gd = DETECT, Gm; initgraph(&Gd, &Gm, "c:\\Bc\\Bgi");
settextjustify(CENTER_TEXT,CENTER_TEXT);
Repr_Grafic(A,50,20,getmaxx()-50,getmaxy()-20,(getmaxy()-40)/Adi(A));
getchar(); closegraph();
}
07.05.15
31
C+
PO
10.1.1.
unde:
Dac deschiderea fiierului s-a realizat corect, atunci funcia returneaz o valoare
ntreag reprezentnd descriptorul de fiier (LUN, care va fi utilizat n continuare la celelelte
operaii efectuate asupra acestui fiier), iar n caz de nereuit se va returna valoarea -1.
Pentru a putea utiliza funcia Open trebuie incluse fiierele header io.h i fcntl.h.
Exemplu:
...
int Lun;
Lun = open (Fisier.Dat,ORDONLY);
...
mod - poate lua una dintre valorile: S_IREAD (fiierul se poate citi), S_IWRITE
(scriere n fiier), S_IEXEC (execuia programului din fiierul specificat).
Pentru a putea utiliza funcia Creat trebuie incluse fiierele io.h i stat.h.
Fiierele text sunt implicite.
07.05.15
32
C+
PO
10.1.2.
unde:
3=STDPRN, 4=STDAUX),
buffer - este zona de memorie n care se citete,
l u n g - este lungimea (n octei) a nregistrrii citite.
Funcia returneaz numrul de octei citii (cel mult l u n g ), 0 la sfrit, sau -1 n caz
de eroare. Automat, dup o citire (a articolului curent) se trece la urmtorul articol, implicit
prima poziionare fiind la nceput de fiier (acces secvenial).
Pentru a utiliza funciile Read, Write, LSeek sau Close trebuie inclus fiierul io.h.
10.1.3.
10.1.4.
10.1.5.
10.1.6.
07.05.15
33
C+
PO
Exemple:
//
Creare
\\
#include <io.h>
#include <fcntl.h>
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
void main (void)
{
int Lun;
clrscr();
Lun=open("Fis.Txt",O_CREAT|O_TEXT);
if (Lun!=-1)
{
cout << "Open ..." << endl;
write(Lun,"Primul...\n",10);
write(Lun,"Al Doilea\n",10);
}
else cout << " Open Incorect ! ";
close(Lun);
getchar();
}
//
Citire
\\
#include <io.h>
#include <fcntl.h>
#include <stdio.h>
#include <conio.h>
#include <iostream.h>
void main (void)
{
int Lun;
char Rand[10];
textmode(1); textbackground(BLUE);
textcolor(WHITE); clrscr();
Lun=open("Fis.Txt",O_TEXT);
if (Lun!=-1)
{
read(Lun,Rand,10); cout << Rand;
read(Lun,Rand,10); cout << Rand;
}
else cout << " Open Incorect ! ";
close(Lun);
getchar();
}
07.05.15
34
C+
PO
10.2.1.
unde:
Dac la deschiderea fiierului s-a ales modul w sau a, fiierul va fi creat (recreat).
Funcia returneaz un pointer spre tipul FILE definit n fiierul stdio.h, iar n caz de
nereuit se va returna valoarea NULL (stdin, stdout, stderr, stdaux i stdprn sunt pointeri
spre tipul FILE permind transferuri fr a fi necesar deschiderea sau nchiderea lor).
Exemplu:
...
FILE * Pf;
Pf = fopen (Fisier.Dat,w);
...
10.2.2.
unde:
getc (FILE * Pf ) ;
Funcia returneaz codul caracterului citit, sau valoarea EOF la sfritul fiierului,
sau -1 la eroare.
Exemplu:
#include <stdio.h>
void main (void)
{
}
07.05.15
int c;
while ((c=getc(stdin))!=EOF) putc(c,stdout);
35
C+
PO
10.2.3.
fclose ( FILE * Pf ) ;
10.2.4.
Ex.2:
// Creare fiier text cu format (articole : (Den, Cant, Pre)) \\
#include <stdio.h>
#include <conio.h>
void main (void)
{ FILE *Produse;
char Den[20];
int Cant;
float Pret;
int n=0;
int Eof;
textmode(1);
textbackground(BLUE);
textcolor(WHITE);
clrscr();
if (Produse=fopen("Fis_Form.Txt","w")) {
do {
printf (" Articolul %d \n",++n);
printf (" - Den. : "); Eof=(scanf("%s",Den)==EOF); if(!Eof){
printf (" - Cant.: "); scanf ("%d",&Cant);
printf (" - Pret : "); scanf ("%f",&Pret);
fprintf(Produse,"%-20s%4d%7.2f\n",Den,Cant,Pret);}
}
while (!Eof);
fclose (Produse);
}
else
printf (" Open incorect");
getchar();
36
C+
PO
#include <stdio.h>
#include <conio.h>
void main (void)
{ FILE *Produse;
char Den[20];
int Cant;
float Pret;
int n=0;
textmode(1);
textbackground(BLUE);
textcolor(WHITE);
clrscr();
if (Produse=fopen("Fis_Form.Txt","r")) {
while (fscanf(Produse,"%s%d%f",Den,&Cant,&Pret)!=EOF) {
printf (" Articolul %d : \n",++n);
printf (" - Den. : %-20s \n",Den);
printf (" - Cant.: %4d \n",Cant);
printf (" - Pret : %7.2f \n",Pret);
}
fclose (Produse); }
else printf (" Fisier Absent");
getchar();
10.2.5.
unde:
Fin_Niv_S.Cpp
Dictio.Txt
Traduce
Fin_Niv_S.Pas
07.05.15
37
C+
PO
#include <stdio.h>
#include <iostream.h>
#include <string.h>
#include <conio.h>
#include <process.h>
int Length(char* s)
{
return strlen(s); }
/*
int Pos(char* s, char* S)
{ for (int i=0; i<Length(S); i++) {
int Ok=1;
for (int j=0; j<Length(s); j++)
if (S[i+j]!=s[j]) { Ok=0; break; }
if (Ok) return i;
}
return -1;
} */
/*
void Delete(char* s, int p, int n)
{
while (n) { n--; for (int i=p; i<Length(s); i++) s[i]=s[i+1]; }
} */
/*
void Insert(char* s, char *S, int p)
{
for (int l=0; l<Length(s); l++) {
for (int i=Length(S); i>=p+l; i--) S[i+1]=S[i]; S[p+l]=s[l]; }
} */
}
void Subst (char* x, char* y, char* S)
{
int p=Pos(x,S);
if (p>=0) { Delete(S,p,Length(x)); Insert(y,S,p); }
}
void main (void)
{
clrscr();
const Dd=20; typedef char Cuv[Dd];
struct Per { Cuv St, Dr; };
Per Dictio[20]; int NrCuv=1;
FILE *Dic;
Dic=fopen("Dictio.Txt","r");
if (Dic==NULL) { cout << "Dictio ?"; getche(); exit(1); }
while (EOF!=fscanf(Dic,"%s%s",Dictio[NrCuv].St,Dictio[NrCuv].Dr))
cout << NrCuv << " : " << Dictio[NrCuv ].St
<< " -> " << Dictio[NrCuv++].Dr << endl;
fclose(Dic); NrCuv--;
getche();
FILE *FisI, *FisE;
FisI=fopen("F_Niv_S.Cpp","r"); FisE=fopen("F_Niv_S.Pas","w");
if (FisI==NULL) { cout << "Fisier ?"; getche(); exit(1); }
const Dm=100; char Rand[Dm];
while (fgets(Rand,Dm,FisI)) {
// !=NULL
for (int i=1; i<=NrCuv; i++)
while (Pos(Dictio[i].St,Rand)>=0)
Subst(Dictio[i].St,Dictio[i].Dr,Rand);
fputs(Rand,FisE);
cout << Rand; }
fclose(FisI); fclose(FisE);
getche();
}
10.2.6.
07.05.15
38
C+
PO
10.2.7.
Acest tip de prelucrare permite transferul mai multor articole aflate ntr-o zon
tampon astfel:
unsigned fread (void *Pzt, unsigned dim, unsigned nrart, FILE * Pf) ;
unde:
Pzt - este adresa zonei tampon,
dim - reprezint lungimea unui articol,
nrart - reprezint numrul de articole care se transfer (citesc),
unsigned fwrite (const void *Pzt, unsigned dim, unsigned nrart, FILE * Pf) ;
Ambele funcii returneaz numrul de articole transferate sau -1 la eroare.
Exemple:
#include <stdio.h>
typedef struct {
char Den[10];
int Cant;
float Pret;
Articol;
}
void main (void)
{ FILE *Pf; Articol Art;
int n,i;
("
("
("
("
Articolul %d
- Den. : ");
- Cant.: ");
- Pret : ");
scanf ("%d",&n);
: \n",i);
scanf ("%s", Art.Den );
scanf ("%d",&Art.Cant);
scanf ("%f",&Art.Pret);
fwrite (&Art,sizeof(Articol),1,Pf);
fclose (Pf);
getchar();
}
...
{...
fread
07.05.15
(&Art,sizeof(Articol),1,Pf);
printf("Articolul %d : \n",i);
printf("- Cant.: %d\n", Art.Cant);
39
C+
PO
isascii
isalpha
isalnum
isupper
islower
isdigit
isxdigit
isgraph
isprint
isspace
(int ca r );
(int ca r );
(int ca r );
(int ca r );
(int ca r );
(int ca r );
(int ca r );
(int ca r );
(int ca r );
(int ca r );
ca r
ca r
ca r
ca r
ca r
ca r
ca r
ca r
ca r
ca r
[0,127] ?
este codul unui caracter alfanumeric ?
este codul unei litere ?
este codul unei litere mari ?
este codul unei litere mici ?
este codul unei cifre zecimale ?
este codul unei cifre hexa ?
este codul unui caracter afiabil ?
este codul unui caracter imprimabil ?
este spaiu, tab, Cr, Lf, Vt sau Np ?
(int ca r );
(int ca r );
(int ca r );
11.3. Conversii
Funciile care urmeaz (aflate n fiierul stdlib.h) realizeaz conversii far format.
Format intern Format (zecimal ) extern
int
atoi (const char *pt r );
binar (int ) zecimal extern
long atol (const char *pt r );
binar (long) zecimal extern
double atof (const char *pt r );
virgul flotant (dubl precizie) zecimal extern
Format extern Format intern
char *itoa (int v,char *s, int b);
s v b (valoarea v de tip int, scris n baza b)
char *ltoa (long v,char *s, int b);
s v b (valoarea v de tip long scris n baza b)
07.05.15
40
C+
PO
11.4.1.
Copiere (Str[n]Cpy)
11.4.2.
Concatenare (Str[n]Cat)
11.4.3.
Comparare (Str[n][i]Cmp)
11.4.4.
Semnificaie
sin(x)
cos(x)
arcsin(x)
arccos(x)
arctg(x)
sh(x)
ch(x)
th(x)
x
ex
ln(x)
lg(x)
[x]
trunc(x)
|x|
|x|
|x|
arctg(y/x)
xy
|z|
P(x)
Prototip
abort (void);
exit (int cod_retur);
07.05.15
Semnifica ie
termin un program la eroare
termin un program returnnd un cod de retur
41
C+
int
PO
struct time
int da_year;
int da_day;
int da_mon;
Semnifica ie
Citete Data curent :
Modific Data curent :
Citete Ora Exact :
Modific Ora Exact :
void
void
void
void
unsigned
unsigned
unsigned
unsigned
char
char
char
char
ti_min;
ti_hour;
ti_hund;
ti_sec;
Prototip
getdate (struct date *Data);
setdate (const struct date *Data);
gettime (struct time *OraExact);
settime (const struct time *OraExact);
Exemplu:
#include <stdio.h>;
// Timp : Data, Ora \\
#include <dos.h>;
void main (void)
{ struct date DataC;
getdate(&DataC);
struct time OraEx;
gettime(&OraEx);
printf(" Data : %2d %2d %4d \n", DataC.da_day,DataC.da_mon,DataC.da_year);
printf(" Ora : %2d:%2d:%2d \n", OraEx.ti_hour,OraEx.ti_min,OraEx.ti_sec);
}
1.
2.
Prototip
void clrscr (double x );
void delay (unsigned ms );
07.05.15
Semnificaie
Clear Screen
Wait (ms)
3.
4.
5.
void
void
void
Wait (sec)
Sound (Fr)
NoSound
42
C+
PO
// col, lin
Poziia cursorului:
int wherex ( void ) ;
// col
// lin
Colori nchise
0
1
2
3
4
5
6
7
=
=
=
=
=
=
=
=
BLACK
BLUE
GREEN
CYAN
RED
MAGENTA
BROWN
LIGHTGRAY
Colori deschise
8
9
10
11
12
13
14
15
=
=
=
=
=
=
=
=
DARKGRAY
LIGHTBLUE
LIGHTGREEN
LIGHTCYAN
LIGHTRED
LIGHTMAGENTA
YELLOW
WHITE
// cul f {0,...,7}
// cul s {0,...,15}
07.05.15
43
C+
PO
Funcii
getmaxx (); getmaxy ();
getx (); gety ();
moveto (x,y); moverel (dx,dy);
lineto (x,y); linerel (dx,dy);
line (x1,y1, x2,y2);
rectangle (x1,y1, x2,y2);
circle (x,y,r);
outtext[xy] ([x,y,] mesaj);
setactivepage (pag); setvisualpage (pag);
Exemple:
#include <graphics.h>
#include "graf.h"
07.05.15
// z=f(x,y)
// Dom (x,y)
// DefPr (r,a)
44
C+
PO
Window(a,d,b,c);
setbkcolor(BLUE);
for (i=0; i<=m; i++) {
x=x1+(x2-x1)*i/m; y=y1;
Muta(PrX(x,z(x,y)),PrY(y,z(x,y)));
for (j=1; j<=n; j++) {
y=y1+(y2-y1)*j/n;
Trag(PrX(x,z(x,y)),PrY(y,z(x,y)));
} }
setcolor(YELLOW);
for (j=0; j<=n; j++) {
y=y1+(y2-y1)*j/n; x=x1;
Muta(PrX(x,z(x,y)),PrY(y,z(x,y)));
for (i=1; i<=m; i++) {
x=x1+(x2-x1)*i/n;
Trag(PrX(x,z(x,y)),PrY(y,z(x,y)));
} }
getch(); closegraph();
}
#include <graphics.h>
// Graficul unei curbe \\
#include <conio.h>
#include <math.h>
#include "graf.h"
float x (float t)
{ return cos(t); }
float y (float t)
{ return sin(t); }
float z (float t)
{ return t / 10; }
void main(void)
{ float t, px,py; float t1=-50; float t2=50; float p=0.1; float Raza=0.5; float Alfa=1;
InitGraf (); setgraphmode(1); ViewPort (20,20,getmaxx()-20,getmaxy()-20);
DefPr(Raza,Alfa);
// Pr.||(Raza,Alfa)
t=t1; a=PrX(x(t),z(t)); b=a; c=PrY(y(t),z(t)); d=c;
for (t=t1+p; t<=t2; t+=p*2) {
px=PrX(x(t),z(t)); py=PrY(y(t),z(t));
if (px<a) a=px; else if (px>b) b=px;
if (py<c) c=py; else if (py>d) d=py;
};
Window(a,d,b,c); int Pag=0; setbkcolor(BLUE);
enum { Rosu, Verde } Sem = Verde;
do { clearviewport(); outtextxy(10,10,"Q OP"); outtextxy(10,20,"A");
t=t1; Muta(PrX(x(t),z(t)),PrY(y(t),z(t)));
for (t=t1+p; t<=t2; t+=p)
{Trag(PrX(x(t),z(t)),PrY(y(t),z(t)));}
setvisualpage(Pag); Pag=1-Pag; setactivepage(Pag);
char Rasp=getch();
switch (Rasp&0x5F) {
case 'A' : Raza-=0.01; break;
case 'Q' : Raza+=0.01; break;
case 'P' : Alfa-=0.01; break;
case 'O' : Alfa+=0.01; break;
default : closegraph(); Sem=Rosu; }
DefPr(Raza,Alfa);
} while (Sem==Verde);
}
// Graf.h \\
#include <graphics.h>
#include <math.h>
int u1,v1, u2,v2;
07.05.15
// ViewPort
45
C+
PO
float a, b, c, d ;
float Raza, Alfa;
int u (float x) { return ((x-a)/(b-a)*(u2-u1)+u1); }
int v (float y) { return ((y-d)/(c-d)*(v2-v1)+v1); }
void InitGraf(void)
{ int Gd = DETECT, Gm; initgraph(&Gd, &Gm, "c:\\Bc\\Bgi"); }
void ViewPort(int x1,int y1,int x2,int y2)
{ u1=x1; v1=y1; u2=x2; v2=y2;
/* rectangle(u1,v1,u2,v2);*/ }
void Window(float x1,float y1,float x2,float y2)
{ a=x1; d=y1; b=x2; c=y2; }
// Window
// Pr (r,)
07.05.15
46
C+
PO
// Comentariu
Dac n limbajul C declaraiile erau scrise nainte de instruciuni, n C++ ele pot fi
scrise oriunde.
Dispozitivelor standard de intrare-ieire li s-au ataat streamurile standard cin
(pentru stdin) i respectiv cout (pentru stdout), care permit efectuarea operaiilor de intrareieire aplicnd operatorul >> streamului cin, respectiv << streamului cout. Ierarhiile
necesare sunt n fiierul iostream.h .
Exemplu:
#include <stdio.h>;
#include <iostream.h>;
void main (void)
{ int i;
cout
cout
double x;
cout
cout
char s[10]; cout
cout
#include <conio.h>;
// endl=<Cr>
getch();
Dac n C conversia explicit se poate efectua prin (tip) expresie, n C++ se poate
realiza i prin tip (expresie).
Exemplu:
#include <stdio.h>;
#include <iostream.h>;
#include <conio.h>;
07.05.15
char
c;
cout << " Dati c : "; cin >> c;
cout << " Car. c = " << c << endl;
cout << " Val. c = " << (int) c << endl;
cout << " Val. c = " << int (c) << endl;
void *p;
p=&c;
cout << " Val. c = " << *(int *) p << endl;
typedef int * Pint;
cout << " Val. c = " << * Pint (p)<< endl;
getch();
// Coninutul adresei
// la care se afl un ntreg
47
C+
PO
14.2. Operatori
14.2.1.
Acest operator (::) se utilizeaz cnd dorim s referim o variabil global redefinit
ntr-o funcie, astfel:
:: Variabil
Exemplu:
#include <conio.h>;
#include <iostream.h>;
unsigned x;
char
y[10];
int
i=99;
void main (void)
{
unsigned x;
int
y;
cout << " Dati doua numere :
cout << " Cele doua numere =
cout << " Cele doua numere =
cout << " Cele doua numere =
clrscr();
// Variabile Locale
"; cin >> ::x >> x;
" << ::x << ' ' << x << endl;
" << ++::x << ' ' << --x << endl;
" << ::x << ' ' << x << endl;
y << endl;
for (int i=11; i<::i; ::i-=11) cout << i <<"::"<< ::i << endl;
getche();
}
14.2.2.
Acest operator (&) se poate utiliza i pentru a defini un tip referin printrdeclaraie de forma tip & (asemntor cu o construcie de forma tip *, pentru pointer).
Cu ajutorul acestui operator putem redenumi o variabil, putem realiza un apel prin referin
sau putem s declarm o variabil de referin astfel:
tip & parametru_formal
tip & nume_var_ref ;
07.05.15
48
C+
PO
Exemple:
#include <conio.h>;
#include <iostream.h>;
getch();
}
#include <conio.h>;
#include <iostream.h>;
#include <math.h>;
typedef double Functie (double);
void main (void)
{ Functie & Sin=sin;
double x;
cout << " Dati x : "; cin >> x;
cout << "Sin(" << x << ")=" << Sin(x) << endl;
getch();
}
#include <conio.h>;
#include <iostream.h>;
14.2.3.
Operatorul de alocare New se poate folosi n oricare dintre urmtoarele trei variante:
new tip
new tip ( Valoare_de_intiializare_a_variabilei_dinamice )
new tip [ Numrul_de_variabile_dinamice_alocate ]
Dealocarea se realizeaz astfel:
delete Variabil_de_referin ;
sau
delete [ Numrul_de_var_dinamice_alocate ] Variabil_de_referin ;
Exemplu:
#include <stdio.h>;
07.05.15
#include <conio.h>;
#include <iostream.h>;
49
C+
PO
{
getch();
#include "Crt.Cpp"
ClrScr();
// Aij
: ";
' ';
// Bij
Readln();
// R e z u l t a t e :
1
2
3
4
1
2
3
4
1
2
3
4
07.05.15
:
:
:
:
:
:
:
:
:
:
:
:
11
21
31
41
11
21
31
41
11
21
31
41
22
32 33
42 43 44
22
32
42
12
22
32
42
33
43
13
23
33
43
44
14
24
34
44
50
C+
PO
#include <conio.h>;
#include <iostream.h>;
enum
Figura { punct, cerc };
struct Punct { Real x, y; };
struct Cerc { Punct Centru;
Real Raza; };
struct Obiect { Figura FIG;
union { Punct PUNCT;
Cerc CERC;
};
};
Obiect Translatat ( Obiect o, Punct T )
{
o.PUNCT.x = o.PUNCT.x + T.x;
o.PUNCT.y = o.PUNCT.y + T.y;
return o;
}
void main (void)
{ Punct P = { 3,7 };
Obiect O = { punct, { 1,2 } };
Obiect C; C.FIG=cerc; C.CERC.Centru=O.PUNCT; C.CERC.Raza=10;
Obiect D; D=Translatat(C,P);
cout << " D(" << D.CERC.Centru.x << ","
<< D.CERC.Centru.y << ","
<< D.CERC.Raza
<< ")" << endl;
getch();
}
07.05.15
51
C+
PO
#include <iostream.h>
#include "crt.h"
#include <iostream.h>
#include "crt.h"
07.05.15
52
C+
PO
#include <iostream.h>;
#define Abs_G(x)
(x)> 0 ? (x) : -(x)
// Gresit !
#define Abs_g(x) ( x > 0 ? x : - x )
// gresit !
#define Abs_c(x) ( (x)> 0 ? (x) : -(x) )
// Macro corect
inline long Abs (long x)
// Functie Inline
{
return x > 0 ? x : - x ;
}
void main (void)
{
long x;
cout << " x : " ; cin >> x;
long y=-x;
cout << " |x| = " << Abs_G(x);
cout << endl;
cout << " |x| = " << Abs_g(x) << endl;
cout << " |x| = " << Abs_c(x) << endl;
cout << " |x| = " << Abs (x) << endl;
cout << " |10-y| = " << Abs_G(10-x);
cout << endl;
cout << " |10-y| = " << Abs_g(10-x) << endl;
cout << " |10-y| = " << Abs_c(10-x) << endl;
cout << " |10-y| = " << Abs (10-x) << endl;
getch();
}
Ex. 2:
#include <iostream.h>;
#define
max(
x,
y) (x>y ? x : y)
// Gresit !
inline int Max(int x, int y)
// F.Inline
{
return (x>y ? x : y); }
void main (void)
{ int x,y,z;
x=5; y=2; z=max(++x,++y); cout <<" max("<<x<<','<<y<<")="<<z<< endl;
x=5; y=2; z=Max(++x,++y); cout <<" Max("<<x<<','<<y<<")="<<z<< endl;
}
// Rezultatele
max(7,3)=7
Max(6,3)=6
07.05.15
53
C+
PO
#include <stdlib.h>;
#include <conio.h>;
#include <iostream.h>;
// Inc(Albe/Negre)
(void)
ClrScr();
<<
<<
<<
<<
<<
"
"
"
"
"
P
Q
M
P
Q
:
:
=
=
=
";
";
";
";
";
07.05.15
54
C+
PO
// Ex. Referin \\
#include <iostream.h>;
#include "Crt.Cpp"
void suma (int x,int y,int *z)
{ *z = ++x * ++y;
}
void Suma (int x,int y,int &z)
{ z = ++x * ++y;
}
int* max (int& x, int& y)
{ return ( x > y ? &x : &y ); }
int& Max (int& x, int& y)
{ return ( x > y ? x : y ); }
struct Punct { int x,y; };
Punct Atrib (int x, int y)
{
Punct P; P.x=x; P.y=y;
return P; }
Punct sim (Punct P)
{
P.x=-P.x; P.y=-P.y; return P; }
Punct& Sim (Punct& P)
{
P.x=-P.x; P.y=-P.y; return P; }
Punct* Psim(Punct P)
{
P.x=-P.x; P.y=-P.y; return &P; }
void
Tip (Punct P)
{
cout << " P(" << P.x << ',' << P.y << ')' << endl; }
void main (void)
{ int x,y,z;
ClrScr();
cout << " Dati x,y
: ";
cin >> x >> y;
suma(x,y,&z);
cout << " (x+1)*(y+1) = " << z << endl;
Suma(x,y, z);
cout << " (x+1)*(y+1) = " << z << endl;
cout << "
x,y = " << x << ' ' << y << endl;
cout << " max(x,y)+1 = " << ++ *max(x,y) << endl;
cout << "
x,y = " << x << ' ' << y << endl;
cout << " Max(x,y)+1 = " << ++ Max(x,y) << endl;
cout << "
x,y = " << x << ' ' << y << endl;
Punct P=Atrib(x,y);
Tip(P);
Tip(sim(P));
Tip(P);
Tip(Sim(P));
Tip(P);
cout <<"P(x,y)=("<< sim(P) .x <<','<< Sim(P) . y <<')'<< endl;
cout <<"P(x,y)=("<<(*Psim(P)).x <<','<< Psim(P)->y <<')'<< endl;
}
// R e z u l t a t e :
Readln();
Dati x,y
: 1 5
(x+1)*(y+1) = 12
(x+1)*(y+1) = 12
x,y = 1 5
max(x,y)+1 = 6
x,y = 1 6
Max(x,y)+1 = 7
x,y = 1 7
P(1,7)
P(-1,-7)
P(1,7)
P(-1,-7)
P(-1,-7)
P(x,y)=(1,7)
P(x,y)=(-1,-7)
07.05.15
55
C+
PO
#include <complex.h>;
#include <conio.h>;
#include <iostream.h>;
#include "graf.h"
#include <conio.h>
//
\\
struct Punct
{ float x,y; };
struct Triunghi { Punct A,B,C; };
Punct
Init (float x, float y);
Triunghi Init (Punct A, Punct B, Punct C);
void Translat (Punct&
P, Punct Q);
void Translat (Triunghi& T, Punct Q);
void Rot
(Punct&
P, float Alfa, Punct Q);
void Rot
(Triunghi& T, float Alfa, Punct Q);
Punct
Init (float x, float y)
{ Punct
P = {x,y};
return P; }
Triunghi Init (Punct A, Punct B, Punct C){ Triunghi T; T.A=A; T.B=B; T.C=C; return T; }
void Translat (Punct&
P, Punct Q) { P.x+=Q.x; P.y+=Q.y; }
void Translat (Triunghi& T, Punct Q) {
Translat(T.A,Q);
Translat(T.B,Q);
Translat(T.C,Q); }
Rot(P.x,P.y,Q.x,Q.y,Alfa);
Rot(P.x,P.y,Q.x,Q.y,Alfa); }
Rot(T.A,Q,Alfa);
Rot(T.B,Q,Alfa);
Rot(T.C,Q,Alfa); }
void Muta(Punct P)
void Trag(Punct P)
void Des (Punct
P)
void Des (Triunghi T)
void main(void)
{
{
{
{
Muta(P.x,P.y); }
Trag(P.x,P.y); }
circle(u(P.x),v(P.y),3);}
Muta(T.A); Trag(T.B); Trag(T.C); Trag(T.A);}
Punct
P
= Init(10,10);
Triunghi ABC = Init(Init(5,5),Init(20,7),Init(8,12));
InitGraf(); ViewPort (20,10,getmaxx()-20,getmaxy()-10);
setbkcolor(BLUE); setwritemode(XOR_PUT);
Window
(-10,20,30,-10);
Linie
(-10, 0,20, 0);
Linie
( 0,20, 0,-10);
char Esc=0x1b; float Alfa; char
Rasp='o';
Des(P);
do {
Des(ABC);
if (Rasp=='o') Alfa=0.1; else Alfa=0.1;
Rot(ABC,P,Alfa);
}
while ((Rasp=getche())!=Esc);
closegraph();
}
07.05.15
56
C+
PO
struct
int
int
Obiect
{
Obiect
{ float x,y; float r; };
ELipsa ()
{ return -1; }
Este_Punct (Obiect o) { return o.r==ELipsa(); }
Init( float x0=0, float y0=0, float raza=ELipsa() )
Obiect o;
o.x=x0; o.y=y0; o.r=raza;
return o;
}
Tip ( Obiect o )
{ if (Este_Punct(o)) cout << " Punct ( "; else cout << " Cerc ( ";
cout << o.x << "," << o.y;
if (Este_Punct(o)) ; else cout << "," << o.r;
cout << " ) " << endl;
}
main ()
{
Obiect O=Init();
Tip(O);
// Originea (0,0)
Obiect A=Init(7);
Tip(A);
// A Ox (7,0)
Obiect P=Init(1,2);
Tip(P);
// P R2
(1,2)
Obiect C=Init(3,4,5); Tip(C);
// Cerc
(3,4, 5)
getch();
}
n exemplul care urmeaz se poate vedea cum se pot folosi parametrii implicii
pentru a declara punctul O(0,0), un punct A pe axa Ox, un punct P n plan (R2), un cerc C
(n plan), extremitile unui segment din spaiu (Q,RR 3), precum i segmentele QR i RO:
#include <stdio.h>;
#include <conio.h>;
#include <iostream.h>;
struct Punct
{ float x,y,z; };
Punct Init( float x0=0, float y0=0, float z0=0 )
{
Punct P;
P.x=x0;
P.y=y0;
P.z=z0;
return P;
}
void
Tip ( Punct P )
{
cout << " P(" << P.x <<','<< P.y <<','<< P.z <<')'<< endl;
}
07.05.15
57
C+
PO
// Originea
// A e Ox
// P e R2
// Cerc
// Q e R3
// R e R3
// QR e R3
#include <iostream.h>
#include "crt.h"
07.05.15
58
C+
PO
#include <iostream.h>
#include "crt.h"
1 6 . T i p Ab s t r a c t d e D a t
Programarea modular permite protejarea datelor prin memorie static, (accesul la
date se poate efectua doar din locul declarrii pn la sfritul modulului, nu i n afara lui).
Un tip abstract de dat (Domeniu, Operaii) conine o interfa (Tad.h) i o
implementare (Tad.Cpp). Programul (Program.Cpp) care utilizeaz acest tip abstract
de dat va avea acces doar la modulul de interfa, aa cum se poate vedea n schema de
mai jos:
Program.Cpp
Compilare
Link-editare
Tad.h
Tad.Cpp
Program.Obj
Compilare
Program.Exe
Program.Obj
07.05.15
59
C+
PO
clrscr();
// Nu se p.!
//
Se p.!
getche();
}
// Mult.h \\
#include "ElMult.h"
struct Cet;
typedef Cet *Multime;
void Init
(Multime &A);
int Card
(Multime A);
int E_Vida (Multime A);
void Vida
(Multime A);
void AdEl
(TEl x, Multime A);
void CitM
(Multime A);
void TipM
(Multime A);
int Apart (TEl x, Multime A);
void Inters (Multime A, Multime B, Multime C);
void Dif
(Multime A, Multime B, Multime C);
void Reun
(Multime A, Multime B, Multime C);
int Inclus (Multime A, Multime B);
int Egale (Multime A, Multime B);
Multime DifEl (Multime A, TEl a);
Multime Difer (Multime A, Multime B);
// PMult.Cpp \\
#include <iostream.h>
#include <conio.h>
#include "ElMult.h"
#include "Mult.h"
typedef struct Cet
07.05.15
int card;
TEl Elem[Cm];
};
60
C+
PO
07.05.15
61
C+
PO
else
// ElMult.h \\
#define Cm 255
typedef int TEl;
Un tip abstract de dat realizeaz o unificare (printr-o grupare de tip struct) ntre
date (date membru) i operaiile (funcii membru) lor caracteristice. Funciile membru sunt
considerate de tip inline iar definirea lor n afara structurii se face prin operatorul de
rezoluie (::). n acest mod ns nu se realizeaz o protecie a datelor (accesul la date se
poate face i prin alte funcii, nu numai prin cele membru), aceast protecie putnd fi
realizat (aa cum vom vedea n cele ce urmeaz) cu ajutorul claselor.
Exemplu:
#include <stdio.h>;
#define Pi 3.141592
struct
#include <conio.h>;
#include <iostream.h>;
{ float x,y;
float r;
void Init (float x0, float y0, float raza)
{
x=x0;
y=y0;
r=raza;}
float Lung ();
float Aria ();
};
float Cerc::Lung ()
{ return 2*Pi*r; }
float Cerc::Aria ()
{ return Pi*r*r; }
void main (void)
{ Cerc C;
C.Init(1,2,3);
cout << "C(" << C.x << "," << C.y << "," << C.r << ")" << endl;
cout << "Aria = " << C.Aria() << endl;
cout << "Lung = " << C.Lung() << endl;
getch();
}
07.05.15
Cerc
62
C+
PO
metoda
ncapsularea
motenirea
polimorfism
07.05.15
63
C+
PO
{ [ Modificator_de_protecie: ] List_membrii }
};
unde:
Modificator_de_protecie { private, protected, public}
private nu permite accesul din afara clasei,
protected permite accesul din clasele derivate,
public permite accesul din afara clasei;
#
+
Datele de tip private () pot fi accesate doar de funciile membru sau funcii
prietene (friend). O funcie membru a unei clase poate fi funcie prieten a altei clase, iar
dac toate sunt prietene, atunci se poate declara clas prieten (friend).
//
Vezi C8
Fiecare obiect al unei clase deine un set de date membru (variabile de instan).
Funciile membru publice pot fi utilizate din orice funcie din program, pe cnd cele
private doar din funciile membru ale clasei.
Definirea funciilor membru (metodelor) se poate realiza:
a) imediat (complet, antet plus corp) n definiia clasei (ca funcie inline) dac funcia nu
conine multe instruciuni i nu conine structuri repetitive (apelul nu se face prin salt cu
revenire), astfel:
class Nume_clas
b)
{
Tip_funcie Nume_metod ( ... ) { . . . };
};
// antet+corp
ulterior (dac a fost declarat n definiia clasei doar prototipul funciei), utiliznd
operatorul de rezoluie (de scop) astfel:
Tip_funcie Nume_clas :: Nume_metod ( ... )
rezoluie
{
07.05.15
. . .
};
// :: operatorul de
// corpul funciei
64
C+
PO
Exemplu:
//
//
Clasa
Punct
-----------------------------
\\
\\
# include <conio.h>
# include <iostream.h>
//
( )
(float x0, float y0)
(Punct& P)
(char* Mes);
(char* Mes);
( );
void
Punct::CitP (char* Mes)
void
Punct::TipP (char* Mes)
Punct& Punct::SimPb( )
void
{
private:
(x,y) e
{ x=0;
y=0;
}
{ x=x0; y=y0; }
{ x=P.x; y=P.y; }
main (void)
. . .
Un obiect este o instan a unei clase (o variabil de tipul clasei). Fiecare obiect
aparine unei singure clase (aceasta putnd avea mai multe obiecte).
Obiectele unei clase se declar astfel:
Clas
List_Obiecte;
Exemplu:
//
//
Obiecte
Punct
\\
----------------------------\\
# include <conio.h>
# include <iostream.h>
class Punct {
. . .
};
. . .
void
{
);
main (void)
clrscr(
Punct O,A(1,2);
O.TipP(" O = ");
A.TipP(" A = ");
Punct B1; B1.CitP(" B1: ");
Punct B2 (B1.SimPb());
B2.TipP(" B2= ");
getche(
);
}
07.05.15
65
C+
PO
include
include
include
include
include
define
Constructori - Destructori \\
---------------------------- \\
<dos.h>
<math.h>
<conio.h>
<graphics.h>
<iostream.h>
Cale "c:\\BorlandC\\Bgi"
// private: (x,y) e R2
( )
(float x0, float y0)
(Punct& P)
(int, int, int);
();
{ x=0;
y=0;
}
{ x=x0; y=y0; }
{ x=P.x; y=P.y; }
int
X0
()
{ return int(x); }
int
Y0
()
{ return int(y); }
Punct& Transl(Punct&);
};
Punct:: Punct(int x0,int y0,int c) { x=x0; y=y0; setcolor(c); circle(x,y,5);}
Punct::~Punct( )
{
setcolor(BLACK);
circle(x,y,5);}
Punct& Punct::Transl(Punct& T) { x+=T.x; y+=T.y; return *this; }
void
main (void)
{
Grafic Mod(DETECT);
Punct C(getmaxx()/2,getmaxy()/2,WHITE);
getche();
for (float Alfa=-1.57;Alfa<4.71;Alfa+=0.01)
{ float Raza=100;
Punct M(Raza*cos(Alfa),Raza*sin(Alfa));
Punct P=M.Transl(C);
Punct D(P.X0(),P.Y0(),YELLOW); delay(5);
}
getche();
}
07.05.15
// Centru
66
C+
PO
Componentele claselor (datele i funciile membru) se refer prin operatorul
sau
>, ca i n cazul unei structuri. Funciile membru refer direct componentele clasei (fr
aceti operatori, utiliznd poinetrul this declarat automat ca pointer la obiectul curent).
Exemplu:
//
//
#
#
#
#
#
#
include
include
include
include
include
define
Operatorii i >
\\
---------------------------- \\
<dos.h>
<math.h>
<conio.h>
<graphics.h>
<iostream.h>
Cale "c:\\BorlandC\\Bgi"
getche();
//
M C
M=M>Init(Raza*cos(Alfa),Raza*sin(Alfa)) >Transl(C);
Punct *P=new Punct(M>X0(),M>Y0(),YELLOW); delay(3); // Desen. P
delete P;
} // Sterge P
delete M;
getche();
delete C;
getche();
}
07.05.15
67
C+
PO
Exemplu:
// Constructori String \\
# include <Conio.h>
# include <String.h>
# include <Iostream.h>
07.05.15
68
C+
PO
Antetul unui constructor al unei clase ce conine ca date membru obiecte alte altor
clase este de forma:
Clas (List_par_formali) : Obiect1(List_par_formali1),...,Obiectn(List_par_formalin)
Exemplu:
#include <stdio.h>; #include <conio.h>; #include <iostream.h>;
class
P3D { float x,y,z;
public:
P3D () {x=0;y=0;z=0;}
P3D (float x0, float y0, float z0) {x=x0;y=y0;z=z0;}
void Tip(){ cout <<"P("<<x<<","<<y<<","<<z<<")"<<endl; }
};
class
Cerc { P3D x_y_r;
public:
Cerc () { };
getch();
// Rezultatele afiate:
Alocare ...
C(1,2,3)
Dealocare...
07.05.15
69
C+
PO
class
Natural {
public:
char* Numar;
Natural (char* Nr);
~Natural ();
};
Natural::Natural(char* Nr)
{ Numar = new char[strlen(Nr)+1];
strcpy(Numar,Nr);
cout << " Constr.Ob. ..." << Numar << endl;
}
Natural::~Natural()
{ cout << " ... Distr.Ob. " << Numar << endl;
delete Numar;
}
void f(Natural x)
{ cout << " ... f(x) ... " << endl; }
Natural x("123");
void main (void)
{
cout << "*Start*" << endl;
Natural y("456"); f("789");
cout << "*Stop*" << endl;
}
// Rezultatele afiate:
Constr.Ob. ...123
*Start*
Constr.Ob. ...456
Constr.Ob. ...789
... f(x) ...
... Distr.Ob. 789
*Stop*
... Distr.Ob. 456
... Distr.Ob. 123
07.05.15
70
C+
PO
Punct- x : float
- y : float+ Punct ( )
+ Punct (Punct&)
+~Punct ( )
relaia de asociere :
// prietenie
relaia de derivare :
// motenire
Punct- x : float
- y : float+ Punct ( )
+ Punct (Punct&)
+~Punct ( )
Segment- A : Punct
- B : Punct+ Segment ( )
+ Segment (Segment&)
Student- Facultate:
String
- Varst : int+ Student ( )
+ Student (Student &)
+~Student ( )
+~Segment ( )
07.05.15
71
C+
PO
19. F u n c i i i C l a s e P r i e t e n e ( F r i e n d )
O funcie este prieten cu o clas dac are acces la datele membru private ale
acelei clase. O funcie prieten poate fi o funcie global sau chiar o funcie membru a
altei clase.
O clas este prieten cu o alt clas dac ea are acces la datele membru ale
acesteia.
O funcie, respectiv o clas prieten se declar utiliznd cuvntul friend astfel:
friend Tip_funcie Nume_funcie ( List_parametri_formali ); // Funcie friend global
b) friend Tip_funcie Nume_clas::Nume_funcie(List_par._formali); // Funcie friend membru
c) friend
Nume_clas;
// Clas friend
a)
#include <iostream.h>
class Punct {
float x,y;
public:
};
class Cerc
public:
// private:
Punct (
) { x= 0, y= 0; }
Punct (float x0, float y0) { x=x0, y=y0; }
Punct C;
float r;
};
void main ()
{
Punct C(10,10);
Cerc c(C,4);
if (c.TaieOx()) cout << " Cercul c intersecteaza axa Ox ";
else
cout << " Cercul c nu intersecteaza axa Ox ";
// secret world
/ / F u n c i e f r i e n d me m b r u
#include <iostream.h>
class Punct;
class Cerc {
public:
};
class Punct {
float x,y;
public:
};
Punct* C; float r;
Cerc (Punct O, float raza) { *C=O; r=raza;}
int TaieOx();
Punct (
) { x= 0, y= 0; }
Punct (float x0, float y0) { x=x0, y=y0; }
07.05.15
72
C+
PO
Exemple:
//
#
#
#
#
#
include
include
include
include
define
\\
<dos.h>
<conio.h>
<graphics.h>
<iostream.h>
Cale "c:\\BorlandC\\Bgi"
07.05.15
73
C+
#
#
#
#
#
#
PO
include
include
include
include
include
define
//
<dos.h>
<math.h>
<conio.h>
<graphics.h>
<iostream.h>
Cale "c:\\BorlandC\\Bgi"
\\
{ return float(x)*x; }
{ return ceil (sqrt(x)+0.5); }
Gm;
Grafic(int gd) { Gd=gd; initgraph(&Gd,&Gm,Cale);
setbkcolor(BLUE); }
~Grafic( )
{ getche();
closegraph(); }
};
class Punct;
class Segment{Punct *A, *B;
public:
Segment
Segment
Segment
~Segment
Punct Mijloc
};
class Punct { int
x, y;
public: Punct
Punct
Muta
Trag
~Punct
friend Punct
void
void
// Capetele Segm.
( ) : A(), B() { }
(Punct*,Punct*);
(Segment&);
();
();
(int x0=0,int y0=0) { x=x0; y=y0;
putpixel(x,y,x+y);}
(Punct& P)
{ x=P.x; y=P.y; }
()
{ moveto(x,y); }
()
{ lineto(x,y); }
()
{
}
Segment::Mijloc();
};
Segment:: Segment (Punct *P, Punct *Q) { A=P; B=Q; A->Muta(); B->Trag(); }
Segment:: Segment (Segment& AB)
{ A=AB.A;
B=AB.B;
}
Segment::~Segment ( )
{ A->Muta(); B->Trag(); }
Punct Segment::Mijloc() { Punct M ( int((A->x+B->x)/2),
int((A->y+B->y)/2));
return M; }
void main (void)
{
Grafic Mod(DETECT); setwritemode(XOR_PUT); int Lung=400;
Punct* O = new Punct;
// Originea
Punct* X = new Punct(Lung);
Punct* Y = new Punct(0,Lung);
Segment* OX = new Segment(O,X);
// Axa Ox;
Segment* OY = new Segment(O,Y);
// Axa Ox;
for (int x=1; x<Lung; x++)
{ Punct* P = new Punct (x);
Punct* Q = new Punct (0,Sqrt(Sqr(Lung)-Sqr(x)));
Segment* PQ = new Segment(P,Q);
PQ->Mijloc();
delay(9);
delete PQ; delete P; delete Q;
}
getche();
delete OX; delete OY; delete O; delete X; delete Y;
}
07.05.15
74
C+
PO
Clasa friend
//
# include <conio.h>
\\
# include <iostream.h>
~Grafic( )
};
# include <graphics.h>
{ getche();
closegraph(); }
x, y;
friend Segment;
friend Cerc;
friend Triunghi;
};
class Segment{Punct A, B; int Cul;
y0,int
c)
// Capetele Segm.
friend Triunghi;
};
Punct Segment::Mijloc () { Punct M(int((A.x+B.x)/2),int((A.y+B.y)/2)); return M;}
class Cerc { int
x, y, r;
public:
};
class Triunghi { Punct A, B, C;
// Varfuri
public:
Triunghi ( ) : A(), B(), C() { }
Triunghi (Punct,Punct,Punct);
Triunghi (Triunghi& ABC) { A=ABC.A; B=ABC.B; C=ABC.C;}
};
Triunghi::Triunghi(Punct P,Punct Q,Punct R)
setcolor(YELLOW); Segment AB(A,B);
setcolor(LIGHTBLUE);
Segment
Segment BBP(B,CA.Mijloc());Segment
void
{
07.05.15
int Cf=int((Pi-fabs(Alfa-Pi))/Pi*63); //
setrgbpalette(pal.colors[BLUE],
setrgbpalette(pal.colors[YELLOW],
setrgbpalette(pal.colors[LIGHTBLUE],
setrgbpalette(pal.colors[WHITE],
delay(int(pow((fabs(Alfa-Pi)+0.3)*Pi,2)));
main (void)
r
0,
63
0,
Cf,
}
g
b
0,
Cf);
,63-Cf,0);
Cf, 63);
Cf, Cf);
75
C+
PO
20. M e m b r i s t a t i c i ( S t a t i c )
// $ :
Fiecare obiect dintr-o clas deine toate datele membru (atributele) acesteia. Exist
ns posibilitatea ca toate instanele unei clase s dein anumite atribute comune tuturor
obiectelor clasei respective. Aceti membri (date, funcii) statici au acelai regim de
protecie ca i ceilali membrii.
// $ :
Datele membru statice, care urmeaz s fie utilizate de ctre toate obiectele clasei,
se definesc prin specificatorul static astfel:
class Nume_clas
static
List_Declaraii_date_membru ;
// $ :
};
Datele membru statice, se declar (se iniializeaz) explicit n afara clasei:
Tip_dat_membru Nume_clas ::Dat_membru [ = Valaore ];
Referirea (utilizarea) datelor membru statice se poate face astfel:
Nume_clas ::Dat_membru // Referire natural (global) la clas
b) Obiect Dat_membru
// Referire particular la un obiect
c) Pointer_Obiect >Dat_membru // Referire particular prin pointer
a)
class Punct {
float
x, y;
public:
Punct ()
Punct (float x,float y)
Punct (Punct& P)
~Punct ()
static
};
int Punct::Nr_Ob=0;
07.05.15
int
Nr_Ob;
}
}
}
}
// $:
// se iniializeaz
76
C+
PO
clrscr();
// Cl::Static.
// Ob .Static!
// Ob->Static!
getche();
n exemplul urmtor, sunt utilizai membri statici a,b,c,d pentru a memora domeniul
minim care conine toate punctele curbei (definite parametric) care se deseneaz:
// Membri Statici
Punct
Muta
Trag
~Punct
(x<a)
(x>b)
(y<c)
(y>d)
a=x; else
b=x;
c=y; else
d=y; }
{ return cos(2*t)*cos(t); }
{ return cos(4*t)*sin(t); }
// x(t)
// y(t)
07.05.15
77
C+
PO
// $ :
};
Referirea (utilizarea) metodelor statice se face astfel:
a) Nume_clas :: Funcie_membru (List_par_actuali)
// Referire natural la clas
b) Obiect Funcie_membru (List_par_actuali)
// Referire la un obiect
c) Pointer_Obiect > Funcie_membru (List_par_actuali)
// Referire prin pointer
n urmtorul exemplu, se determin fereastra real (definit prin cele dou puncte
diagonal opuse St_Sus, Dr_Jos) utiliznd funciile statice MinX, MaxX, MinY, MaxY pentru a
determina domeniul minimal care include punctele din grafic.
// Funcii Statice
void
void
void
static
static
static
static
static
# include <graphics.h>
Punct
float
float
float
float
{ x=P.x; y=P.y;
}
{ moveto(u(x),v(y)); }
{ lineto(u(x),v(y)); }
St_Sus, Dr_Jos;
MinX() { return
MaxX() { return
MinY() { return
MaxY() { return
};
Punct Punct::St_Sus, Punct::Dr_Jos;
int u1=110, v1=20,
u2=500, v2=430;
float x (float t)
float y (float t)
St_Sus.x;
Dr_Jos.x;
Dr_Jos.y;
St_Sus.y;
}
}
}
}
//
//
//
//
Metod
Metod
Metod
Metod
// Fereastra Reala
Static
Static
Static
Static
// Fereastra Reala
// Fereastra Ecran
float Pi=3.14153;
P[0].Atrib(x(0),y(0));
Grafic Mod(DETECT);
Punct::St_Sus=Punct::Dr_Jos=P[0];
for (i=1; i<=n; i++) { float Alfa=2*Pi*i/n; P[i].Atrib(x(Alfa),y(Alfa));}
P[0].Muta(); setcolor(WHITE);
for (i=1; i<=n; i++) P[i].Trag();
07.05.15
78
C+
PO
// sau cu typedef
x, y;
public: Punct () { }
void
void
void
Atrib
Punct (Punct& P)
Muta ()
Trag ()
~Punct () { }
static Punct St_Sus, Dr_Jos;
static float MinX() { return St_Sus.x; }
{ moveto(u(x),v(y)); }
{ lineto(u(x),v(y)); }
// Metod Static
};
// Definire
// Iniializare
// sau:
//
void (Punct :: *Pm[2])() = {&Punct::Muta,&Punct::Trag};
(P[0].*Pm[0])(); setcolor(WHITE);
for (i=1; i<=n; i++) (P[i].*Pm[1])();
// Def+Ini
// Apel Muta
// Apel Trag
07.05.15
79
C+
PO
Un alt exemplu, care utilizeaz pointeri la metode (Triun, Drept i Romb) este
urmtorul:
// Pointeri la *Metode
# include <math.h>
# include <conio.h>
# include <graphics.h>
# define Cale "c:\\BorlandC\\Bgi"
class Grafic { int Gd, Gm;
public: Grafic(int gd) { Gd=gd; initgraph(&Gd,&Gm,Cale); setbkcolor(BLUE);}
~Grafic( )
{ getche();
closegraph();} };
int u (float);
int v (float);
void
void
Muta ()
Triun ()
void
Drept ()
void
Romb ()
~Punct
static Punct
static float
static float
static float
static float
() {
}
St_Sus, Dr_Jos;
MinX() { return
MaxX() { return
MinY() { return
MaxY() { return
{ moveto(u(x),v(y)); }
{ setcolor(WHITE);
Muta();
moverel(0,-3); linerel(-2,5);
linerel(4,0); linerel(-2,-5);}
{ setcolor(LIGHTRED); Muta();
moverel(-2,-2); linerel(0,4);
linerel(4,0); linerel(0,-4);linerel(-4,0);}
{ setcolor(YELLOW); Muta();
moverel(0,-3); linerel(-2,3);
linerel(2,3); linerel(2,-3);linerel(-2,-3);}
St_Sus.x;
Dr_Jos.x;
Dr_Jos.y;
St_Sus.y;
}
}
}
}
// Fereastra Reala
};
Punct Punct::St_Sus, Punct::Dr_Jos;
// Fereastra Reala
int u1=110, v1=20, u2=500, v2=430;
// Fereastra Ecran
int u (float x) { return ((x-Punct::MinX())/(Punct::MaxX()-Punct::MinX())*(u2-u1)+u1); }
int v (float y) { return ((y-Punct::MaxY())/(Punct::MinY()-Punct::MaxY())*(v2-v1)+v1); }
float x0 (float t)
{ return cos(4*t)*cos(t); }
// x(t)
float y0 (float t)
{ return cos(2*t)*sin(t); }
// y(t)
float x1 (float t)
{ return cos(2*t)*cos(t); }
// x(t)
float y1 (float t)
{ return cos(4*t)*sin(t); }
// y(t)
float x2 (float t)
{ return
cos(t); }
// x(t)
float y2 (float t)
{ return
sin(t); }
// y(t)
07.05.15
80
C+
PO
*,
asociativitatea.
Suprancrcarea se poate face cu:
a) funcii membru - numrul parametrilor fiind egal cu aritatea operatorului minus unu,
deoarece un operand este chiar obiectul curent pentru care se apeleaz metoda (acesta
putnd fi referit prin pointerul this),
b) funcii prietene - numrul parametrilor fiind egal cu aritatea operatorului.
Redefinirea unui operator se realizeaz printr-o funcie (prieten sau membru) al
crei nume este compus din cuvntul operator urmat de operatorul propriuzis (+, <, ) .
Exemplu:
# include <Conio.h>
# include <String.h>
//
friend
String operator+(String&);
String operator&(String&,String&);
~String ();
int Length ();
void Print ();
\\
# include <Iostream.h>
//
//
//
//
Constructor
Constructor
Constructor
Operator de
implicit
de copiere
de conversie
atribuire
// Operator + (concatenare)
// Operator & (concatenare)
a)
b)
// Destructor
// Lungimea sirului
// Tipareste sirul
};
String::String ()
{ s=new char; s[0]=0; }
String::String (const String& S) { s=new char[S.Length( )+1];strcpy(s,S.s);}
String::String (const char* S) { s=new char[ strlen(S)+1];strcpy(s,S); }
String& String::operator=(const String& S)
{
if (s!=S.s) {delete []s; s=new char[S.Length()+1]; strcpy(s,S.s);} return *this; }
String String::operator+(String& S)
// funcie membru a)
{
char* sS=new char[this->Length()+S.Length()+1];
strcpy(sS,s); strcpy(sS+this->Length(),S.s); String Rez(sS); delete sS; return Rez; }
String::~String () { delete []s;}
int String::Length () { return strlen(s); }
String operator&(String& s,String& S)
// funcie prieten b)
{
char* sS=new char[s.Length()+S.Length()+1];
strcpy(sS,s.s); strcpy(sS+s.Length(),S.s); String Rez(sS); delete sS; return Rez; }
void String::Print () { cout << s << endl; }
void main ()
{
String Nume("Popescu"), Prenume("Ionel");
String Nume_Prenume=Nume+" "+Prenume;
Nume_Prenume.Print();
String Prenume_Nume=Prenume&" "&Nume;
Prenume_Nume.Print();
}
07.05.15
clrscr();
getche();
81
C+
PO
//
# include <Conio.h>
# include <String.h>
# include <Iostream.h>
(Op.
= ) \\
// Constructor implicit
//
... de copiere
//
... de conversie
// Operator de atribuire
// Operator de adunare
// Operator de scadere
int
int
int
int
int
int
//
//
//
//
//
//
~Natural
int Length
void Input
void Print
};
07.05.15
operator< (const
operator<=(const
operator> (const
operator>=(const
operator==(const
operator!=(const
();
();
();
();
Natural&);
Natural&);
Natural&);
Natural&);
Natural&);
Natural&);
//
//
//
//
...
...
...
...
...
...
relational
...
...
...
...
...
<
<=
>
>=
==
<>
Destructor
Numarul de cifre
Citeste numar
Tipareste numar
82
C+
PO
void main ()
{
Natural a,b;
cout << " a : "; a.Input();
cout << " b : "; b.Input();
cout << " a+b = "; (a+b).Print(); ;
cout << "|a-b|= "; if (a>=b) (a-b).Print(); else
(b-a).Print();
clrscr();
getche();
07.05.15
83
C+
PO
# include <Conio.h>
# include <String.h>
(Op.
+=, -= ) \\
# include <Iostream.h>
( );
(const Natural&);
(unsigned long);
operator= (const Natural&);
operator+ (const Natural&);
operator- (const Natural&);
Natural& operator+=(Natural&);
Natural& operator-=(Natural&);
int
int
int
int
int
int
~Natural
int Length
void Print
};
operator< (const
operator<=(const
operator> (const
operator>=(const
operator==(const
operator!=(const
();
();
();
Natural&);
Natural&);
Natural&);
Natural&);
Natural&);
Natural&);
//
//
//
//
//
//
Constructor implicit
... de copiere
... de conversie
Operator de atribuire
Operator de adunare
Operator de scadere
// ... de ad.&.atr.
// ... de sc.&.atr.
//
... relational <
//
...
...
<=
//
...
...
>
//
...
...
>=
//
...
...
==
//
...
...
<>
// Destructor
// Numarul de cifre
// Tipareste numar
Natural::Natural ( ) { }
Natural::Natural (const Natural& S) { }
Natural::Natural (unsigned long S) { }
Natural& Natural::operator= (const Natural& S){ }
char* Suma (const char* a, const char *b) { }
char* Dif (const char* a, const char *b) { }
Natural Natural::operator+ (const Natural& S){ Natural Sum; Sum.s=Suma(s,S.s); return Sum;}
Natural Natural::operator- (const Natural& S){ Natural D; D.s=Dif(s,S.s); return D;}
S)
S)
S)
S)
S)
S)
{
{
{
{
{
{
}
}
}
}
}
}
void main ()
{ Natural a(125),b(175);
while (a!=b) if (a>b) a-=b; else b-=a;
if (a==1) cout << " Prime intre ele ";
else { cout << "Cmmdc="; a.Print(); }
}
07.05.15
clrscr();
getche();
84
C+
PO
# include <Conio.h>
# include <String.h>
Natural
Natural
Natural
Natural&
Natural
Natural
( );
(const Natural&);
(unsigned long);
operator= (const Natural&);
operator+ (const Natural&);
operator- (const Natural&);
Natural&
Natural
Natural&
Natural
operator
operator
operator
operator
++();
++(int);
--();
--(int);
int
operator < (const Natural&);
~Natural ();
int Length ();
//
//
//
//
//
//
Constructor
... de
... de
Operator de
Operator de
Operator de
implicit
copiere
conversie
atribuire
adunare
scadere
//
//
//
//
... prefixat
incr
...
postfixat ...
...
prefixat decr
...
postfixat ...
//
... relational <
// Destructor
// Numarul de cifre
// cout << x
// cin >> x
};
Natural::Natural ( ) { }
Natural::Natural (const Natural& S) { }
Natural::Natural (unsigned long S) { }
Natural& Natural::operator= (const Natural& S){
Natural& Natural::operator++() {
Natural& Natural::operator--() {
Natural Natural::operator++(int){
Natural Natural::operator--(int){
}
}
}
}
return *this=*this+1; }
return *this=*this-1; }
Natural x(*this); *this=*this+1; return x;}
Natural x(*this); *this=*this-1; return x;}
07.05.15
// ++x
// --x
// x++
// x--
// cout
// cin
// <<
// >>
clrscr();
getche();
85
C+
PO
#include <conio.h>;
class Q { long m, n;
// m / n
public:
Q (long, long);
// constructor implicit
Q& operator ~();
// operator de simplificare
friend Q
operator *(Q, Q);
// functie prieten
void
Tip(const char* Mes="");
// tiparire (mesaj)
};
inline Q::Q(long p=0, long q=1 ) { m=p; n=q; }
Q& Q::operator ~()
{ long d=Cmmdc(m,n); m/=d; n/=d; return *this; }
Q
operator *(Q r, Q s) {return ~Q(r.m*s.m, r.n*s.n); }
// friend
inline void Q::Tip (const char* Mes)
{ if (n) cout << Mes << m << "/" << n << endl;
else cerr << " Numitor nul " ;};
long Cmmdc(long a, long b)
{ if (b) return Cmmdc(b,a%b);
else return a;
};
void main ()
{
clrscr();
Q x(3,2); x.Tip(" x : ");
Q y(2,9); y.Tip(" y : ");
Q z(2);
z.Tip(" z : "); z=x*y; z.Tip(" x*y = ");
Q w(2,1); w.Tip(" w : "); z=x*w; z.Tip(" x*w = ");
z=x*2;
z.Tip(" x*2 = "); z=2*x; z.Tip(" 2*x = ");
getch();
}
// R e z u l t a t e :
x
y
z
x*y
w
x*w
x*2
2*x
07.05.15
:
:
:
=
:
=
=
=
3/2
2/9
2/1
1/3
2/1
3/1
3/1
3/1
86
C+
PO
O alt variant n care se evit utilizarea unei funcii prietene este de a defini o funcie
membru (Produs) care se va apela de ctre funcia de suprancrcare a operatorului de
nmulire.
Exemplu:
// Numere raionale: Q
#include <string.h>;
#include <iostream.h>;
#include <conio.h>;
Q
void
Produs (Q);
// m / n
// constr. implicit
// operator de simplificare
// Produs
// tiparire (mesaj)
};
inline Q::Q(long p=0, long q=1 ) { m=p; n=q; }
Q& Q::operator ~()
{ long d=Cmmdc(m,n); m/=d; n/=d; return *this; }
void main ()
{
Q x(3,2);
Q y(2,9);
Q z(4,2);
Q w;
w=x*y;
w=x*z;
w=x*2;
w=2*x;
clrscr();
x.Tip("
y.Tip("
z.Tip("
w.Tip("
w.Tip("
w.Tip("
w.Tip("
x : ");
y : ");
z : ");
x*y=
x*z=
x*2=
2*x=
");
");
");
");
getch();
// R e z u l t a t e :
x :
y :
z :
x*y=
x*z=
x*2=
2*x=
3/2
2/9
4/2
1/3
3/1
3/1
3/1
07.05.15
87
C+
PO
Exemplu:
/ / N u m e r e c o m p l e x e : T C
#include <iostream.h> #include <conio.h> #include <math.h>
#include <complex.h>
// class C;
class T
{
public:
//
float
float
void
class C
{
public:
float
float
float
void
//
float
float
void
C
(T z);
// Conversie prin constructor C<-T
float Modul ();
float Arg ();
void Tip (const char* Mesaj);
};
C::C
( float a, float b ) { Re=a; Im=b; }
C::C
(T z) { Re=z.Re(); Im=z.Im(); } // Conversie prin constructor C<-T
C::Modul( ) { return sqrt(Re*Re+Im*Im); }
C::Arg ( ) { return atan2 (Im,Re); }
C::Arg ( ) { return atan2 (Im,Re); }
C::Tip ( const char* Mesaj)
{ cout << Mesaj << Re << "+" << Im << "i" << endl; }
T::T ( float Modul, float Arg) { Ro=Modul; Fi=Arg; }
T::T (C w) { Ro=w.Modul(); Fi=w.Arg(); }
// Conversie C->T
T::Re ( ) { return Ro*cos(Fi); }
T::Im ( ) { return Ro*sin(Fi); }
T::Tip(const char* Mesaj)
{ cout << Mesaj << Ro << "," << Fi << ";" << endl; }
void main ()
{
clrscr();
T y(2,3);
y.Tip(" (r,u) = ");
C x;
x=y;
x.Tip(" (a,b) = ");
complex z(y.Re(),y.Im());
cout << " z = " << z << endl;
cout << " (x,y) = " << real(z) << "+" << imag(z) << "i" << endl;
cout << " (x,y) = " << sqrt(norm(z)) << "," << arg(z) << ";" << endl;
getch();
}
// R e z u l t a t e :
(r,u)=2,3;
(a,b)= -1.979985+0.28224i
z =(-1.979985,0.28224)
(x,y)= -1.979985+0.28224i
(r,u)=2,3;
07.05.15
88
C+
PO
class Q
{
public:
void
inline
inline
inline Q
#include <iostream.h>;
long m;
long n;
Q
(long, long);
operator double();
Q
operator *(Q);
Tip (const char* Mes);
#include <conio.h>;
// m / n
// constr. implicit
// Q double
// inmultire
// tiparire
};
Q::Q(long p, long q)
{ m=p; n=q; }
Q::operator double () { return double(m) / n;
}
Q::operator * (Q r)
{ return Q(m*r.m, n*r.n); }
inline void Q::Tip(const char* Mes) {cout << Mes << m << "/" << n << endl;}
void main ()
{
Q x(2,5);
Q y(3,7);
Q z=x*y;
z.Tip(" z = ");
double a, b;
a=x*4.5;
cout << " a = " << a << endl;
b=4.5*x;
cout << " b = " << b << endl;
}
07.05.15
clrscr();
getch();
// R e z u l t a t e :
z = 6/35
a = 1.8
b = 1.8
89
C+
PO
23.2.2. Conversia dintr-un tip abstract ntr-un alt tip abstract (prin operatori)
Acest tip de conversie se poate realiza i prin oparatori (dar nu simultan i prin
constructori).
n programul urmtor este realizat conversia (prin operatorul de
conversie) din trigonometric (clasa T) n forma algebric (clasa C):
/ / N u m e r e c o m p l e x e : T C
#include <iostream.h> #include <conio.h> #include <math.h>
#include <complex.h>
class C
{
public:
float
float
void
C::C
(
float C::Modul(
float C::Arg (
void C::Tip (
{
Ro, Fi;
// forma polar
(float Modul=0, float Arg=0);
();
// Operatorul de conversie
();
();
(const char* Mesaj);
};
T::T ( float Modul, float Arg) { Ro=Modul; Fi=Arg; }
T::operator C() { return C(Re(),Im()); }
// Op. Conv.
class T
{
public:
operator
float
float
void
float
T
C
Re
Im
Tip
// R e z u l t a t e :
(r,u)=2,3;
(a,b)= -1.979985+0.28224i
z =(-1.979985,0.28224)
(x,y)= -1.979985+0.28224i
(r,u)=2,3;
07.05.15
90
C+
PO
//
Funcii
T e m p l a t e (1) \\
void main ()
{
int a,b;
cout << " Dati a,b : "; cin >> a >> b;
cout << " Maximul = " << Max(a,b) << endl;
clrscr();
float x,y;
cout << " Dati x,y : "; cin >> x >> y;
cout << " Maximul = " << Max(x,y) << endl;
getche();
}
//N&d-Eusorsgreeti!
//
Funcii
T e m p l a t e (2) \\
#include <string.h>
07.05.15
clrscr();
getche();
91
C+
PO
//
Clase T e m p l a t e \\
clrscr();
getche();
Nume_Tip)
07.05.15
92
C+
PO
#include <conio.h>
#include <iostream.h>
# include "C_Templ4.h"
# pragma option -Jgx
void main ()
{
clrscr();
Vint10 X; X.CitV("X"); cout << " Maximul este " << X.MaxV( ) << endl;
Vflo13 Y; Y.CitV("Y"); cout << " Maximul este " << Y.MaxV( ) << endl;
getche();
}
// Cpp Template ... Manual \\
#include <conio.h>
#include "C_Templ4.h"
template <class T, int Dim>
void Vect<T,Dim>::CitV (char *Mes)
{ cout << " Dati nr. elem.: "; cin >> n;
cout << " Dati elem." << Mes << " : ";
for (int i=0; i<n; i++) cin >> X[i];
}
template <class T, int Dim>
T Vect<T,Dim>::MaxV ()
{ T max=X[0];
for (int i=1; i<n; i++) if (X[i]>max) max=X[i];
}
#include <iostream.h>
return max;
T
int
public: void
T
X[Dim];
n;
CitV (char*);
MaxV ( );
};
07.05.15
93
C+
PO
simpl
C2
multipl k
C1
C2
2) Agregare relaie de asociaie prin care obiectul agregat este inclus n obiectul
agregant (verbul caracteristic este a avea), i evident c poate fi simpl sau multipl:
C1
simpl
C2
multipl k
C1
C2
C2
Specializare
simpl
C1
C2
C1
C3
Specializare
multipl
C2
C3
Motenire
multipl
Se pot obine n felul acesta i ierarhii spaiale de clase, avnd relaii att pe
orizontal ct i pe vertical.
94
asociaie
C1
C1
rol1
rol2
C2
C2
instaniere
PO
instaniere
C+
legtur
O1
O2
C1
C1
asociaia
{ordonata}
asociaia
calificant
C2
C2
07.05.15
C2
Cas.
95
C+
PO
Clase asociate \\
#include <conio.h>
#include <iostream.h>
#include "VectCaut.h"
void main (void)
{ int n;
cout << " Dati n : "; cin >> n;
VectSort X(n);
// X.Sort ();
VectCaut x(&X);
X.Print();
int a,p;
do { cout << " Dati a : "; cin >> a;
if (p=x.CautSec(a)) cout << " Pe poz." << p << endl;
else if(a) cout << " Inexistent! " << endl; }
while (a);
cout << " Dati m : "; cin >> n;
VectSort* Y=new VectSort(n); Y->Sort();
VectCaut* y=new VectCaut(Y); Y->Print();
do { cout << " Dati b : "; cin >> a;
if (p=y->CautBin(a)) cout << " Pe poz." << p << endl;
else if(a) cout << " Inexistent! " << endl; }
while (a);
clrscr();
getche();
}
//
Clas
#include "VectSort.h"
class VectCaut { VectSort *v;
public: VectCaut (VectSort*);
int CautSec (int a);
int CautBin (int a);
};
//
asociant \\
Clas asociat \\
07.05.15
96
C+
PO
//
Clas asociant \\
# include "VectCaut.h"
VectCaut::VectCaut (VectSort *p)
{
v = p;
}
int VectCaut::CautSec(int a)
{ int i=1, n=v->Dim(), *x=v->Adr();
while ((i<=n) && (x[i]-a)) i++;
return i%(n+1);
}
int VectCaut::CautBin(int a)
{ int St=1, Dr=v->Dim(), *x=v->Adr();
while (St<=Dr) { int m=(St+Dr)/2;
if (x[m]-a) if (x[m]<a) St=m+1; else Dr=m-1;
else return m; }
return 0;
}
//
Clas asociat \\
# include <iostream.h>
# include "VectSort.h"
VectSort::VectSort (int k)
{
n = k; v = new int[k+1];
for (int i=1; i<=n; i++) cin >> v[i];
}
void VectSort::Sort( )
{ int k=1; enum {Nu,Da} Sortat;
do { Sortat=Da;
for (int i=1; i<=n-k; i++)
if (v[i]>v[i+1]) { int Temp=v[i]; v[i]=v[i+1];
v[i+1]=Temp; Sortat=Nu;
} k++;
}
while (!Sortat);
}
void VectSort::Print ( )
{
for (int i=1; i<=n; i++) cout << v[i] << ','; cout << endl;
}
int* VectSort::Adr ( )
{
return v;
}
int VectSort::Dim ( )
{
return n;
}
VectSort::~VectSort ( )
{
delete []v;
}
07.05.15
97
C+
PO
C1
C1
Conine
C2
C2
instaniere
instaniere
O1
conine
O2
07.05.15
clrscr();
getche();
98
C+
PO
//
Clas
#include "VectSort.h"
class VectCaut { VectSort V;
public: VectCaut (int=10);
void Sort ();
void Print();
int CautSec (int);
int CautBin (int);
};
//
Agregant \\
Clas Agregant \\
# include "Vect_Agr.h"
VectCaut::VectCaut (int n) : V(n)
{
}
void VectCaut::Sort ()
{
V.Sort();
}
void VectCaut::Print ()
{
V.Print();
}
int VectCaut::CautSec(int a)
{ int i=1, n=V.Dim(), *x=V.Adr();
while ((i<=n) && (x[i]-a)) i++;
return i%(n+1);
}
int VectCaut::CautBin(int a)
{ int St=1, Dr=V.Dim(), *x=V.Adr();
while (St<=Dr) { int m=(St+Dr)/2;
if (x[m]-a) if (x[m]<a) St=m+1; else Dr=m-1;
else return m; }
return 0;
}
//
Clas Agregat \\
//
};
//
Clas Agregat \\
# include <iostream.h>
# include "VectSort.h"
07.05.15
//
\\
99
C+
PO
n urmtorul exemplu se va folosi o clas Iterator pentru list simplu nlnuit care
utilizeaz clasa Elem pentru un nod al listei i clasa Lista:
//
Iterator List \\
#include <conio.h>
#include <iostream.h>
# define Tel int
class Elem
{ Tel Inf;
Elem* Leg;
public: Elem (Tel inf, Elem* leg=0) { Inf=inf; Leg=leg; }
friend class Lista;
friend class Iterator;
};
class Lista { Elem* Cap;
public: Lista ( )
{ Cap=0; }
void Ad (Tel);
friend class Iterator;
};
void Lista::Ad (Tel elem)
{ if (Cap) { Elem* p=Cap; while (p->Leg) p=p->Leg; p->Leg=new Elem(elem,0);}
else Cap=new Elem(elem,0);
}
class Iterator { Elem* p;
public:
Iterator(Lista& L)
Tel operator () ( )
void operator ++ ( )
int operator ! ( )
};
{
{
{
{
p = L.Cap;
return p->Inf;
p = p->Leg;
return p!=0;
}
} // elementul curent
} // avanseaza in lista
} // exista element
clrscr();
getche();
}
07.05.15
100
C+
PO
class Cerc
Raza
Centrul
};
void main ()
{
Cerc C;
Cerc::Punct P;
//
...
}
C l as e In cu i b at e
#include <conio.h>
#include <iostream.h>
class Cerc {
float
class
\\
// Cerc(x,y,r)
r;
Punct {
float
public: Punct
void Print
};
Punct Centru;
public: Cerc (Punct P, float
void Print()
};
void main ()
{
Cerc::Punct O(1,2);
Cerc C(O,3);
// Punct(x,y)
x,y;
(float x0=0, float y0=0) { x=x0; y=y0; }
()
{ cout <<' '<< x <<' '<< y <<' '; }
raza) { Centru=P; r=raza; }
{ Centru.Print(); cout << r; }
O.Print();
C.Print();
clrscr();
cout << endl;
cout << endl;
getch();
07.05.15
101
C+
PO
Evident c din clasa ncuibat (Punct) nu avem acces la elementele clasei din care
face parte (Cerc). Dac se dorete acest lucru, atunci se poate proceda ca i n urmtorul
exemplu:
//
C l as e In cu i b at e
\\
#include <conio.h>
#include <iostream.h>
class Cerc {
// Cerc(x,y,r)
float r;
public: Cerc (float raza) { r=raza; }
class Punct;
friend Punct;
class Punct {
// Punct(x,y)
float x,y;
public: Punct (float x0, float y0) { x=x0; y=y0; }
void Print (Cerc c){cout <<' '<<x<<' '<<y<<'
'<<c.r;}
};
};
// void Cerc::Punct::Print (Cerc c) { cout <<' '<<x<<' '<<y<<' '<<c.r; }
void main ()
{
Cerc c(3);
Cerc::Punct O(1,2);
clrscr();
O.Print(c);
getch();
class R
//
C l as e In cu i b at e
\\
double x;
public: R (double x) { this->x=x; }
class R2; friend R2;
class R2 {
double y;
public: R2 (double y) { this->y=y; }
class R3; friend R3;
class R3 {
double z;
public: R3 (double z) { this->z=z; }
void Print (R,R2);
};
void Print (R);
};
};
void
R::R2::Print (R a)
{cout <<' '<<a.x;}
void R::R2::R3::Print (R a, R2 b) {b.Print(a); cout <<' '<<b.y<<' '<<z;}
void main ()
{
R
OX (1);
R::R2
XOY(2);
R::R2::R3 XYZ(3);
}
07.05.15
clrscr();
XYZ.Print(OX,XOY);
getch();
102
C+
PO
specializare
C1
C1
C1
C2
este o
Ob
Cb
generalizare
este un
Prin aceast relaie putem modela similitudinile dintre clase dou sau mai multe
clase. Pornind de la o clas de baz (general) se pot deriva noi clase (prin diferenele
specifice). Obiectele clasei derivate motenesc atributele i metodele clasei de baz la care
se vor aduga noile elemente caracteristice (vor fi umflate), ceea ce permite reutilizarea
resurselor deja pregtite n clasele de baz (pentru obiectele similare). Verbul caracteristic
al acestei relaii de specializare este a fi ( este un fel de <a kind of>).
Od
Cd
C2
C2
Specializare
simpl
25.4.1.
C3
Specializare
multipl
C3
Motenire
multipl
Clase derivate
07.05.15
103
C+
PO
d\b#+
+#+###
Cl_Baz
Cl_Derivat
by
cz
Cl_Baz
Cl_Derivat
bcy
Cl_Baz
public:
a
b
c
protected:
07.05.15
//inline
104
C+
PO
Deoarece relaia de derivare este poate cea mai important relaie dintre clase, sunt
oferite faciliti de implementare, care permit urmtoarele faciliti:
economia de cod reutilizarea codului scris o singur dat dup care se motenete,
extensibilitate re-specializare prin derivarea de noi ramuri dintr-o ierarhie,
polimorfism ntr-o ierarhie de clase se poate implementa o comportare polimorfic,
ncapsularerelaxare relaia de derivare ofer posibilitatea nchiderii resurselor
simultan cu deschiderea spre modificare i extensie.
Relaiile de derivare (de fapt i celelalte relaii dintre clase) sunt stabilite la
compilare, deci nu se mai pot modifica pe parcursul execuiei. Mai trebuie cunoscut faptul
c prin derivare nu se pot moteni constructorii, destructorii, elementele prietene (funcii,
clase sau metode friend) i nici operatorii redefinii.
Exemplu:
//
Relatia de derivare \\
#include <conio.h>
#include <string.h>
#include <iostream.h>
class N {
protected:
char* c;
public:
N (char* s) { c=new char[strlen(s)+1]; strcpy(c,s); }
~N (
) { delete [ ] c; }
char* Modul (
) { return c; }
};
void Print (N n) { cout << n.Modul() << endl; }
class Z : public N
{
private:
public:
char
};
char Semn;
Z (char* s) :
~Z (
)
Semnul(
)
N(s+1)
{ Semn=s[0]; }
{
}
{ return Semn; }
07.05.15
clrscr();
getche();
105
C+
PO
Conversia unui obiect dintr-o clas derivat ntr-un obiect aparinnd clasei de baz
este permis, invers ns nu (sursa trebuie s acopere destinaia):
Contra_Exemplu:
//
Conversii la derivare ? \\
N
Z
N*
Z*
clrscr();
n("1234");
Print (n);
k(n);
Print (k);
i = new N(k); Print (*i);
j = new Z(i); Print (*j);
Pentru o funcie care are ca parametru formal un obiect al clasei de baz este permis
apelul avnd ca parametru un obiect al clasei derivate, invers nu (o funcie care are ca
parametru formal un obiect al clasei derivate, nu poate fi apelat avnd ca parametru actual
un obiect al clasei de baz).
Exemplu:
//
Conversie la derivare \\
#include <conio.h>
#include <string.h>
#include <iostream.h>
class N {
protected:
public:
N
N
N
~N
char* Modul
};
char*
(
(char*
(N&
(
(
c;
)
s)
n)
)
)
{
{
{
{
{
char
Z(
Z (char*
~Z (
Semnul(
Semn;
) : N( )
s) : N(s+1)
)
)
{ Semn='+' ;
{ Semn=s[0];
{
{ return Semn;
}
}
}
}
clrscr();
Print (k);
Print (n);
Print (*p);
Print (*q);
WriteAbs_(p);
WriteAbs_(q);
getche();
07.05.15
106
C+
#include <conio.h>
#include <iostream.h>
PO
//
Relaia de derivare \\
#include "Vect_Der.h"
void main (void)
{ int n;
cout << " Dati n : "; cin >> n;
Vect_Der X(n); X.Print();
int a,p;
do { cout << " Dati a : "; cin >> a;
if (p=X.CautSec(a)) cout << " Pe poz." << p << endl;
else if(a) cout << " Inexistent! " << endl; }
while (a);
cout << " Dati m : "; cin >> n;
Vect_Der* Y=new Vect_Der(n); Y->Sort(); Y->Print();
do { cout << " Dati b : "; cin >> a;
if (p=Y->CautBin(a)) cout << " Pe poz." << p << endl;
else if(a) cout << " Inexistent! " << endl; }
while (a);
}
//
Clas
class VectBaza {
protected: int *v, n;
public:
VectBaza (int = 10);
void
Sort ( );
void
Print( );
~ VectBaza ( );
};
de baz \\
clrscr();
getche();
//
Clas de baz \\
<< VectBaza.Cpp >>
# include <iostream.h>
# include "VectBaza.h"
VectBaza::VectBaza (int k)
{
n = k; v = new int[k+1];
for (int i=1; i<=n; i++) cin >> v[i];
}
void VectBaza::Sort( )
{ int k=1; enum {Nu,Da} Sortat;
do { Sortat=Da;
for (int i=1; i<=n-k; i++)
if (v[i]>v[i+1]) { int Temp=v[i]; v[i]=v[i+1];
v[i+1]=Temp; Sortat=Nu;
} k++;
}
while (!Sortat);
}
void VectBaza::Print ( )
{
for (int i=1; i<=n; i++) cout << v[i] << ','; cout << endl;
}
VectBaza::~VectBaza ( )
{
delete []v;
}
07.05.15
107
C+
PO
//
Clas
#include "VectBaza.h"
class Vect_Der : public VectBaza {
public: Vect_Der (int=10);
int CautSec (int);
int CautBin (int);
};
Clas
//
Derivat \\
Derivat \\
# include "Vect_Der.h"
Vect_Der::Vect_Der (int n) : VectBaza(n) {
}
int Vect_Der::CautSec(int a)
{ int i=1; while ((i<=n) && (v[i]-a)) i++; return i%(n+1); }
int Vect_Der::CautBin(int a)
{ int St=1, Dr=n;
while (St<=Dr) { int m=(St+Dr)/2;
if (v[m]-a) if (v[m]<a) St=m+1; else Dr=m-1;
else return m; }
return 0;
}
n exemplul care urmeaz, datele x,y (din clasa de baz Punct) au fost declarate
protected deoarece clasa derivat (Cerc) le refer. La clasa derivat am utilizat
modificatorul public pentru a putea utiliza i pentru Cerc operaia Contine (PC).
//
Program Fct_NeVirtuala;
\\
class
Punct {
protected:
float
public:
x,y;
getch();
// R e z u l t a t e :
Cercul C nu contine punctul P.
Se observ n exemplul de mai sus c rezultatul nu este cel dorit. Acest neajuns l
vom rezolva mai trziu declarnd Distana ca funcie virtual (pentru legare dinamic).
07.05.15
108
C+
PO
Fa de motenirea simpl, n care dintro singur clas de baz se deriveaz una sau
mai multe clase derivate (specializate),
motenirea multipl presupune existena mai
multor clase de baz din care un sau mai multe
clase motenesc diverse caracteristici.
Cb
Cd1
Cb1
Cd2
Cb2
Cd
Motenire simpl
Motenire multipl
Declararea unei clase derivate din mai multe clase de baz se face astfel:
class Clas_de_baz_1 { };
class Clas_de_baz_2 { };
class Clas__derivat : Mod_Pr Clas_de_baz_1, Mod_Pr Clas_de_baz_2
{
};
unde Mod_Pr { public, protected, private }.
Datorit motenirii multiple o clas de baz poate fi
prezent n mai multe exemplare ntr-o clas derivat, aa
cum se poate vedea n exemplul alturat, unde datele
membru ale clasei Animal vor fi motenite n dou
exemplare de ctre clasa Cine (unul prin clasa Domestic,
altul prin clasa Mamifer) i pot fi referite prin operatorul
de rezoluie ( :: ) aplicat clasei prin care se face motenirea
(Nume).
Aceast motenire repetitiv a unei clase de baz
este corect i se poate utiliza astfel:
Animal
Mamifer
Domestic
Cine
Cl_Baz
Cl_Baz
Cl_Der1
Cl_Der2
Clas_Derivat
07.05.15
109
C+
PO
Dac dorim realizarea unei singure copii a atributelor motenite, vom folosi
motenirea multipl virtual:
Cl_Baz
Cl_Der1
Cl_Der2
Clas_Derivat
class
class
class
class
07.05.15
110
C+
PO
P r o g r a m C l a s e N e Vir t u a l e ;
\\
#include <iostream.h>
#include <conio.h>
#include <string.h>
clrscr();
c.Tip();
getch();
// Rezultate:
Nume Mamifer :
Nume Domestic:
Greutate
:
Pret
:
Lant
:
07.05.15
Cane
Nero
13
1300
8
111
C+
PO
Dac dorim ca datele membru s fie prezente ntr-un singur exemplar n clasele
derivate, atunci vom utiliza clase virtuale. O clas de baz devine virtual prin motenire
dac se declar aceasta prin cuvntul virtual plasat naintea clasei (devenind astfel clas
virtual fa de clasa derivat).
Programul anterior modificat astfel nct numele s fie memorat ntr-un singur
exemplar este urmtorul:
//
P r o g r a m C l a s e Vir t u a l e ;
\\
#include <iostream.h>
#include <conio.h>
#include <string.h>
// Rezultate:
Nume Animal
Greutate
Pret
Lant
07.05.15
:
:
:
:
Lup
13
1300
8
112
C+
PO
Exemplul:
//
P r o g r a m I e r a r h i e C l a s e Vir t u a l e / N e v i r t u a l e ;
\\
#include <iostream.h>
#include <conio.h>
class A {
public: A (char* a)
{ cout << " A : " << a << endl; }
class B: virtual public A {
public: B (char* b) : A(b) { cout << " B : " << b << endl; }
class C: virtual public A {
public: C (char* c) : A(c) { cout << " C : " << c << endl; }
class D:
public A {
public: D (char* d) : A(d) { cout << " D : " << d << endl; }
class E {
public: E (char* e)
{ cout << " E : " << e << endl; }
class F {
public: F (char* f)
{ cout << " F : " << f << endl; }
class G:
public B, public C, public D, public E, virtual public F {
public: G (char* g) : A(g), B(g), C(g), D(g), E(g), F(g)
{ cout << " G : " << g << endl; }
void main (void)
{
clrscr();
G Ob("Ob.");
getch();
}
// Rezultate:
A
F
B
C
A
D
E
G
07.05.15
:
:
:
:
:
:
:
:
Ob.
Ob.
Ob.
Ob.
Ob.
Ob.
Ob.
Ob.
113
C+
PO
26. Polimorfism
Suprancrcarea (overloading), prin redefinirea unor funcii sau metode, permite
alegerea la compilare-link_editare a funciei sau a metodei dorite prin semntura acesteia,
fr a mai putea alege la execuie.
Polimorfismul permite ca la execuie s se decid ce metod s fie apelat, oferind
o facilitate a metodelor din clase aflate n relaie de derivare. Prin polimorfism se execut
aciuni diferite prin mesaje cu semnturi identice asupra obiectelor de tip diferit (obiecte din
clase diferite rspund diferit la acelai mesaj).
Dou obiecte sunt compatibile dac aparin aceleai clase (evident) dar i dou
variabile
a) de tip pointer la clasa de baz, respectiv pointer la clasa derivat,
b) de tip referin (pointer constant) la clasa de baz, respectiv referin la clasa derivat .
Legarea unei metode (binding), nelegnd prin aceasta cenexiunea logic dintre o
entitate i o proprietate a acesteia (corespondena dintre un mesaj trimis unui obiect, adic
ordinul de apel, i metoda care se execut ca rspuns la acesta) poate fi:
07.05.15
114
C+
PO
# include <conio.h>
# include <iostream.h>
Met od vi r t u al
\\
class Cb { public:
virtual void f() { cout << " Baza
};
class Cd : public Cb
{ public:
};
void
g(Cb* p) { p->f(); }
void main ()
{
clrscr();
// Legare Statica
// Legare Dinamica
getche();
n exemplul urmtor vom utiliza variabile de tip referin la clasa de baz, respectiv
la clasa derivat.
//
# include <conio.h>
# include <iostream.h>
Met od vi r t u al
\\
class Cb { public:
virtual void f() { cout << " Baza
};
class Cd : public Cb
{ public:
};
void
g(Cb& r) { r.f(); }
void main ()
{
Cb Ob;
Ob.f();
g(Ob);
}
07.05.15
clrscr();
Cd Od;
Od.f();
g(Od);
// Legare Statica
// Legare Dinamica
getche();
115
C+
PO
//
Met od vi r t u al
\\
float
class
Punct { protected:
float x,y;
public:
Punct (float x0, float y0) { x=x0; y=y0; }
Punct (Punct &P) { x=P.x; y=P.y; }
virtual float Dist (Punct P) {return sqrt(Sqr(x-P.x)+Sqr(y-P.y));
int
Contine(Punct P) {return Dist(P)==0; };
};
Cerc : public Punct { float r;
public:
Cerc (float x0, float y0, float R):Punct(x0,y0){r=R;}
float Dist (Punct P) {Punct C(x,y); return C.Dist(P)-r; }
};
class
class
class
class
clrscr();
C contine punctul P." ;
C nu contine punctul P." ;
" Segm. AB contine punctul P." ;
" Segm. AB nu contine punctul P." ;
getche();
07.05.15
116
C+
PO
Aproape orice metod poate fi virtual, chiar i metodele inline, metodele friend
(dar nu i funciile friend) operatorii (dac nu se redefinesc prin funcii friend) i
destructorii, n schimb constructorii i metodele statice nu pot fi virtuale.
n exemplul prezentat n continuare, al doilea produs ( 2/3 * 4/5 = 8/15) nu va fi
afiat dac operatorul de nmulire a dou numere raionale nu este declarat virtual,
(deoarece operatorul *= va apela operatorul de nmulire pentru Q n loc de F cum ar
trebui, a i b fiind din clasa F). Se observ c la nmulirea a dou obiecte din clasa Q nu
sunt tiprite fraciile care se nmulesc, pe cnd la nmulirea a dou obiecte din clasa F
fraciile care se nmulesc sunt tiprite.
//
#include <conio.h>;
\\
#include <iostream.h>;
clrscr();
<< endl;
<< endl;
d;
<< endl;
// R e z u l t a t e :
p = 2/3
q = 4/5
p = 8/15
r = 8/15
a = 2/3
b = 4/5
2/3 * 4/5 = 8/15
d = 8/15
2/3 * 4/5 = 8/15
d = 8/15
07.05.15
117
C+
PO
07.05.15
Animal
Porumbel
Urs
Cal
118
C+
PO
// Rezultate:
gras,
gras,
slab,
07.05.15
tanar, lent
batran, rapid
tanar, rapid
119
C+
PO
Figur
Punct
P trat
Cerc
/ / Cl as Abs tr ac t - M et od e Pure \ \
#
#
#
#
include
include
include
include
<Conio.h>
<Process.h>
<Iostream.h>
<Graphics.h>
class Figura {
protected:
public:
virtual
int x,y;
Figura (int u=0, int v=0) { x=u; y=v; }
void Draw () = 0;
// Pura sau Nula
{ }
virtual
class Punct
};
: public
int
int
Arie () = 0;
Pret () { return Arie()*100+1; }
Figura {
int Cul;
public:
Punct
c=WHITE):Figura(u,v)
{ Cul=c;
}
void Draw() { putpixel(x,y,Cul); }
int Arie() { return 0; }
class Patrat
};
: public
Figura {
int Lat;
public:
Figura(u,v)
{ Lat=L;
}
void Draw() { moveto(x,y);
linerel(0,+Lat); linerel(+Lat,0);
linerel(0,-Lat); linerel(Lat,0); }
int
class Cerc
};
: public
Figura {
int Raza;
public:
Cerc (int u, int v, int R=1) : Figura(u,v)
{ Raza=R;}
void Draw() { circle(x,y,Raza); }
int Arie() { return 3*Raza*Raza; }
};
void InitGraf(void) { int Gd = DETECT, Gm; initgraph(&Gd, &Gm, "C:\\BorlandC\\Bgi"); }
void main (void)
{
clrscr();
Figura* Fig[22];
int i,n; cout << " Dati n : "; cin >> n;
for (i=0; i<n; i++) { int t,x,y,z;
cout << " Dati fig." << i+1 << "(t,x,y,z): "; cin >> t >> x >> y >>
z;
switch (t) { case 1: Fig[i]=new Punct (x,y,z); break;
case 2: Fig[i]=new Patrat(x,y,z); break;
case 3: Fig[i]=new Cerc (x,y,z); break;
default:
exit(1);
};
cout << " Pret = " << Fig[i]->Pret() << endl;
07.05.15
120
C+
PO
};
InitGraf();
getche();
07.05.15
getche(); closegraph();
121
C+
PO
27. I e r a r h i i p e n t r u I n t r r i / I e i r i
Pentru c nu exist instruciuni de intrare/ieire, s-au definit funcii (n C), respectiv
dou ierarhii de clase (n C++). Aceste dou ierarhii (reprezentate n figurile de mai jos i
declarate n fiierul iostream.h) realizeaz operaiile de intrare/ieire prin stream-uri (flux de
date sursdestinaie).
strembuf
filebuf
strstreambuf
ios
istream
ostream
iostream
istream_withassign
ostream_withassig
iostream_withassig
Clasele derivate din clasa istream sau ostream se numesc clase stream iar obiectele
claselor derivate din clasa ios se numesc streamuri. n fiierul iostream.h sunt definite
streamurile cin ( istream_withassign, pentru stdin), cout ( ostream_withassign, pentru
stdout), clog i cerr ( ostream_withassign, pentru stderr, cu respectiv fr zone tampon).
07.05.15
122
C+
PO
clrscr();
getch();
// Rezultate:
r = 12/13
{
public:
...
ostream& Tiprire
...
( ostream& s );
};
ostream& Tiprire ( ostream& s )
{
s << ... ;
return s;
}
ostream& operator << ( ostream&, Clas c )
{
return c.Tiprire(s);
}
07.05.15
123
C+
PO
\\
#include <iostream.h>
#include <conio.h>
operator
clrscr();
getch();
// Rezultate:
r = 12/13
>>
...
friend istream& operator >> ( istream&, Clas& );
...
};
07.05.15
124
C+
PO
Exemplu:
//
\\
#include <iostream.h>
#include <conio.h>
{ p=m; q=n;
( ostream& s,
r.q;
return
( istream& s,
r.q;
return
}
Q r )
s;
}
Q& r )
s;
}
clrscr();
getch();
public:
};
...
istream& Citire
...
( istream& s );
\\
#include <iostream.h>
#include <conio.h>
07.05.15
125
C+
PO
public:
enum {
skipws
left
right
internal
dec
oct
hex
showbase
showpoint
uppercase
showpos
scientific
fixed
unitbuf
stdio
};
=
=
=
=
=
=
=
=
=
=
=
=
=
=
=
0x0001,
0x0002,
0x0004,
0x0008,
0x0010,
0x0020,
0x0040,
0x0080,
0x0100,
0x0200,
0x0400,
0x0800,
0x1000,
0x2000,
0x4000
//
//
//
//
//
//
//
//
//
//
//
//
//
//
//
};
Atributul x_flags are o valoare implicit pentru fiecare tip standard, care se poate
modifica utiliznd funcia membru setf descris n continuare.
Metoda setf are urmtoarele dou forme:
1) long setf (long format);
2) long setf (long bit, long grup);
Funcia modific atributul x_flags preciznd ntraga valoare (varianta a)) sau
preciznd un grup de bii i bitul dorit din cadrul grupului (varianta b)). Grupele (i valorile
corespunztoare) sunt adjustfield (left, right, internal), basefield (dec, oct, hex) i
floatfield (scientific, fixed) n ambele variante funcia returneaz valoarea anterioar a
atributului x_flags. Referirea grupului i bitului dorit se face prin numele clasei urmat de
operatorul de rezoluie i bitul dorit (ios::b). Valoarea atributului x_flags se poate obine i
prin apelul metodei flags (cout.flags() ).
Atributul x_width conine lungimea minim a cmpului de afiare a unei date
(respectiv lungimea maxim a cmpului din care se face citirea), avnd valoarea implicit
07.05.15
126
C+
PO
nul (afiare pe lungimea minim necesar), care se poate modifica utiliznd funcia membru
width descris n continuare n ambele forme:
a) int width ( );
b) int width (int lungime);
Funcia returneaz valoarea atributului x_flags (varianta a)) sau modific atributul
x_width preciznd noua valoare (lungime care poate fi o expresie) i returneaz valoarea
anterioar a atributului x_width (varianta b)). Dup fiecare transfer valoarea atributului
x_flags devine nul.
Atributul x_fill conine caracterul de umplere necesar completrii cmpului de afiare
a datei n situaia n care lungimea acestuia este mai mare dect lungimea necesar, avnd
valoarea implicit spaiu ( ), care se poate modifica utiliznd funcia membru fill :
a) char fill ( );
b) char fill (char car);
Funcia returneaz valoarea atributului x_ fill (varianta a)) sau modific atributul x_
fill preciznd noul caracter de umplere (car) i returneaz valoarea anterioar (varianta b)).
Atributul x_precision conine precizia de afiare (numrul de zecimale) a unei date de
tip real, avnd valoarea implicit 0, care se poate modifica utiliznd funcia membru
precision :
a) int precision ( );
b) int precision (int n);
Funcia returneaz valoarea atributului x_ precision (varianta a)) sau modific
atributul x_ precision preciznd noua precizie (p) i returneaz valoarea anterioar (varianta
b)).
n exemplul urmtor se poate vedea apelul funciilor prezentate anterior precum i
rezultatele obinute:
//
<< cu form at \\
#include <conio.h>
#include <iostream.h>
class N {
int
public:
istream&
ostream&
operator
};
c;
N
(int x=0
) { c=x; }
Cit (istream& s) { s >> c; return s; }
Tip (ostream& s) { s << c; return s; }
double (
) { return this-> c; }
// N -> R
07.05.15
127
C+
PO
clrscr();
cout.setf(ios::hex,ios::basefield);
cout << " Numarul natural n este: " << n << endl;
cout.setf(ios::showbase);
cout << " Numarul natural n este: " << n << endl;
cout << " Numarul natural n este: ";
cout.setf(ios::dec,ios::basefield);
cout.width(6); cout.fill('.');
cout << n << endl;
double x(n); cout << " Numarul n/3.14159 este: ";
cout.setf(ios::fixed,ios::floatfield);
cout.width(9); cout.fill('_'); cout.precision(2);
cout << x/3.14159 << endl;
getche();
}
Rezultate:
Dati un
Numarul
Numarul
Numarul
Numarul
Numarul
27.3.2.
numar natural :
natural n este:
natural n este:
natural n este:
natural n este:
n/3.14159 este:
100
100
64
0x64
...100
____31.83
Manipulatori
ws
dec
oct
hex
flush
ends
endl
1.
2.
3.
4.
5.
6.
setbase (int b)
setiosflags (int f)
resetiosflags (long f)
setw (int l)
setfill (int c)
setprecision (int p)
07.05.15
128
C+
PO
//
<< cu m anipulatori \\
#include <conio.h>
#include <iostream.h>
#include <iomanip.h>
Rezultate :
class N {
int c;
public: N
(int x=0
) { c=x; }
istream& Cit (istream& s) { s >> c; return s; }
ostream& Tip (ostream& s) { s << c; return s; }
operator double (
) { return this-> c; }
};
istream& operator >> (istream& s, N& C) { return C.Cit(s); }
ostream& operator << (ostream& s, N C) { return C.Tip(s); }
n : 100
n = 100
n = 64 : 2001
n = 0x64
n = ...100
n/3= ____33.33
clrscr();
"; cin >> n;
" << n << endl;
" << hex << n <<" : "<< cout.flags() << endl;
" << setiosflags(cout.showbase) << n << endl;
" << dec <<setw(6)<<setfill('.')<< n << endl;
" << setw(9)<<setfill('_')<<setprecision(2)<<n/3;
getche();
#include <conio.h>
#include <iostream.h>
#include <iomanip.h>
class N {
char c[6];
public:
N (
istream& Cit (istream&
ostream& Tip (ostream&
};
istream& operator >> (istream& s,
ostream& operator << (ostream& s,
void main (void)
{
>> cu m anipulatori \\
Rezultate :
) { c[0]=0; }
s) { s >> c; return s; }
s) { s << c; return s; }
N& C) {return C.Cit(s);}
N C) {return C.Tip(s);}
1 : 1234567890
_______________ n = 1
2 : _______________ n = 23
3 : _______________ n = 456
4 : _______________ n = 7890
5 : 1234567890
_______________ n = 12345
clrscr();
N n;
for (int i=1; i<=5; i++)
{ cout << i << " : ";
cin >> setw(i+1) >> n ;
// cin.width(i+1);
cout << " _______________ n = " << n << endl;
}
getche();
}
07.05.15
129
C+
PO
public:
enum {
goodbit
eofbit
failbit
badbit
hardfail
};
=
=
=
=
=
0x00,
0x01,
0x02,
0x04,
0x80,
//
//
//
//
//
operaie corect
sfrit de fiier
eroare intrare/ieire
operaie invalid
eroare fatal
};
1)
2)
3)
4)
5)
class N { char
c[80];
};
void main (void)
{ N n;
}
Rezultate :
: Citeste spatiile.
= Citeste spatiile.
: ^Z
07.05.15
130
C+
PO
#include <conio.h>
#include <iostream.h>
class N {
int
c;
public:
N (
) { c=0; }
istream& Cit (istream& s) { s >> c; return s; }
ostream& Tip (ostream& s) { s << c; return s; }
};
istream& operator >> (istream& s, N& C) { return C.Cit(s); }
ostream& operator << (ostream& s, N C) { return C.Tip(s); }
void main (void)
{
Rezultate :
n : a
State : 2
n : ^Z
State : 3
n : 123
State : 0
n = 123
N n; int Gresit;
do {
cout << " n : "; cin >> n ;
cout << " State : " << hex << cin.rdstate() << endl;
if (cin.good()) Gresit=0;
else {
Gresit=1;
cin.clear();
// anulare biti
char t[255];
// zona tampon
cin.getline(t,255);
// vidare z.t.
}
}
while (Gresit);
cout << " n = " << dec << n << endl;
}
clrscr();
getche();
Verificarea strii de eroare a unui stream se mai poate face prin operatorul ! sau prin
conversia ntr-un pointer fr tip (void*) :
a) operatorul ! este suprancrcat cu metoda clasei ios:
int operator ! ( );
07.05.15
131
C+
PO
n exemplul urmtor se poate vedea att utilizarea conversiei spre tipul void*,
precum i a funciei membru get ( n varianta b)):
//
#include <iostream.h>
#include <string.h>
class N {
int
char*
char*
char*
public:
c;
Mes;
Mer;
Met;
N (int c=0, char* mes=" : ",
char* mer=" Err.\n",
char* met=" = ");
istream& Cit (istream& s);
ostream& Tip (ostream& s) {s<<Met<<c; return s;}
};
char* met)
strcpy(Mes,mes);
strcpy(Mer,mer);
strcpy(Met,met);
istream& N::Cit(istream& s)
{
cout << Mes;
while (!(s>>c)) {
char t[255];
s.clear(); s.get(t,255);
if (s.get()==EOF) return s;
cout << Mer << Mes;
}
return s;
}
istream& operator >> (istream& s, N& C) { return C.Cit(s); }
ostream& operator << (ostream& s, N C) { return C.Tip(s); }
void main (void)
{
N
n;
do
{
cin >> n;
if (cin) cout << n << endl;
}
while (!cin.eof());
}
07.05.15
Rezultate :
: 123
= 123
: a
Err.
: 456
= 456
: xy
Err.
: ^Z
132
C+
PO
Cuprins
pag.
1. Redactarea programelor C.....................................................................1
1.1.
Generaliti...........................................................................................1
1.2.
1.3.
Funcii..................................................................................................2
1.4.
Elementele limbajului...........................................................................3
2. Variabile...................................................................................................4
2.1.
Variabile globale...................................................................................4
2.2.
Variabile locale.....................................................................................4
2.3.
2.4.
Iniializarea variabilelor.......................................................................6
3. Expresii.....................................................................................................7
3.1.
Operatori..............................................................................................7
4. Operaii de intrare/ieire.......................................................................11
4.1.
Funcia Printf....................................................................................11
4.2.
Funcia Scanf.....................................................................................12
4.3.
Funcia PutChar................................................................................13
4.4.
Funcia GetChar................................................................................13
4.5.
Funcia GetChe.................................................................................13
4.6.
Funcia GetCh....................................................................................13
5. Instruciuni.............................................................................................14
5.1.
Instruciunea Vid..............................................................................14
5.2.
Instruciunea Expresie.......................................................................14
5.3.
Instruciunea Compus......................................................................14
5.4.
Instruciunea If..................................................................................15
5.5.
Instruciunea Switch..........................................................................15
5.6.
Instruciunea While............................................................................16
5.7.
Instruciunea Do_While.....................................................................16
5.8.
Instruciunea For...............................................................................17
5.9.
Instruciunea Break.............................................................................17
5.10.
Instruciunea Continue.......................................................................17
07.05.15
133
C+
PO
5.11.
Instruciunea GoTo.............................................................................17
5.12.
6. Pointeri...................................................................................................20
6.1.
6.2.
Operaii cu Pointeri............................................................................21
6.3.
6.4.
Pointeri la funcii.............................................................................23
6.5.
6.6.
Declararea c o n s t antelor..................................................................24
6.7.
S t i v a .................................................................................................25
7. Recursiviate............................................................................................25
8. Tipuri de date.........................................................................................26
8.1.
8.2.
8.3.
8.4.
8.5.
Cmpuri de biti..................................................................................28
9.2.
Abori binari........................................................................................30
10.
Utilizarea fiierelor........................................................................32
10.1.
Nivelul inferior...................................................................................32
10.2.
Nivelul superior..................................................................................35
11.
Funcii standard.............................................................................40
11.1.
Macrouri de clasificare.......................................................................40
11.2.
11.3.
Conversii............................................................................................40
11.4.
11.5.
Funcii de calcul.................................................................................41
11.6.
11.7.
11.8.
Funcii diverse....................................................................................42
07.05.15
134
C+
PO
12.
13.
14.
Faciliti C++.................................................................................47
14.1.
14.2.
Operatori............................................................................................48
14.3.
15.
Funcii C++....................................................................................53
15.1.
Funcii Inline......................................................................................53
15.2.
15.3.
Suprancrcarea funciilor..................................................................56
15.4.
15.5.
16.
T i p A b s t r a c t d e D a t ..........................................................59
17.
17.1.
Definirea Claselor..............................................................................64
17.2.
Constructori i Destructori..............................................................68
18.
1 9 . F u n c i i i C l a s e P r i e t e n e ( F r i e n d ) ................................72
2 0 . M e m b r i s t a t i c i ( S t a t i c ) // $ : ................................................76
20.1.
20.2.
21.
Pointeri la Metode..........................................................................79
22.
Suprancrcarea operatorilor.......................................................81
22.1.
22.2.
22.3.
23.
Conversii utilizator........................................................................86
23.1.
Conversii implicite.............................................................................86
23.2.
Conversii explicite..............................................................................89
24.
07.05.15
C+
PO
24.1.
24.2.
Clase Template...................................................................................92
24.3.
25.
25.1.
Relaia de Asociaie............................................................................95
25.2.
Relaia de Agregare............................................................................98
25.3.
Clase ncuibate(imbricate)................................................................101
25.4.
Relaia de derivare............................................................................103
2 6 . P o l i m o r f i s m .............................................................................113
26.1.
26.2.
2 7 . I e r a r h i i p e n t r u I n t r r i / I e i r i .........................................120
27.1.
27.2.
Operatorul de extragere
27.3.
Intrri/Ieiri cu format......................................................................124
27.4.
>>...........................................................122
Cuprins.....................................................................................................131
Bibliografie...............................................................................................135
07.05.15
136
C+
PO
Bibliografie
07.05.15
137