Note Digitale: B.Tech (Anul I - SEM II) (2018-19)

PROGRAMARE ORIENTATĂ PE OBIECTE
NOTE DIGITALE
B.TECH
(Anul I – SEM II)
(2018-19)
DEPARTAMENTUL CSE & IT
LNVETOLEARN&LEARNTO
COLEGIUL DE INGINERIE ȘI TEHNOLOGIE

MALLA REDDY (Instituție autonomă - UGC, Guvernul Indiei)
Recunoscut în conformitate cu 2 (f) și 12 (B) din UGC ACT 1956 (Afiliat la JNTUH, Hyderabad, aprobat de AICTE - Acreditat de NBA și NAAC - Gradul "A" -
Certificat ISO 9001: 2015) Maisammaguda, Dhulapally (Post Via.
Hakimpet), Secunderabad – 500100, statul Telangana, India.
Anul I B.Tech II SEM L T/P/D C

4 1/-/- 3
(R18A0502) PROGRAMARE ORIENTATĂ PE OBIECTE
Obiectivele
• Pentru a preda elevului conceptele de programare orientată pe obiecte și proceduri
• Pentru a diferenția între funcții, clase și obiecte
• Pentru a învăța să supraîncărcați funcțiile și operatorii
• Pentru a proiecta aplicații utilizând tehnici de gestionare dinamică a memoriei
• Pentru a învăța elevul să implementeze programarea generică și gestionarea excepțiilor
Unitatea I
Introducere în programarea orientată pe obiecte: Paradigma orientată pe obiecte - Diferențele
dintre programarea orientată pe obiecte și programarea orientată pe proceduri, Conceptele de bază
ale programării orientate pe obiecte, Încapsularea, Moștenirea și polimorfismul, Beneficiile OOP,
Structura unui program C ++, spațiul de nume, Tipuri de date, jetoane C ++, Identificatori, Variabile,
Constante, Operatori, Structuri de control și bucle.
Unitatea II
Funcții, clase și obiecte:
Introducerea claselor, definirea clasei, definirea unui membru, obiecte, controlul accesului, domeniul
de aplicare al clasei, operatorul rezoluției domeniului, funcțiile inline, alocarea memoriei pentru
obiecte, membrii datelor statice, funcțiile statice ale membrilor, matricele de obiecte, obiectele ca
argumente funcționale, funcțiile prieten.
Unitatea III
Constructori, distrugători, moștenitori:
Introducere în constructori, constructori impliciti, constructori parametrizați, constructori de copii,
constructori multipli într-o clasă, distrugători.
Moștenire:
Introducere în moștenire, Definirea claselor derivate, Moștenire unică, Moștenire multiplă,
Moștenire pe mai multe niveluri, Moștenire ierarhică, Moștenire hibridă.
Unitatea IV
Indicatori, funcții virtuale și polimorfism:
Introducere în gestionarea memoriei, operator nou și operator de ștergere, Pointeri către obiecte,
Pointeri către clase derivate, Polimorfism, Polimorfism de timp de compilare, Polimorfism de timp de
execuție, Funcții virtuale, Supraîncărcare - Supraîncărcare funcție, Supraîncărcare operator.
Unitatea V
Șabloane și tratarea excepțiilor:
Introducere în șabloane, șabloane de clasă, șabloane de clasă cu parametri multipli, șabloane de
funcții, șabloane de funcții cu parametri multipli.
Tratarea excepțiilor:
Elementele de bază ale tratării excepțiilor, Tipuri de excepții, Mecanismul de tratare a excepțiilor,
Mecanismul de aruncare și prindere, Revocarea unei excepții, specificarea excepțiilor.
Rezultate:
• Pentru a diferenția programarea orientată pe obiecte și programarea procedurală.
• Pentru a construi clase, funcții și obiecte
• Pentru a pune în aplicare constructorii, distrugătorii și moștenirea
• Dezvoltarea programelor folosind tehnici de gestionare dinamică a memoriei
• Pentru a aplica tratarea excepțiilor și programarea generică.
Manuale:
1. Programare orientată pe obiecte cu C ++ de Balagurusamy
2. C++, referința completă, ediția a4-a , Herbert Schildt, TMH.
Referinţe:
1. C++ Primer, edițiaa 3-a , S.B.Lippman și J.Lajoie, Pearson Education.
2. Limbajul de programare C++, edițiaa 3-a , B.Stroutstrup, Pearson Educ
UNITATEA -1
Concepte de programare orientată pe obiecte: Diferențe de paradigmă orientate obiect între programarea
orientată pe obiecte și programarea orientată pe proceduri, conceptele de bază ale programării orientate pe
obiecte, încapsularea, moștenirea și polimorfismul. Beneficiile OOP . Structura unui program C ++, spațiu de
nume, tipuri de date, jetoane C ++, identificatori, variabile, constante, operatori, structuri de control și bucle.
Prezentare generală a limbajului C:

1. Limbajul C este cunoscut sub numele de limbaj orientat pe structură sau limbaj orientat pe proceduri
2. Utilizează o abordare de programare de sus în jos, în care o problemă este privită ca o secvență de sarcini care
trebuie îndeplinite.
3. Tot codul de program al lui c poate fi executat în C ++ dar invers multe nu fi posibil
4. Supraîncărcarea funcției și supraîncărcarea operatorului nu sunt posibile.
5. Variabilele locale pot fi declarate numai la începutul blocului.
6. Controalele programului sunt prin salturi și apeluri către subrutine.
7. Polimorfismul, încapsularea și moștenirea nu sunt posibile.
Pentru rezolvarea problemelor, problema este împărțită într-un număr de module. Fiecare modul este un
subprogram.
8. Proprietatea de abstractizare a datelor nu este acceptată de limbajul orientat spre procedură.
9. Datele din limbajul orientat spre procedură sunt deschise și pot fi accesate de orice funcție.
Prezentare generală a limbajului C++:

1. C++ poate fi considerat o versiune incrementală a limbajului c, care constă în toate construcțiile limbajului de
programare cu caracteristici nou adăugate ale programării orientate pe obiecte.
2. C++ este un limbaj de programare orientat pe structură (procedură) și orientat pe obiecte.
3. Extensia de fișier a programului C++ este ". CPP"
4. Supraîncărcarea funcției și supraîncărcarea operatorului sunt posibile.
5. Variabilele pot fi declarate în linie, adică atunci când este necesar
6. În c++ se pune mai mult accent pe date decât pe proceduri
7. Polimorfismul, încapsularea și moștenirea sunt posibile.
8. Proprietatea de abstractizare a datelor este acceptată de c++.
9. Accesul la date este limitat. Acesta poate fi accesat prin furnizarea diferitelor moduri de vizibilitate atât
pentru date, cât și pentru funcțiile membrilor. acolo prin asigurarea securității datelor prin ascunderea datelor
10. Legarea dymanică este susținută de C++
11. . Suportă toate caracteristicile limbajului c
12.It poate fi numită o versiune incrementală a limbajului c
Diferența dintre programarea orientată pe proceduri (POP) și programarea orientată pe obiecte (OOP)
Programare orientată spre proceduri Programare orientată pe obiecte

Programul este împărțit în părți mici numite
1
Programul este împărțit în părți numite obiecte.
funcții.
Nu se acordă importanță datelor , ci Se acordă importanță datelor, mai degrabă decât
2
funcțiilor, precum și succesiunii acțiunilor procedurilor sau funcțiilor, deoarece funcționează
care trebuie făcute. ca o lume reală.
3 urmărește Abordare de sus în jos. Urmează OOP Abordare de jos în sus.
OOP are specificatori de acces numiți Public,
4 Nu are niciun specificator de acces.
Privat, Protejat etc.
Datele se pot deplasa liber de la o funcție la Obiectele se pot mișca și comunica între ele prin
5
alta în sistem. funcțiile membrilor.
Pentru a adăuga date și funcții noi în POP nu OOP oferă o modalitate ușoară de a adăuga date și
6
este atât de ușor. funcții noi.
Majoritatea funcțiilor utilizează date globale În OOP, datele nu se pot deplasa cu ușurință de la o
7 pentru partajare, care pot fi accesate liber de la funcție la alta, pot fi păstrate publice sau private,
o funcție la alta în sistem. astfel încât să putem controla accesul datelor.
Nu are nicio modalitate adecvată de a ascunde OOP oferă ascunderea datelor, astfel încât oferă
8
datele, deci este mai puțin sigur. mai multă securitate.
În OOP, supraîncărcarea este posibilă sub forma
9 Supraîncărcarea nu este posibilă. supraîncărcării funcției și supraîncărcării
operatorului.
Exemplu de procedură orientată Exemple de programare orientată pe obiecte sunt:

10
Programarea este : C, VB, FORTRAN, Pascal. C++, JAVA, VB.NET, C#.NET.
Principiile (sau caracteristicile) programării orientate pe obiecte:

1. Încapsulare
2. Abstractizarea datelor
3. Polimorfism
4. Moștenire
5. Legare dinamică
6. Transmiterea mesajului
Încapsulare: Împachetarea datelor și a funcțiilor împreună ca o singură unitate este cunoscută sub numele de
încapsulare. În mod implicit, datele nu sunt accesibile lumii exterioare și sunt accesibile numai prin funcțiile care
sunt înfășurate într-o clasă. Prevenirea accesului direct la date de către program se numește ascunderea datelor sau
ascunderea informațiilor
Extragerea datelor:
Abstractizarea se referă la actul de reprezentare a caracteristicilor esențiale fără a include
detaliile sau explicațiile din spatele terenului. Clasele folosesc conceptul de abstractizare și sunt definite ca o listă
de atribute, cum ar fi dimensiunea, greutatea, costul și funcțiile care operează asupra acestor atribute. Ele
încapsulează toate proprietățile esențiale ale obiectului care urmează să fie creat. Atributele sunt numite membri
ai datelor, deoarece dețin date, iar funcțiile care operează asupra acestor date sunt numite funcții membru.
Clasa utilizează conceptul de abstractizare a datelor, astfel încât acestea se numesc tip de date abstracte
(ADT)
Polimorfism: Polimorfismul provine din cuvintele grecești "poli" și "morfism". "poli" înseamnă multe, iar
"morfism" înseamnă formă, adică multe forme. Polimorfismul înseamnă capacitatea de a lua mai mult de o formă.
De exemplu, o operațiune are un comportament diferit în diferite cazuri. Comportamentul depinde de tipul de date
utilizate în operațiune.
Diferite modalități de realizare a polimorfismului în programul C ++:
1) Supraîncărcarea funcției 2) Supraîncărcarea operatorului
#include<iostream>
Utilizarea spațiului de nume
Std; int main() {int a=4; a=a<<2;
cout<<"a="<<a<<endl;
returnare 0;
}
Moștenire: Moștenirea este procesul prin care un obiect poate dobândi proprietățile altuia.
Moștenirea este cel mai promițător concept al OOP, care ajută la realizarea obiectivului de a construi software din
părți reutilizabile, mai degrabă decât codificarea manuală a fiecărui sistem de la zero. Moștenirea nu numai că
acceptă reutilizarea între sisteme, ci și facilitează direct extensibilitatea în cadrul unui sistem. Moștenirea cuplată
cu polimorfismul și legarea dinamică minimizează cantitatea de cod existent care trebuie modificată,
îmbunătățind în același timp un sistem.
Când copilul clasei, moștenește părintele clasei, copilul clasei este denumit clasă derivată (subclasă) și
părintele clasei ca clasă de bază (super clasă). În acest caz, copilul clasei are două părți: o parte derivată și o parte
incrementală. Partea derivată este moștenită de la părintele clasei. Partea incrementală este noul cod scris special
pentru copilul clasei.
Legare dinamică:
Legarea se referă la conectarea apelului de procedură la codul care trebuie executat ca răspuns la apel.
Legare dinamică (sau legare târzie) înseamnă codul asociat cu un anumit apel de procedură necunoscut până la
momentul apelului la momentul rulării.
Transmiterea mesajului:
Un program orientat obiect constă dintr-un set de obiecte care comunică între ele.
Obiectele comunică între ele prin trimiterea și primirea de informații .
Un mesaj pentru un obiect este o cerere de executare a unei proceduri și invocă funcția care este chemată
pentru un obiect și generează rezultat
Beneficiile programării orientate pe obiecte (OOP)

> , ........................... . . , , ,, Reutilizare: În programele OOP, funcțiile și modulele care sunt scrise de un utilizator pot fi
reutilizate de alți utilizatori fără nici o modificare.
Moștenire: Prin aceasta putem elimina codul redundant și putem extinde utilizarea claselor existente.
Ascunderea datelor: Programatorul poate ascunde datele și funcțiile dintr-o clasă de alte clase. Ajută programatorul să
construiască programele sigure.
Complexitatea redusă a unei probleme: Problema dată poate fi privită ca o colecție de obiecte diferite. Fiecare obiect
este responsabil pentru o anumită sarcină. Problema este rezolvată prin interfațarea obiectelor. Această tehnică reduce
complexitatea proiectării programului.
Ușor de întreținut și actualizat: OOP facilitează menținerea și modificarea codului existent, deoarece pot fi create
obiecte noi cu mici diferențe față de cele existente. Complexitatea software-ului poate fi gestionată cu ușurință.
Transmiterea mesajului: Tehnica comunicării mesajelor între obiecte facilitează interfața cu sistemele externe.
Modificabilitate: este ușor să faceți modificări minore în reprezentarea datelor sau procedurile într-un
program OO. Schimbările din interiorul unei clase nu afectează nicio altă parte a unui program, deoarece
singura interfață publică pe care lumea exterioară o are cu o clasă este prin utilizarea metodelor.
STRUCTURA DE BAZĂ A LIMBAJULUI C++: Programul scris în limbajul C ++ urmează această structură
de bază. Secvența secțiunilor ar trebui să fie așa cum sunt în structura de bază. Un program C ar trebui să aibă una
sau mai multe secțiuni, dar trebuie urmată succesiunea secțiunilor.
1. Secțiunea de documentare
2. Secțiunea de legătură
3. Secțiunea de definiții
4. Declarația globală, secțiunea și declarațiile de clasă
5. Definiția funcției membrului
6. Funcția principală
secțiunea main() {
Secțiunea declarație Secțiunea executabilă
1. SECȚIUNEA DE DOCUMENTAȚIE : este prima și este utilizată pentru a documenta utilizarea
logicii sau a motivelor în programul dvs. Poate fi folosit pentru a scrie detaliile obiective, dezvoltator și logice ale
programului. Documentarea se face în limbajul C cu /* și */ . Orice este scris între aceste două se numesc
comentarii.
2. SECȚIUNEA DE LEGĂTURĂ: Această secțiune spune compilatorului să lege anumite
apariții ale cuvintelor cheie sau funcțiilor din programul dvs. la fișierele antet specificate în această
secțiune.
de exemplu, #include<iostream>
folosind spațiul de nume std;
Directiva determină preprocesorul să adauge conținutul fișierului IOSTREAM la program. Acesta conține declarații pentru cout și
cin.
>
COUT este un obiect predefinit care reprezintă fluxul de ieșire standard. Operatorul << este un
operator de inserare, determină afișarea șirului între ghilimele duble pe ecran.
Declarația cin>>n; este o instrucțiune de intrare și determină programul să aștepte ca utilizatorul să introducă un
număr. Numărul tastat este plasat pe variabila "n". Identificatorul cin este un obiect predefinit în C++ care
corespunde fluxului de intrare standard. Operatorul >> este cunoscut sub numele de operator de extracție. Extrage
valoarea de pe tastatură și o atribuie variabilei de valoare din dreapta sa.
3. DEFINIȚIE SECȚIUNE: Este folosit pentru a declara unele constante și a le atribui unele
valoare. de ex. #define MAX 25
Aici #define este o directivă compilator care spune compilatorului ori de câte ori MAX este găsit
în program, înlocuiți-l cu 25.
4. SECȚIUNEA DECLARAȚIA GLOBALĂ: Aici variabilele și sfidările de clasă care sunt utilizate pe
tot parcursul programului (inclusiv funcțiile principale și alte funcții) sunt declarate astfel încât să le facă globale
(adică accesibile tuturor părților programului). O CLASĂ este o colecție de date și funcții care acționează sau
manipulează datele. Componentele de date ale unei clase se numesc membri de date , iar componentele
funcționale ale unei clase se numesc funcții membre
O clasă ca, denumită și un plan sau prototip care definește variabila sau funcțiile comune tuturor
obiectelor de un anumit tip. Este un tip de date definit de utilizator
de ex.
int i; Această declarație se face în afara și înainte de Main()
5. SUBPROGRAM SAU SECȚIUNE FUNCȚIONALĂ : Aceasta are toate subprogramele sau

funcțiile de care are nevoie programul nostru.
Afișaj gol()
{
cout<<"C++ este mai bun decât C";
}
PROGRAMUL SIMPLU "C++":
#include<iostream>
Afișaj gol()
{
cout<<"C++ este mai bun decât C";
}
int main()
{
afișaj()
returnare 0;
}
6. SECȚIUNEA PRINCIPALĂ A FUNCȚIILOR: Îi spune compilatorului de unde să înceapă execuția de

la main()
{
Punctul de la începutul execuției
}
Funcția principală are două secțiuni
1. secțiunea declarației: În aceasta sunt declarate variabilele și tipurile lor de date.
2. Secțiunea executabilă sau secțiunea de instrucțiuni : Aceasta are partea programului care îndeplinește
efectiv sarcina de care avem nevoie.
Spațiu de nume:
Spațiul de nume este utilizat pentru a defini un domeniu care ar putea conține identificatori globali.
Ex:-Domeniul de aplicare al spațiului de nume pentru biblioteca standard C ++.
O clasă, funcții și șabloane sunt declarate în spațiul de nume numit
std folosind spațiul de nume std;-->directivă poate fi utilizată.
Spațiu de nume definit de utilizator:

Sintaxa pentru definirea spațiului de nume este
namespace_name spațiului de nume

{
declarații de variabile.funcții, clase etc.
}
ex:
#include<iostream>
Exemplu de spațiu de nume
{`
int m;
Afișaj vid(Int N)
{
cout<<"în spațiul de nume
} N="<<n<<endl;
}
folosind eșantionul spațiului de nume;

int main()
{
int a=5;
m=100;
afișaj(200);
cout<<"M în spațiul numelui eșantionului:"<<eșantion::m;
returnează 0;}
#include<iostream>
Această directivă determină preprocesorul să adauge conținut de fișier iostream la program. unele versiuni
vechi de C ++ utilizate iostream.h .dacă complier nu acceptă ANSI (American Nation Standard Institute)
C ++, apoi utilizați fișierul antet iostream.h
TIPURI DE DATE:
Un tip de date este utilizat pentru a indica tipul de valoare a datelor stocate într-o variabilă. Toate
compilatoarele C acceptă o varietate de tipuri de date. Această varietate de tipuri de date permite
programatorului să selecteze tipul adecvat nevoilor aplicației, precum și mașinii. ANSI C acceptă
următoarele clase de date:
Tipuri de date principale:

1.Tip de date întreg
2 Tip de date .caracter
3 Tip de date în virgulă mobilă
4 . Tip de date boolean
5.Tipul de date Void
Tip de date întregi: -
Acest tip de date este utilizat pentru a stoca numere întregi. Aceste numere nu conțin partea zecimală. Dimensiunea întregului
depinde de lungimea unei mașini (16 biți sau 32 de biți). Pe o mașină pe 16 biți, intervalul valorilor întregi este - 32.768 până
la +32.767.variabilele întregi sunt declarate prin cuvânt cheie int. C oferă control asupra intervalului de valori întregi și a
spațiului de stocare ocupat de aceste valori prin tipurile de date: int scurt, int, int lung atât în formă semnată, cât și în formă
nesemnată.
Numere întregi semnate: (mașină pe 16 biți):

Un întreg semnat utilizează 1 bit pentru semn și 15 biți pentru magnitudinea numărului
Un întreg semnat utilizează 1 bit pentru semn și 15 biți pentru magnitudinea numărului. (-2 15până la +215-1).
Ex: conectat tx=100;
0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0
, । । .......
Bitul semnat Magnitudine
MSB (cel mai semnificativ bit)
100(10)=00000000001100100(2)
Reprezentarea numărului negativ :
-100(10)=1111111110011100(2)
15 14 13 12 11 10 9 8 7 -1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2

+1*2 +
6 5 4 3 2 1 0
0*2 +0*2 +1*2 +1*2 +1*2 +0*2 +0*2
= -32768+16384+8192+4096+2048+1024+512+256+128+0+0+26+8+4+0+0 =-
100(10)
NOTĂ: Bitul semnat (MSB BIT): 0 reprezintă numere întregi pozitive, 1 reprezintă numere negative
Numere întregi nesemnate: Numerele întregi nesemnate utilizează toți cei 16 biți pentru a stoca magnitudinea.
Stochează numerele nu au niciun calificator de semne și dimensiuni și intervalul de date întregi tip pe 16 biți și
mașină sunt prezentate în tabel:
MEMORIE NECESARĂ
GAMA
SAU DIMENSIUNEA DE FORMATU
TIP DE DATE STOCARE
TURBO C ÎN OCTEȚI GCC/ TURBO C (16 BIȚI) GCC L SPECIER
(16 BIȚI) COMPILATOARE ÎN
(PE 32 DE BIȚI)
LINUX (32 BIȚI)
int scurt -32768
-32768 Până la 32767
sau 2 2 %hd
Până la 32767 (-2 până (-2 până la +2
semnat scurt int la +2 -1) -1)
int scurt
0 până la 65535 (de la 0 0 până la 65535 (de la 0 la
sau la +2 -1) +2 -1)
semnat scurt int 2 2 %hu
-32768 -2.147.843.648 până la

2 4
Până la 32767 (-2 până 2.147.843.647 (de la -2 la
Semnat int sau int %d sau %i
la +2 -1) +2 -1)
nesemnat int 0 până la 65535 0 până la 4.294.967.295 (0 până
2 4 (de la 0 la +2 -1) la 2 -1 ) %u
Long int sau semnat -2.147.843.648 -2.147.843.648 până
Long int până la la
4 4 2,147,843,647 2,147,843,647 %ld
31 31 (de la -2 la +2
(de la -2 la +2
Nesemnat Long Int 0 până la 4.294.967.295 -1)
0 până la 4.294.967.295 (0 până
4 4 (0 până la 2 -1 ) la 2 -1 ) %lu
lung lung int sau -9223372036854775808
semnat lung lung Spre
Nu este
acceptat 8 ------- 9223372036854775807 (- %Ld
Int
263 până la +263-1)
Tip de date caracter: (char)

Un singur caracter poate fi definit ca un tip de date de caractere. Tipul de date de caractere ocupă un octet de
memorie pentru stocarea caracterului. Calificativele semnate sau nesemnate pot fi aplicate tipului de date char.
char este cuvântul cheie folosit pentru declararea variabilelor
Dimensiunea și gama tipului de date de caractere pe mașina pe 16 biți sau 32 de biți pot fi prezentate mai jos
Tip de date MEMORIE NECESARĂ SAU GAMA FORMATUL SPECIER

DIMENSIUNE STOCARE (în
octeți) -128 până la 127(-2 7
char sau char semnat 1 %c
până la 2 -1)
0 până la 256 (0 până la 2
Caracter semnat nesemnat 1 %c
-1)
Tipuri în virgulă mobilă:
Numărul în virgulă mobilă reprezintă un număr real cu o precizie de 6 cifre, ocupă 4 octeți de memorie.
Variabilele în virgulă mobilă sunt declarate prin flotarea cuvântului cheie.
Tipul de date cu virgulă mobilă dublă ocupă 8 octeți de memorie, oferind o precizie de 14 cifre. Acestea sunt, de
asemenea, cunoscute sub numele de numere de precizie dublă. Variabilele sunt declarate prin cuvinte cheie: dublu
, lung, dublu se referă la un tip de date în virgulă mobilă care este adesea mai precis decât dubla precizie.
Dimensiunea și intervalul tipului de date în virgulă mobilă sunt prezentate în tabel:
Tip de date Dimensiune (memorie) Gama Specificator de
(cuvânt cheie) format
Pluti 32 biți (4 octeți) 3.4E-38T03.4E+38 %f
Dublu 64 biți (8 octeți) 1.7E-308 până la I.7E +308 %lf
dublă lungă 80 biți (10 octeți) 3.4E-4932 până la Lf
B Tip de date oolean: - 1.1E+4932
Tipul de date booleene sau logice este un tip de date, având două valori (de obicei notate adevărat și fals),
destinat să reprezinte valorile de adevăr ale logicii și algebrei booleene. Este numit după George Boole, care a
definit pentru prima dată un sistem algebric de logică la mijlocul secolului al 19-lea. Tipul de date boolean este
rezultatul principal al instrucțiunilor condiționale, care permit acțiuni diferite și modifică fluxul de control în
funcție de evaluarea unei condiții booleene specificate de programator la adevărat sau fals.
C99 a adăugat un tip boolean (adevărat/fals) care este definit în antetul <stdbool.h> Variabila booleană este
definită de cuvântul kkey bool ; Ex:
Bool B;
unde b este o variabilă care poate stoca true(1) de fals (0)
Tipul vid
Tipul vid nu are valori. Acesta este de obicei utilizat pentru a specifica tipul de funcții returnate. Tipul funcției despre care se
spune că este nulă atunci când nu returnează nicio valoare funcției de apelare. Acest lucru este, de asemenea, utilizat pentru
declararea indicatorului de uz general numit indicator vid.
Tipuri de date derivate.
Tipurile de date derivate sunt Matrice, indicatorul și referințele sunt exemple pentru tipurile de date
derivate.
Tipuri de date definite de utilizator:
Acestea Tipurile de date definite de utilizator sunt cunoscute sub numele de tipuri de date definite de utilizator.
Ele sunt structura, uniunea, clasa și enumerarea
Jetoane C++
IDENTIFICATORI: Identificatorii sunt numele date diferitelor elemente ale programului, cum ar fi variabilele,
funcțiile și matricele. Acestea sunt nume definite de utilizator constând din secvențe de litere și cifre.
Norme pentru declararea identificatorilor:
Primul caracter trebuie să fie un alfabet sau un caracter de subliniere.
> Acesta trebuie să fie format numai din litere, cifre și caractere de subliniere.
Identificatorii pot avea orice lungime, dar numai primele 31 de caractere sunt semnificative.
> Nu trebuie să conțină spațiu alb sau spațiu gol.
Nu ar trebui să folosim cuvinte cheie ca identificatori.
> Literele mari și minuscule sunt diferite.
Exemplu: ab Ab aB AB sunt tratate diferit
Exemple de identificatori validi:
a, x, n, num, SUM, fapt, grand_total, sum_of_digits, sum1
Exemple de identificatori nevalidi: $amount, ³num', total-general, suma cifrelor, 4num.

$amount : Caracterul special nu este permis
Grand-Total : cratima nu este permisă.
Suma cifrelor : spațiile goale dintre cuvinte nu sunt permise.
4num : nu ar trebui să înceapă cu un număr (primul caracter trebuie să fie o literă sau o subliniere
Notă: Unii compilatori de C recunosc doar primele 8 caractere; Din acest motiv, ei nu pot distinge identificatorii
cu cuvinte cu o lungime mai mare de opt caractere.
Variabile:O locație de memorie numită se numește variabilă.

SAU
Este un identificator utilizat pentru a stoca valoarea unui anumit tip de date în memorie.
Deoarece numele variabilei este identificator, folosim următoarele reguli, care sunt aceleași cu cele ale
identificatorului:
Reguli pentru declararea numelor
variabilelor:
> Primul caracter trebuie să fie un alfabet sau un caracter de subliniere.
Acesta trebuie să fie format numai din litere, cifre și caractere de subliniere.
> Identificatorii pot avea orice lungime, dar numai primele 31 de caractere sunt semnificative.
Nu trebuie să conțină spațiu alb sau spațiu gol.
> Nu ar trebui să folosim cuvinte cheie ca identificatori.

Literele mari și minuscule sunt diferite.
Numele variabilelor trebuie să fie unice în domeniul dat
> Ex:int a,b,a;//este valabil
Int a,b;//este valabil
Declarație variabilă: Declarația variabilei dă numele pentru locația memoriei și dimensiunea acesteia și
Specifică intervalul de valori care poate fi stocat în locația
Sintaxă:
respectivă.
Numele variabilei de tip
date; A 10 2000
Ex:
int a=10; x 2.300000 5000
float x=2,3;
CUVINTE CHEIE:
Există anumite cuvinte, numite cuvinte cheie (cuvinte rezervate) care au un sens predefinit în
limbajul "C++". Aceste cuvinte-cheie trebuie utilizate numai în scopul preconizat și nu ca identificatori.
Tabelul următor prezintă cuvintele cheie standard "C++"
automobil sparge caz Char Const continua
Implicit face dublu altfel Enum extern
pluti pentru Goto dacă Int lung
Înregistrează- restitui scurt Semnat Dimensiunea: static
teStruct comutator tipdef uniune Nesemnate nul
volatil vreme .class prieten nou șterge
acest public privat protejat Inline încerca
arunca prinde șablon
CONSTANTE:
Constantele se referă la valori care nu se modifică în timpul executării unui program.
Constantele pot fi împărțite în două categorii majore:
1.Constante primare:
a)Constante numerice
Constante întregi.
Virgulă mobilă (reală)
Constante. b)Constante de caractere
Constante cu un singur caracter Constante șir
2.constante secundare:
Constante de enumerare.
Constante simbolice.
Matrice, sindicate etc.
Reguli pentru declararea constantelor:
1 . Virgulele și spațiile libere nu sunt permise în cadrul constantei.
2 . Constanta poate fi precedată de semnul minus (-), dacă este necesar.
3 . Valoarea unei constante trebuie să se încadreze în limitele minime ale tipului său de date specificat.
Constante întregi: O constantă întreagă este un număr cu valoare întreagă. Se compune din secvența de cifre.
Constantele întregi pot fi scrise în trei sisteme de numere diferite:
1 . Număr întreg zecimal (în baza 10).
2 . Număr întreg octal (baza 8).
3 . Hexazecimal (în baza 16).
Constanta întreagă zecimală: Se compune dintr-un set de cifre, de la 0 la 9.
Declarație valabilă: 0, 124, -56, + 67, 4567 etc.
Declarație invalidă: 245 USD, 2,34, 34 345, 075.
23.345,00. Este, de asemenea, o declarație invalidă.
Notă: Spațiile încorporate, virgulele, caracterele, simbolurile speciale nu sunt permise între cifre
Acestea pot fi precedate de un semn opțional + sau ±.
Număr întreg octal: Se compune dintr-un set de cifre, de la 0 la 7.

Ex: 037, 0, 0765, 05557 etc. (reprezentare valabilă)
Este o secvență de cifre precedată de 0.
Ex: Reprezentări nevalide
0394: cifra 9 nu este permisă (numai cifrele de la 0 la 7)
235: nu începe cu 0. (Numărul inițial trebuie să fie 0).
Număr întreg hexazecimal: Se compune din setul de cifre, de la 0 la 9 și alfabetele A, B, C, D, E și F. Întregul

hexazecimal este o secvență de cifre precedată de 0x sau 0X. De asemenea, putem folosi de la a la f în loc de A la
F.
Ex: 0X2, 0x9F, 0Xbcd, 0x0, 0x1. (Declarații valide)
Ex: Reprezentări nevalide: 0af, 0xb3g, 0Xgh.
0af: nu începe cu 0x sau 0X.
0xb3g, 0Xgh: caractere ilegale precum g, h. (sunt permise doar de la a la f)
Magnitudinea (valoarea maximă) a unei constante întregi poate varia de la zero la o valoare maximă care variază
de la un computer la altul.
Valorile maxime tipice pentru majoritatea computerelor personale sunt: (mașini pe 16 biți)
Constanta zecimală a numerelor întregi: 32767 (215-1)
Constanta întreagă octală: 077777
Constanta întreagă hexazecimală: 0X7FFF
Notă: Cea mai mare valoare care poate fi stocată depinde de aparat.
Constante în virgulă mobilă sau constante reale: Numerele cu părți fracționate se numesc constante reale.
Acestea sunt numerele cu baza 10 care conține fie o parte zecimală, fie un exponent (sau ambele). Reprezentare:
Aceste numere pot fi reprezentate fie în notație zecimală, fie în notație exponentă (notație științifică).
Notație zecimală: 1234.56, 75.098, 0.0002, -0.00674 (notații valide)
Exponent sau notație științifică:
Forma generală: Mantissa e exponent
Mantissa: Este un număr real exprimat în notație zecimală sau într-o notație întreagă.
Exponent: Este un număr întreg cu semnul opțional plus (+) sau minus (-).
E sau e: Litera care separă mantissa și partea zecimală.
Ex: (Notații valide)
3
1.23456E+3 (1.23456×10 )
1
7.5098 E+1 (7.5098×10 )
-4
2E-4 (2×10 )
Aceste notații exponențiale sunt utile pentru reprezentarea numerelor care sunt fie foarte mari, fie foarte
mic. Ex: 0.00000000987 este echivalent cu 9.87e-9
Constante de caracter:-
Constante cu un singur caracter: Este caracter (sau orice simbol sau cifră) inclus între ghilimele simple.
Ex: "a‟ "1‟ "*‟
Fiecare constantă de caracter are valori întregi cunoscute sub numele de valori ASCII
ASCII:- ASCII înseamnă American Standard Code for Information Interchange. Pronunțat ask-ee, ASCII este un cod pentru
reprezentarea caracterelor englezești ca numere, cu fiecare literă atribuită unui număr de la 0 la 255.Computerele pot înțelege
doar numerele, astfel încât un cod ASCII este reprezentarea numerică a unui caracter, cum ar fi "a" sau "@" sau o
acțiune de un fel. Codurile SCII reprezintă textul din computere, echipamente de comunicații și alte dispozitive care
utilizează text. Majoritatea schemelor moderne de codificare a caracterelor se bazează pe ASCII, deși acceptă multe caractere
suplimentare. Mai jos este tabelul de caractere ASCII, care include descrieri ale primelor 32 de caractere care nu se imprimă.
Constante șir sau șir literal:
Constanta șir este o secvență de zero sau mai multe caractere încadrate de ghilimele duble.
Exemplu:
"MRCET" "12345" "*)(&%"
Secvențe de evadare sau constante de caractere bară oblică inversă
Limbajul C acceptă unele caractere neimprimabile, precum și backslash ( \ ) care pot fi exprimate
ca secvențe de evadare. O secvență de evadare începe întotdeauna cu o bară oblică urmată de unul sau mai multe
personaje speciale.
De exemplu, un nou caracter linie este reprezentat "\n" sau endl
Acestea sunt utilizate în formatarea ecranului de ieșire, adică secvența de evacuare este utilizată în
funcții de ieșire. Unele secvențe de evadare sunt prezentate mai jos:
Secvență de evadare Caracter

"a' Alertă sonoră
"b" Spațiu în spate
"f Formular de alimentare
"n' Linie nouă
"e" Filă orizontală
Filă verticală
ofertă unică
Cotație dublă
«\23 Semnul întrebării
"W Backslash
Nu' Zero
OPERATORI ȘI EXPRESII
Un operator este un simbol care reprezintă o anumită operațiune care poate fi efectuată asupra datelor. Un operand este
obiectul asupra căruia se efectuează o operație.
Prin combinarea operatorilor și operanzilor formăm o expresie. O expresie este o secvență de operanzi și operatori care se
reduce la o singură valoare.
Operatorii C pot fi clasificați ca

1. Operatori aritmetici
2. Operatori relaționali
3. Operatori logici
4. Operatori de atribuire
5. Operatori de creștere sau decrenare
6. Operator condiționat
7. Operatori biți înțelepți
8. operator unar
9. Operatori speciali
10. Operatori suplimentari în c++
1. OPERATORI ARITMETICI: Toți operatorii aritmetici de bază sunt prezenți în operatorul C. rost
+ adăuga
- Scăderea
* înmulțirii
/ divizie
% Diviziunea MODULO (rest)
O operație aritmetică care implică numai operanzi reali (sau operanzi întregi) se numește aritmetică reală
(sau aritmetică întreagă). Dacă o combinație de aritmetică și reală se numește aritmetică în mod mixt.
/*C program pe expresii aritmetice întregi*/
#include<iostraem.h>
vid principal()
{
int a, b;
cout<"Introduceți oricare două numere întregi";
cin>>a>>b;
cout<<"a+b"<< a+b;
cout<<"a-b"<< a-b;
cout<<"a*b"<< a*b;
cout<<"a/b"<< a/b;
cout<<"a%b"<< a%b;
}
IEŞIRE:
a+b=23
a-b=17
a*b=60
a/b=6
a% b=2
2. OPERATORI RELAȚIONALI : Adesea comparăm două cantități și, în funcție de relația lor, luăm anumite
decizii, pentru acea comparație folosim operatori relaționali.
operator rost
> este mai mică decât

> este mai mare decât
> = este mai mică sau egală cu
> = este mai mare sau egală cu
== este egal cu
!= nu este egal cu
/* Program C pe operatori relaționali*/
#include<iostream.h>
vid principal()
{
int a,b;
clrscr();
cout<<"Introduceți valorile a, b:";
cin>>a>>b;
cout<<"a>b"<< a>b;
cout<<"a>=b"<< a>=b;
cout<<"a<b"<< a<b;
cout<<"a<=b"<< a<=b;
cout<<"a==b"<< a==b;
cout<<"a!=b"<< a!=b;
}
IEŞIRE:
Introduceți valorile a, b: 5 9
a>b: 0 //fals
a<b: 1 //adevărat
a>=a: 1 //adevărat
a<=b: 1 //adevărat
a==b: 0 //fals
a!=b: 1 //adevărat
3 . OPERATORI LOGICI:
Date logice: O bucată de date se numește logică dacă transmite ideea de adevărat sau fals. În C++ folosim tipul de date int
pentru a reprezenta date logice. Dacă valoarea datelor este zero, aceasta este considerată falsă. Dacă este diferită de zero (1
sau orice număr întreg, altul decât 0), este considerat adevărat. C++ are trei operatori logici pentru combinarea valorilor
logice și crearea de noi valori logice:
Tabele de adevăr pentru AND (&&) și OR (operatori ID : X Y X&Y X/Y
0 0 0 0
1 operator de masă tor NO I (!): 0 1 0 1
x "X
0 1 1 0 0 1
1 0 1 1 Eu 1
Notă:Programul de mai jos funcționează în compilator care acceptă standardele C99
#include<stdbool.h>
int main()
{
Bool A,B;
/*logic și*/
a=0;b=0;
Cout<<" A&&B "<< A&&B<<endl;
a=0;b=1;
a=1;b=0;
a=1;b=1;
/*logic sau*/
a=0;b=0;
cout<<" a||b "<< a||b<<endl;
a=0;b=1;
a=1;b=0;
a=1;b=1;
/*logic nu*/
a=0;
a=1;
returnare 0;
}
IEȘIRE: 0&&0=0
0&&1=0
1&&0=0
1&&1=1
0||0=0
0||1=1
1||0=1 1||1=1 !0 =1 !1 =0
4 . OPERATOR DE ATRIBUIRE:
Expresia de atribuire evaluează operandul din partea dreaptă a operatorului (=) și plasează valoarea
acestuia în variabila din stânga.
Notă: Operandul stâng dintr-o expresie de atribuire trebuie să fie o singură variabilă.
Există două forme de atribuire:
•Atribuire simplă
•Atribuire compusă
Atribuire simplă:
În expresiile algebrice am găsit aceste expresii.
Ex: a=5; a = a + 1; a=b+1;
Aici, operandul din partea stângă trebuie să fie o variabilă, dar nu o constantă. Variabila din partea stângă
trebuie să poată primi o valoare a expresiei. Dacă operandul din stânga nu poate primi o valoare și îi
atribuim una, primim o eroare de compilare.
Atribuire compusă:
O atribuire compusă este o notație prescurtată pentru o atribuire simplă. Este nevoie ca operandul stâng să
fie repetat ca parte a expresiei corecte. Sintaxă: operator variabil + = valoare
Ex:
A+=1; este echivalent cu A=A+1;
Avantajele utilizării operatorului de atribuire prescurtată:

1. Ceea ce apare în partea stângă nu trebuie repetat și, prin urmare, devine mai ușor de scris.
2. Declarația este mai concisă și mai ușor de citit.
3. Declarația este mai eficientă.
Operatorul ++ adaugă unul la operandul său, unde operatorul - - scade unul din operandul său. Acești operatori sunt
operatori unari și să ia următoarea formă:
Operator Descriere
Atât operatorii de creștere, cât și cei descrescători pot
preceda sau urma operandul. -—a Pre-incrementare
Postfix Increment/Decrement :( a++/a--) A++ Post-incrementare
În incrementul postfix (Decrement) valoarea este —o Pre-decrement
incrementată (descrescătoare) cu unu. Astfel, a ++ are a— Post-declin
același efect ca
Unii dintre operatorii de atribuire prescurtați utilizați în mod obișnuit sunt prezentați în tabelul următor:
Declarație cu operatorul simplu de atribuire Declarație cu operatorul stenograf
a=a+l a-=1
a=a-l a-=l
a=a*l a*=i
a=a/1 A-1
a=a% 1 a%=l
a=a*(n-l) a*=n+1
5.OPERATORI DE CREȘTERE (++) ȘI DE SCĂDERE (--):
a = a + 1; a--are același efect ca a=a-1.
Diferența dintre a++ și a+1 este că, dacă ++ este după operand, creșterea are loc după evaluarea expresiei.
Operandul dintr-o expresie postfix trebuie să fie o variabilă.
Ex1:
int a=5;
B=a++; Aici valoarea lui B este 5. Valoarea lui A este 6.
Ex2:
int x=4; y=x--; Aici valoarea y este 4, valoarea x este 3
Prefix increment/decrément (++a/ --a)
În incrementul prefixului (decrement), efectul are loc înainte ca expresia care conține operatorul să fie evaluată. Este inversul
operației postfix. ++a are același efect ca a=a+1.
--a are același efect ca a=a-1.
Ex: int b=4;
A = ++b;
În acest caz, valoarea lui b ar fi 5, iar A ar fi 5.
Efectele incrementării atât a postfixului, cât și a prefixului sunt aceleași: variabila este incrementată cu
1. Dar se comportă diferit atunci când sunt folosite în expresii așa cum se arată mai sus. Execuția acestor operatori este
rapidă în comparație cu declarația de atribuire echivalentă.
int main()
{
int a=1;
int b = 5;
++a;
--b;
cout<<"b="<<b<<endl;
cout<<"a="<<a++<<endl;
cout<<"b="<<b--<<endl;
cout<<"b="<<b<<endl;
returnare 0;
}
a=2
b=4
a=2
a=3
b=4
b=3
6 . OPERATOR CONDIȚIONAL SAU OPERATOR TERNAR:
Un operator ternar necesită doi operanzi pentru a opera

Sintaxă:
vid principal()
{
int a, b, c;
cout<<"Introduceți valorile a și b:";
cin>>a>>b;
c=a>b?a:b;
cout<<"cel mai mare dintre a și b este "<<c;
}
Introduceți valorile a și
b:1 5
7 . OPERATORI BITWISE : C acceptă operatori speciali cunoscuți sub numele de operatori biți pentru
manipularea datelor la nivel de biți. Ele nu sunt aplicate pentru a pluti sau dublu.
operator rost
& La nivel de biți ȘI
^ Exclusiv pe biți SAU

<< Deplasare stânga
>> Shift dreapta
~ complementul cuiva
Operator AND la nivel de biți (&)
Operatorul AND la nivel de biți este un operator binar, necesită doi operanzi integrali (caracter sau întreg). Face o comparație
la nivel de biți, așa cum se arată mai jos:
Primul bit de operand Al doilea bit de operand Opel și Opel
0 0 0
0 1 0
1 0 0
1 1 1
Operator OR la nivel de biți ( |)

Operatorul OR la nivel de biți este un operator binar, necesită doi operanzi integrali (caracter sau întreg). Face
o comparație la nivel de biți, așa cum se arată mai jos:
Primul bit de operand Al doilea bit de operand Opel | Opel

0 0 0
0 1 1
1 0 1
1 1 1
Operator Bitwise EXCLUSIV OR ( A )

Operatorul bitwise EXCLUSIVE OR este un operator binar, necesită doi operanzi integrali (caracter sau
întreg). Face o comparație la nivel de biți , așa cum se arată mai jos:
Primul bit de operand Al doilea bit de operand Opel A Opel

0 0 0
0 1 1
1 0 1
1 1 0
Operatori de schimb
Operatorii de schimbare mută biții spre dreapta sau spre stânga. Acestea sunt de două tipuri: . •Operator de deplasare la
dreapta pe biți
. •Deplasarea la nivel de biți a operatorului la stânga
Deplasare la dreapta pe biți
Este un operator binar, necesită doi operanzi integrali. Primul operand este valoarea care trebuie deplasată, iar al doilea
operand specifică numărul de biți care trebuie deplasați. Când biții sunt deplasați la dreapta, biții de la capătul cel mai
din dreapta sunt șterși și un zero este inserat la bitul MSB.
vid principal()
{
int x,schimba;
cout<<"Introduceți un număr:");
cin>>x;
cout<<"Intrați acum de multe ori la dreapta schimbați: ";
cin>>shift;
cout<<"Before Right Shift:"<<x;
x=x>>shift;
cout<<"După schimbarea la dreapta:"<<x;
}
Rulare1:
Introduceți un număr:8
Intrați acum de mai multe ori la Shift dreapta:1
Înainte de deplasare la dreapta:8
După schimbarea la dreapta:4
Explicație: Numărul introdus prin tastatură ca intrare este 8, iar numărul binar corespunzător este 1000.
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
15 14 13 12 11 10 9 876543 21 0
După executarea programului, datele de intrare x trebuie deplasate cu 2 biți în partea dreaptă. Răspunsul în formă
binară ar fi următorul:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
15 14 13 12 11 10 9 876543 21 0
Operatorul schimbătorului din dreapta împarte numărul dat la o putere de 2. Dacă schimbăm un număr binar cu
două locuri spre dreapta, împărțim numărul dat la 4 (2').
Deplasarea la nivel de biți a operatorului la stânga
Este un operator binar, necesită doi operanzi integrali. Primul operand este valoarea care trebuie deplasată,
iar al doilea operand specifică numărul de biți care trebuie deplasați la stânga.
Când biții se deplasează spre stânga, biții din capătul cel mai din stânga sunt șterși.
Ex: int a=2;

a«=3;
Shift stânga este opusul operatorului shift dreapta. Operatorul de schimb din stânga înmulțește numărul dat
cu o putere de 2. Dacă deplasăm un număr binar cu trei locuri spre stânga, înmulțim numărul dat cu 8 (2, 3).
Complementul unuia sau Bitwise NU
NOT la nivel de biți, sau complement, este o operație unară care efectuează negarea logică pe fiecare bit.
formând complementul celor din valoarea binară dată. Cifrele care au fost 0 devin I și invers.
Ex: NU 0111 (zecimal 7) = 1000 (zecimal 8)
În C, t operatorul NOT la nivel de biți este (tildă). Tabel de adevăr:
Valoarea expresiei ~Expresie
0 1
1 (diferit de zero) 0
Notă: Operatorul complementului (Bitwise NOT) este diferit de operatorul logic NOT. Folosim acest operator
în procesul de codificare și decodare.
8.5 OPERATORI PECIALI
Acești operatori care nu se încadrează în niciuna dintre clasificările de mai sus sunt ,(virgulă), dimensiunea,
operatorii Pointer (& și *) și operatorii de selecție membri (. și ->). Operatorul virgulă este utilizat pentru a lega
expresii înrudite.
DIMENSIUNEA operatorului:
Returnează numărul de octeți ocupați de operand. Operandul poate fi o variabilă, o constantă (valoare de date)
sau un calificator de tip de date.
Ex: int a. c, f, d;
c=dimensiunea(a); Aici c = 2, dimensiunea operatorului returnează dimensiunea variabilei a care este de tip
int f = sizeof(dublu lung); valoarea f este 10, care este dimensiunea calificatorului dublu lung de tip d =
sizeof(23.345); Valoarea d este 4 , care este dimensiunea valorii constantei flotante
Dimensiunea operatorului este utilizată în mod normal pentru a determina lungimea matricelor și structurilor.
Este, de asemenea, utilizat pentru a aloca spațiu dinamic variabilei s în timpul executării unui program.
Operatorul virgulă (,)
Operatorul virgulă poate fi folosit pentru a lega expresia asociată a expresiilor este evaluată de la stânga la
dreapta și valoarea expresiei combinate.
Ex: a=(x=10, y=20, x+y);
Mai întâi atribuie valoarea 10 lui x, apoi atribuie 20 lui y și fina

Are cea mai mică prioritate dintre toți operatorii.
Folosim operatorul virgulă în declarațiile buclă și declaratic de același tip.
Operator Descriere
4- Unar plus
9.OPERATOR UNAR: operatorul care operează - Unar minus
pe un singur operand se numește operator unar — Creștere
— Decrement
& Adresă
— Cele se completează
Dimensiunea: Dimensiunea
Tip operatorului
Turnarea tipului
Operatori în c++: Toți operatorii de mai sus ai limbajului c sunt valabili și în c ++. Operatorii noi introduși în c+
+ sunt:
Anonim Operator Simbol

1. Operatorul rezoluției domeniului de
2. aplicare către un declarant membru
Indicator ::*
3. Indicator către operatorul membru ->*,->
4. Indicator către operatorul membru .*
5. nou Operator de alocare a memoriei
6. șterge Operator de eliberare a memoriei
7. endl Operator linie de alimentare
8. Setw Operator lățime câmp
9. inserare <<
10. Extracție >>
8.6 cop Operator de rezoluție:

Aplicare:-Vizibilitatea sau disponibilitatea unei variabile într-un program se numește domeniu de aplicare. Există
două tipuri de domeniu de aplicare. i)Domeniul de aplicare local ii)Domeniul de aplicare global
Domeniul de aplicare local: vizibilitatea unei variabile este locală funcției în care este declarată.
Domeniul de aplicare global: vizibilitatea unei variabile pentru toate funcțiile
un operator de rezoluție a domeniului de aplicare în ": :" .
Aceasta este utilizată pentru a accesa variabilele globale dacă aceleași variabile sunt declarate ca locale
și PROGRAMUL GLOBAL1.2: -
int a=5;
vid principal()
{
int a=10;
cout<<"Local a="<<a<<endl;
cout<<"Global a="<<::a<<endl;
}
Producția preconizată:
Local a=10
Global a=5
Membru Operator de dereferențiere: -
1. Indicator către un declarant membru ::*
2. Indicator către operatorul membru ->*,->
Indicator către un declarator membru ::*
Acest operator este utilizat pentru a declara un indicator membrului clasei #include<iostream.h>
Exemplu de clasă
{public:
int x;
};
int main()
{ eșantionul s; obiect
eșantion int ::*p;//pointerul declerare s.*p=10; corect
cout<<s.*p;
} Ieșire:10
2. Indicator către operatorul membru ->*
Exemplu de clasă #include<iostream.h>
{
public:
int x;
Afișaj gol()
{
cout<<"x="<<x<<endl;
}
};
int main()
{
eșantionul s; obiect
eșantion *ptr;
int sample::*f=&sample::x;
s.x=10;
ptr=&s;
cout<<ptr->*f;
ptr->display();
}
3. Indicator către operatorul

membru .*
Exemplu de clasă
{
Public: Int X;
};
int main()
{
eșantion int ::*p;//pointer: declerare
s.*p=10; corect
cout<<s.*p;
}
Manipulatoare:
Manipulatorii sunt operatorii utilizați pentru formatarea datelor care urmează să fie afișate pe ecran. Cele
mai frecvent utilizate manipulatoare sunt endl și setw
endl:-este utilizat în declarația de ieșire și inserează o linie de alimentare. Este similar cu noul caracter linie
("\n")
ex: cout<<"a=2"<<endl;
cout<"name=sunil"<<endl;
Ieşire:
a=2
nume=sunil
SETW:-
Acest manipulator permite o lățime specificată pentru un câmp care urmează să fie tipărit pe ecran
și în mod implicit valoarea tipărită este aliniată corect. Această funcție este disponibilă în fișierul antet
iomanip.h
#include<iomanip.h>
int main()
{
int s=123;
cout<<"s="<<setw(10)<<s ;
}
Ieşire
s = 123
Operatori de inserție (<<) și extracție (>>):
operatorii sunt utilizați cu obiecte de ieșire și de intrare
ex:
cout<<"Enter n";
cin>>n
Declarații de control:Fluxul de execuție a declarațiilor într-un program se numește control. Declarația de

control este o declarație care controlează fluxul de execuție a programului. Declarațiile de control sunt
clasificate în următoarele categorii.
1.Declarații de control secvențiale
2.Declarații privind martorii condiționali
(tip) expresie;
3.Declarații de control necondiționat Sau
1. Secvențial controla Declaraţii:- tip (expresie); Instrucțiuni de control
Declaraţii Asigură acel cel secvențial (sau
declarații) sunt executate în același mod ordinea în care
Ele apar în program. și anume prin Implicit sistem
Execută instrucțiunile în ordinea în Secvenţial
programului.
2.Declarații privind martorii condiționali:Afirmații care sunt executate atunci când o condiție este adevărată.
Aceste afirmații sunt împărțite în trei categorii. sînt
1. Declarații decizionale
2. Schimbați declarația de control a carcasei sau
3.Declarații de control în buclă sau repetări
1 . Declarații de luare a deciziilor: - Aceste declarații sunt utilizate pentru a controla fluxul de execuție a unui
program prin luarea unei decizii în funcție de o condiție, prin urmare sunt numite declarații de luare a deciziilor.
Declarațiile de luare a deciziilor sunt de patru tipuri
1. Simplu dacă
2. Dacă altfel
3.Imbricate dacă mai sunt
4.1 f else scară
1.51 MPLE dacă afirmația: dacă expresia testului este adevărată, atunci dacă instrucțiunea execută afirmații
care urmează imediat dacă
Sintaxă:
If(expresie test)
Lista declarațiilor;
/*cel mai mare dintre cele două numere*/

#include<stdio.h>
int main()
{
int a,b;
cout<<"Introduceți oricare două numere întregi:";
cin>>a>>b;
dacă(a>b)
cout<<"A este mai mare decât B\n A="<<a;
if(b>a)
cout<<"B este mai mare decât A\n A="<<b;
returnare 0;
}
2 . dacă – altă declarație:
Dacă expresia testului este adevărată, bloc de afirmații care urmează dacă sunt executate și dacă
expresia testului este falsă, atunci afirmațiile din blocul else sunt executate dacă (expresie de test)
{
caseta de declarații1;
}
altfel
{
caseta de declarații2;
}
/*cel mai mare dintre cele două numere*/
int main()
{
int a,b;
cout<<"Introduceți oricare două numere întregi:";
cin>>a>>b;
dacă(a>b) cout<<"A este mai mare decât B\n A="<<a;
cout<<"B este mai mare decât A\n A="<<b;

altfe
l returnare 0;
3 . Cuibărirea afirmațiilor dacă-altceva ESTE,de asemenea, posibil să se cuibărească una dacă afirmația în interiorul
alteia. URMEAZĂsă fie luate o serie de decizii.
Dacă –else instrucțiune plasată în interiorul altei afirmații dacă altceva Sintaxă:
If(expresie test) {If(expresie test) {
//statements } else { //statements } }
else
{If(expresie test) { //declarații } altceva
{ //declarații }
} /*cel mai mare dintre cele trei
numere*/
#include<conio.h> int main() { int a,b,c;
cout<<"Introduceți valorile a, b, c:";
cin>>a>>b>>c;
dacă(a>b) {
dacă(a>c) {
cout<<"A ia
cel mai mare
dintre trei
numere\n";
cout"A= "<<a;
} altceva {
cout<<"C ia
cel mai mare
dintre trei numere\n"; cout<<"c= "<<c;
} } altceva {if(b>c) {
cout<<"B ia cel mai mare dintre trei numere\n"; cout<<"B="<<b;
}
altfel
{
cout<<"C ia cel mai mare dintre trei numere\n";
cout<<"c="<<c;
}
}
getch();
returnare 0;
}
4.1 f else scară
IF(Condiția1)
declarație1;
altfel dacă(condiție2)
declarația 2;
altfel dacă(condiție3)
declarația n;
altfel
Declarație implicită.
declarația-x;
Cuibăritul lui dacă-altceva depinde de condițiile cu care avem de-a face.
Condiția este evaluată de sus în jos.dacă o condiție este adevărată, afirmația asociată cu aceasta este executată.
Când toate condițiile devin false, atunci partea finală care conține declarații implicite va fi executată.
vid principal()
{
int per;
cout<<"Intră
procent"; cin>>per;
dacă(per>=80)
cout<<"Securizat
Distincție"<<sfârșit; altfel dacă(per>=60)
cout<<"Securizat mai întâi
Diviziune"<<endl; altfel dacă(per>=50)
cout<<"Securizat
Divizia a doua"<<endl;
altfel dacă(per>=40)
cout<<"Securizat
Diviziune"<<endl; Treile
altfel a
cout<<"Fail"<<endl
INSTRUCȚIUNEA COMUTATORULUI sau SELECTAREA MULTIDIRECȚIONAL :

În plus față de selecția bidirecțională, majoritatea limbajelor de programare oferă un alt concept de selecție cunoscut sub
numele de selecție multidirecțională. Selecția multiway alege între mai multe alternative. C are două moduri diferite de a
implementa selecția multidirecțională: instrucțiunea comutatorului și construcția else-if
Dacă, să presupunem, că avem mai multe opțiuni valide din care să alegem, atunci putem folosi
instrucțiunea de comutare în locul afirmațiilor dacă.
comutator(expresie)
{.
Valoarea cazului-1:
Blocul 1
sparge;
Valoarea cazului-2:
Blocul 2
sparge;
Implicit:
bloc implicit;
/*program pentru simularea unui calculator simplu */ #include<iostream.h>

int main()
{
plutitor a,b;
char opr;
cout<<"Introduceți numărul1 numărul operatorului2 : ";

cin>>a>>oper>>b;
comutator(OPR)
{
cazul "+":
cout<<"Sumă: "<<(a + b)<<endl;
sparge;
cazul '-': cout<<"Diferență: "<<(a -b)<<endl;
sparge;
cazul '*': cout<<"Produs: "<<a * b<<endl;
sparge;
cazul '/': cout<<"Coeficient :"<<(a / b)<<endl;
sparge;
implicit: cout<<"Invalid Operation!"<<endl;
}
returnare 0;
}
Declarații de control în buclă sau repetări:

Un bloc sau un grup de declarații executate în mod repetat până când o anumită condiție este satisfăcută
se numește buclă. Grupul de afirmații incluse în acoladă curbată se numește declarație bloc sau compusă.
Avem două tipuri de structuri de buclă.
Unul în care starea este testată înainte de a intra în blocul de declarații numit control de intrare.
Cealaltă condiție în care este verificată la ieșire numită buclă controlată de ieșire.
Instrucțiunile buclă pot fi împărțite în trei categorii, după cum se arată mai jos
1 .în timp ce instrucțiunea buclă
2 .do în timp ce instrucțiunea buclă
3 .pentru instrucțiunea buclă .for
1 . ÎN TIMP CE DECLARAȚIA:
În timp ce (condiție de testare)

{
corpul buclei
}
Este o buclă controlată de intrare. Condiția este evaluată și, dacă este
adevărată, atunci corpul buclei este executat. După executarea corpului,
starea este evaluată din nou și, dacă este adevărată, corpul este executat din
nou. Acest lucru continuă până când starea testului devine falsă.
C Program pentru a găsi suma a n numere naturale */

int main()
{
int i = 1,suma = 0,n;
cout<<"Enter N"<<end;
cin>>n;
în timp ce(i<=n)
{
sumă = sumă + i;
i = i + 1;
}
cout<<"Suma primului"<<n<"numerele naturale este:"<<suma<<endl; returnare 0;

}
2 . FACEȚI ÎN TIMP CE AFIRMAȚIA:
tlo-while — (Ieșire controlată)

Bucla de timp nu permite executarea corpului dacă starea de testare este falsă. Do while este o buclă
controlată de ieșire și corpul său este executat cel puțin o dată.
face
{
corp
}în timp ce (condiție de testare);
/*c program pentru a găsi suma a n numere naturale */

#include<stdio.h>
int main()
{
int i = 1,suma = 0,n;
cout<<"Enter N"<<endl;
cin>>n
do{
sumă = sumă + i;
i = i + 1;
} în timp ce(i<=n);
cout<<"Suma numerelor naturale first"<< n<<"
este:"<<sumă; returnare 0;
}
Notă: dacă starea testului este falsă. înainte ca bucla să fie executată, atunci În timp ce bucla execută de zero ori unde ca
do - în timp ce execută o singură dată
3.PENTRU BUCLĂ: Este, de asemenea, o buclă de control al intrării care oferă o structură mai
concisă
Sintaxă:
pentru(inițializare; expresie test; increment/descreștere) {
Declaraţii;
}
Pentru că afirmația este împărțită în trei expresii, fiecare este
separată prin punct și virgulă;
1.Expresia de inițiere este utilizată pentru inițializarea
variabilelor
2. Expresia testului este responsabilă de continuarea buclei.
Dacă este adevărat, atunci fluxul de control al programului
intră în buclă și execută blocul de declarații asociate cu
acesta . Dacă expresia testului este falsă, bucla se termină
3.expresia increment/descreștere constă din operator
increment sau descrescător Acest proces continuă până când
condiția testului este îndeplinită.

#include<stdio.h>
int main()
{
int i ,suma = 0,n;
cout<<"Enter N";
cin>>n;
pentru(i=1;i<=n;i++)
{
sumă = sumă + i;
}
cout<<"Suma numerelor naturale first"<<n<<" este:%d"<<sumă; returnare 0;
Bucle imbricate:Scrierea unei instrucțiuni de control buclă într-o altă instrucțiune de control buclă se
numește instrucțiune buclă imbricată
Ex:
pentru(i=1;i<=10;i++)
pentru(j=1;j<=10;j++) cout<<i<<j;
/*program de tipărire a numerelor prime până la un anumit număr*/

#include<stdio.h>
#include<conio.h>
vid principal()
{
int n,i,fapt,j;
clrscr();
cout<<"introduceți numărul:";
cin>>n
{fapt=0;
ACEASTĂ BUCLĂ VA VERIFICA UN NU PENTRU A FI PRIM NU. SAU
NU. pentru(j=1;j<=i;j++)
{
if(i%j==0) fact++;
}
if(fapt==2)
cout<<i<<"\t";
}
getch( );
}
Ieşire:
Introduceți numărul: 5
2 35
Declarații privind martorii necondiționați:

Declarații care transferă controlul de la o parte a programului la o altă parte
necondiționat Diferite declarații necondiționate sunt
1) du-te la
2)pauză
3)Continuare
1.GOTO :- Instrucțiunea GOTO este utilizată pentru ramificarea necondiționată sau transferul execuției
programului către instrucțiunea etichetată.
Declarația goto de a se ramifica necondiționat dintr-un punct în altul al programului. Goto necesită o etichetă
pentru a identifica locul unde urmează să fie făcută ramura. O etichetă este orice nume valid de variabilă și
trebuie urmată de două puncte (;). Eticheta este plasată imediat
înainte de declarația în care urmează să fie transferat controlul. Este prezentată forma generală de goto
sub:
eticheta etichetă:
goto; declarație;
etichetă:
declarație; eticheta
goto;
Salt înainte Salt înapoi
Eticheta: poate fi oriunde în program, fie înainte, fie după eticheta goto; declarație.
Dacă eticheta: este plasată după eticheta goto;, unele afirmații vor fi omise și saltul este cunoscut sub numele
de salt înainte.
Dacă eticheta: este plasată înaintea etichetei goto; Se va forma o buclă, unele declarații vor fi executate în
mod repetat. Un astfel de salt este cunoscut sub numele de salt înapoi.

#include<stdio.h>
int main()
{
int i ,suma = 0,n;
cout<<"Enter N";
cin>>n;
i=1;
L1:
sumă = sumă + i;
I++;
dacă(i<=n) mergeți la L1;
cout<<"Suma primelor numere naturale "<<n<" este"<<sumă; returnare 0;

pauză: - când se întâlnește o declarație de pauză într-o buclă, bucla este imediat ieșită
și programul continuă cu afirmațiile imediat următoare buclei
#include<stdio.h>
int main()
{
int i ,suma = 0,n;
cout<<"Enter N";
cin>>n;
i=1;
L1:
sumă = sumă + i;
I++;
dacă(i>n) rupe;
du-te la L1;
cout<<"Suma primilor"<<n<<"numere naturale este: "<<sumă; returnare 0;

}
Continua:Este folosit pentru a continua iterația declarației buclă sărind peste declarații după
continuarea declarației. Aceasta determină controlul să meargă direct la starea de testare și
apoi să continue bucla.
/*c program pentru a găsi suma a n numere pozitive citite de la tastatură*/
#include<stdio.h>
int main()
{
int i ,suma = 0,n,număr;
cout<<Enter N";
cin>>n;
{
cout<<"Introduceți un număr:";
numărul >> cin;
dacă(număr<0) continuă;
sumă = sumă + număr;
}
cout<<"Suma numerelor<<n<<" este:"<<sumă;
returnare 0;
}
UNITATEA -2
Funcții, clase și obiecte:

Introducerea claselor, definirea clasei, definirea membrilor, obiecte, controlul accesului,
Class Scope, Scope Resolution Operator, Inline Functions, Memory Allocation for Objects, Static Data
Members, Static Member Functions, Arrays of Objects, Objects as Function Arguments, Friend Functions.
Introducerea clasei:
O abordare de programare orientată pe obiecte este o colecție de obiecte și fiecare obiect constă din
structuri și proceduri de date corespunzătoare. Programul este reutilizabil și mai ușor de întreținut.
Aspectul important în oop este o clasă care are o sintaxă similară cu cea a structurii.
clasă: Este o colecție de date și funcții ale membrilor care manipulează datele. Componentele de date ale clasei
se numesc membri de date, iar funcțiile care manipulează datele se numesc funcții membre.
Poate fi numit și plan sau prototip care definește variabilele și funcțiile comune tuturor obiectelor de un
anumit tip. Este, de asemenea, cunoscut sub numele de tip de date definit de utilizator sau ADT (tip de date
abstracte) O clasă este declarată de clasa cuvântului cheie.
Sintaxă:-
clasa class_name {
Specificator acces :
Declarații variabile;
Specificator acces :
declarații de funcții;
};
Control acces:
Specificatorul de acces sau modificatorii de acces sunt etichetele care specifică tipul de acces acordat
membrilor unei clase. Acestea sunt utilizate pentru ascunderea datelor. Acestea sunt, de asemenea, numite
moduri de vizibilitate. Există trei tipuri de specificatori de acces
1. Privat
2. Public
3. Protejat
1. Privat:
Dacă membrii datelor sunt declarați ca acces privat, atunci nu pot fi accesați din alte funcții din afara
clasei. Acesta poate fi accesat numai prin funcțiile declarate în cadrul clasei. Este declarat prin cuvântul cheie
"privat‟ .
2. Public:
Dacă membrii datelor sunt declarați acces public, atunci aceștia pot fi accesați din alte funcții din afara
clasei. Este declarat prin cuvântul-cheie "public".
3. Protejat: Nivelul de acces al declarației protejate se situează între public și privat. Acest specificator de
acces este utilizat în momentul moștenirii
Notă:-
Dacă nu este specificat niciun specificator de acces, atunci acesta este tratat implicit ca privat
Specificatorul implicit de acces al structurii este public în cazul în care cel al unei clase este "privat"
Exemplu:
Elev de clasă
{
privat : int roll;
nume de caractere[30];
public:
nul get_data()
{
cout<<"Introduceți numărul rolei și numele": cin>>roll>>name;
}
nul put_data()
{
cout<<"Numărul rolei:"<<roll<<endl;
cout<<"Nume :"<<nume<<endl;
}
};
Obiect:-Instanța unei clase se numește obiect.
Sintaxă:
class_name object_name;
Ex:
elevii s;
Accesarea operatorului members:-d ot este utilizată pentru a accesa membrii clasei
Object-name.function-name(argumente reale);
Ex:
s.get_data();
s.put_data();
Notă:
1 . Dacă specificatorul de acces nu este specificat în clasă, specificatorul de acces implicit este privat
2 . Toate funcțiile membrilor trebuie declarate publice, dacă nu sunt accesibile în afara clasei. Obiect:
Instanța unei clase se numește obiect.
Sintaxă:
Class_name numele obiectului;
Exemplu:
elevii s;
În exemplul de mai sus s este obiectul. Este o entitate în timp real care poate fi utilizată
Scrieți un program pentru a citi datele unui student
#include<iostream>
Elev de clasă
{
privat:
int rolă;
numele caracterelor[20];
public:
void getdata()
{cout<<"Introduceți numărul rolei:";
cin>>rolă;
cout<<"Introduceți numele:";
cin>>nume;
}
vid putdata()
{cout<<"Roll no:"<<roll<<endl;
cout<<Nume:"<<nume<<endl;
}
};
int main()
{
elevii s;
s.getdata();
s.putdata();
returm 0;
}
Domeniu de aplicare Operator rezoluție:
Aplicare:-Vizibilitatea sau disponibilitatea unei variabile într-un program se numește domeniu
de aplicare. Există două tipuri de domeniu de aplicare. i)Domeniul de aplicare local
ii)Domeniul de aplicare global
Domeniul de aplicare local: vizibilitatea unei variabile este locală funcției în care este
declarată.
Domeniu de aplicare global: vizibilitatea unei variabile pentru toate funcțiile unui program
Operator de rezoluție a domeniului de aplicare în "::" .
Aceasta este utilizată pentru a accesa variabilele globale dacă aceleași variabile sunt declarate
ca locale și globale
int a=5;
vid principal()
{
int a=1;
cout<<"Local a="<<a<<endl;
cout<<"Global a="<<::a<<endl;
}
Domeniul de aplicare al clasei:

Operatorul rezoluției domeniului de aplicare (::) este folosit pentru a defini o funcție în afara unei clase.
#include <iostream>
Exemplu de clasă
{
public:
ieșire vidă(); Declarație de funcție
};
definirea funcției în afara
Eșantion de vid de clasă::output() {
cout << "Funcție definită în afara clasei.\n";
};
int main() {
eșantion obj;
obj.ieșire();
returnare 0;
}
Rezultatul programului:
Funcție definită în afara clasei.
Scrieți un program pentru a găsi zona dreptunghiului

dreptunghi de clasă
{
int L,B;
public:
nul get_data();
zona nulă();
};
Dreptunghi vid::get_data()
{
cout<<"Introduceți lungimea dreptunghiului";
cin>>L;
cout<<"Introduceți lățimea dreptunghiului";
cin>>B;
}
int dreptunghi::area()
{
returnați L * B;
}
int main()
{
dreptunghiul r;
r.get_data();
cout<<"Aria dreptunghiului este"<<r.area();
returnare 0;
}
FUNCȚII INLINE:
Definiție:
O funcție inline este o funcție care este extinsă în linie atunci când este invocată. Extinderea în linie face
ca un program să ruleze mai rapid, deoarece cheltuielile generale ale apelului și returnării unei funcții
sunt eliminate. Acesta este definit prin utilizarea cuvântului cheie " inline"
Necesitatea funcției inline:

> • ,, , Unul dintre obiectivele utilizării funcțiilor într-un program este de a economisi spațiu de memorie, care devine apreciabil
atunci când o funcție este probabil să fie apelată de mai multe ori.
De fiecare dată când o funcție este apelată, este nevoie de mult timp suplimentar în executarea unei serii de
instrucțiuni pentru sarcini precum saltul la funcție, salvarea registrelor, împingerea argumentelor în stivă și
revenirea la funcția de apelare.
>
Atunci când o funcție este mică, un procent substanțial din timpul de execuție poate fi cheltuit în astfel de
cheltuieli generale.
O soluție la această problemă este utilizarea definițiilor macrocomenzilor cunoscute sub numele de
macrocomenzi. Macrocomenzile preprocesorului sunt populare în C. Dezavantajul major al
macrocomenzilor este că acestea nu sunt cu adevărat funcții și, prin urmare, verificarea obișnuită a erorilor nu
apare în timpul compilării.
C++ are o soluție diferită la această problemă. Pentru a elimina costul apelurilor către funcții mici, C ++
propune o nouă caracteristică numită funcție inline.
Formular general:
Antet de funcție în linie
{
funcția corpului;
Exemplu:
Mul plutitor în linie (Float X, Float Y)
{
întoarcere (x*y);
}
Div dublu în linie (dublu P, dublu Q)
{
retur (p/q);
}
int main()
{
float a=12.345;
float b = 9,82;
cout<<mul(a,b);
cout<<div(a,b);
returnare 0;
}
Proprietățile funcției inline:
1. Funcția inline trimite cerere, dar nu o comandă către compilator
2. Compilați serviciul meu sau ignorați cererea
3. Dacă funcția are prea multe linii de cod sau dacă are o logică complicată, atunci este executată ca
funcție normală
Situații în care inline nu funcționează:
>
O funcție care returnează valoare , dacă conține buclă de comutare sau ambele, atunci este tratată ca funcție normală.
>
Dacă o funcție nu returnează nicio valoare și conține o declarație returnată, atunci este tratată ca funcție normală
>
Dacă funcția conține variabile statice, atunci este executată ca funcție normală
>
Dacă funcția inline este declarată ca funcție recursivă, atunci este executată ca funcție normală.
Alocarea memoriei pentru obiecte: Memoria pentru obiecte este alocată atunci când acestea sunt declarate,
dar nu și atunci când clasa este definită. Toate obiectele dintr-o clasă dată utilizează aceleași funcții membre.
Funcțiile membre sunt create și plasate în memorie o singură dată atunci când sunt definite în definiția clasei
MEMBRII STATICI AI CLASEI
Membrii datelor statice

Funcții statice ale membrilor
Membrii datelor statice:
Un membru de date al unei clase poate fi calificat ca static. O variabilă statică are anumite caracteristici
speciale:
Este inițializat la zero atunci când este creat primul obiect al clasei sale. Nu este permisă nicio altă
inițializare.
Doar o copie a acelui membru este creată pentru întreaga clasă și este împărtășită de toate obiectele acelei clase,
indiferent câte obiecte sunt create.
Este vizibil numai în cadrul clasei, dar durata sa de viață este întregul program.
Membrul datelor statice este definit prin cuvântul cheie "static‟
Sintaxă:
Tip de date numele clasei::static_variable Nume;
Ex: int item::count;
#include<conio.h>
Element de clasă
{
Număr de inte statice;
numărul int;
public:
void getdata(int a) {
număr=a; număr++;
}
void getcount()
{
cout<<"count is"<<count;
}
};
int item::count;//declerare
int main()
{
lit. a, b, c;
a.getcount();
b.getcount();
c.getcount();
a.getdata(100);
b.getdata(200);
c.getdata(300);
cout<<"După citirea datelor";
a.getcount();
b.getcount();
c.getcount();
returnare 0;
}
Ieşire:
numărul este 0
numărul este 0
numărul este 0
După citirea datelor
numărul este 3
numărul este 3
numărul este 3
Funcții statice ale membrilor
La fel ca variabila statică a membrilor, putem avea și funcții statice ale membrilor. O funcție membru care
este declarată statică are următoarele proprietăți:
O funcție statică poate avea acces numai la alți membri statici (funcții sau variabile) declarați în aceeași
clasă.
O funcție membru static trebuie apelată folosind numele clasei (în locul obiectelor sale) după cum
urmează: class-name :: function-name;
Test de clasă
{
Codul INT;
Număr de inte statice;
public:
Cod set vid()
{
cod = + + număr;
}
Cod spectacol nul()
{
cout<<"număr obiect"<<cod;
}
Static void showcount()
{
cout<<"count"<<count;
}
};
testul int::count;
int main()
{
încercarea t1,t2;
t1.codul SET();
t2.cod set();
test::showcount();
încercarea t3;
t3.codul SET();
test::showcount();
t1.showcode();
t2.showcode();
t3.showcode();
returnare 0;
}
Ieşire:
Contele 2
Condacul 3
numărul obiectului 1
Matrice de obiecte: Matricele de variabile de tip "clasă" sunt cunoscute sub numele de "matrice de obiecte". O
serie de obiecte este stocată în interiorul memoriei în același mod ca într-o matrice obișnuită.
Sintaxă:
Clasa class_name
{
privat:
data_type membri;
public:
data_type membri; funcțiile membrilor;
};
Matrice de obiecte:
Class_name object_name[dimensiune];
Unde dimensiune este dimensiunea matricei
Ex:
Clasa mea obj[10];
Scrieți un program pentru a inițializa matricea de obiecte și a le imprima
#include<iostream>
clasa MyClass
{
int a;
public:
set vid(int x)
{
a=x;
}
int get()
{
returnarea a;
}
};
int main()
{
MyClass obj[5];
pentru(int i=0;i<5;i++)
obj[i].set(i);
pentru(int i=0;i<5;i++)
cout<<"obj["<<i<<"].get():"<<obj[i].get()<<endl;
}
Ieşire:
obj[0].get():0
obj[1].get():1
obj[2].get():2
obj[3].get():3
obj[4].get():4
Obiecte ca argumente funcționale: Obiectele pot fi folosite ca argumente pentru

funcții Acest lucru se poate face în trei moduri:
a. Pass-by-value sau call by value
b. Adresă de trecere sau apelare după adresă
c. Trimitere cu referință sau cerere cu referință
a.Pass-by-value – O copie a obiectului (obiect real) este trimisă funcției și atribuită obiectului funcției numite
(obiect formal). Atât copiile reale, cât și cele formale ale obiectelor sunt stocate în diferite locații de memorie.
Prin urmare, modificările făcute în obiectul formal nu sunt reflectate în obiectul real. Scrieți un program pentru
a schimba valorile a două obiecte
Scrieți un program pentru a schimba valorile a două obiecte
eșantion de clasă2;
eșantion de clasă1
{
int a;
public:
vid getdata(int x);
afișare vidă prieten(eșantion1 x,eșantion2 y);
prieten void swap (eșantion1 x,eșantion2 y);
};
Void Sample1::GetData(Int X)
{
a=x;
}
Exemplu de clasă2
{
int b;
public:
vid getdata(int x);
prieten void swap (eșantion1 x,eșantion2 y);

};
{
b=x;
}
Void Display (eșantion1 x,eșantion2 y)
{
cout<<"Datele din obiectul 1 sunt"<<endl;
cout<<"a="<<x.a<<endl;
cout<<"b="<<y.b<<endl;
}
Void swap (eșantion1 x, eșantion2 y)
{
int t;
t=x.a;
x.a=y.b;
y.b=t;
}
int main()
{
eșantion1 OBJ1;
eșantion2 OBJ2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Înainte de schimbul de date între două obiecte\n
"; afișaj (obj1,obj2);
swap(OBJ1,OBJ2);
cout<<"după schimbul de date între două obiecte\n ";
afișaj (obj1,obj2);
}
Înainte de schimbul de date între două obiecte
Datele din obiectul 1 sunt a = 5
Datele din obiectul 2 sunt b = 15
după schimbul de date între două obiecte
b. Adresă de trecere: Adresa obiectului este trimisă ca argument pentru a funcționa.
Aici ampersand(&) este folosit ca operator de adresă și săgeata (->) este utilizată ca operator de referențiere.
Dacă se face vreo modificare argumentelor formale, atunci există o modificare a argumentelor reale, scrieți un
program pentru a schimba valorile a două obiecte;
{
int a;
public:
vid getdata(int x);
prieten void swap(sample1 *x,sample2 *y);
};
{
a=x;
}
Exemplu de clasă2
{
int b;
public:
vid getdata(int x);
prieten void swap(sample1 *x,sample2 *y);
};
{
b=x;
}
{
}
Void swap(eșantion1 *x,eșantion2 *y)
{
int t;
t=x->a;
x->a=y->b;
y->b=t;
}
int main()
{
eșantion1 OBJ1;
eșantion2 OBJ2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Înainte de schimbul de date între două obiecte\n ";
swap(&obj1,&obj2);
}
Datele din obiectul 2 sunt b = 5 c.Pass-by-reference:O referință a obiectului este trimisă ca argument pentru a
funcționa.
Referința la o variabilă oferă un nume alternativ pentru variabila definită anterior. Dacă se aduce vreo
modificare variabilei de referință, atunci există o modificare a variabilei inițiale.
O variabilă de referință poate fi declarată după cum urmează:
Tip de date & variabilă de referință =variabilă;
int x=5;
int &y=x;
Ex:
Scrieți un program pentru a găsi suma a n numere naturale folosind variabila de referință #include<iostream.h>
int main()
{
int i=0;
int &j=i;
int s=0;
int n;
cout<<"Enter n:";
cin>>n;
în timp ce(j<=n)
{
s=s+i;
I++;
}
cout<<"sum="<<s<<endl;
}
Ieşire:
Introduceți n:10
sumă=55
Scrieți un program pentru a schimba valorile a două obiecte
{
int a;
public:
vid getdata(int x);
prieten void swap (eșantion1 &x,eșantion2 & y);
};
{
a=x;
}
Exemplu de clasă2
{
int b;
public:
vid getdata(int x);
prieten void swap (eșantion1 &x,eșantion2 & y);
};
{
b=x;
}
{
}
Void swap (eșantion1 &x, eșantion2 și y)
{
int t;
t=x.a;
x.a=y.b;
y.b=t;
}
int main()
{
eșantion1 OBJ1;
eșantion2 OBJ2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Înainte de schimbul de date între două obiecte\n ";
swap(OBJ1,OBJ2);
}
Ieşire:
FUNCȚIILE PRIETENILOR:Membrii privați nu pot fi accesați din afara clasei. adică.... O funcție non-
membră nu poate avea acces la datele private ale unei clase. În C++, o funcție non-membru poate accesa privat,
făcând funcția prietenoasă pentru o clasă.
Definiție:
O funcție prieten este o funcție care este declarată în cadrul unei clase și este definită în afara clasei. Nu
este nevoie de niciun operator de rezoluție a domeniului de aplicare pentru definirea . Poate accesa membrii
privați ai unei clase. Se declară prin utilizarea cuvântului cheie " prieten"
Ex:
Exemplu de clasă
{ int x,y; public: eșantion (int a,int b);
prieten int sum(eșantion s);
};
Eșantion::Eșantion(int a,int b)
{ x=a;y=b;
}
int sum(eșantioane s)
{ int sum;
sum=s.x+s.y;
returnare 0;
}
vid principal()
{
Eșantion obj(2,3);
int res=sum(obj);
cout<< "sum="<<res<<endl;
}
O funcție de prieten posedă anumite caracteristici speciale:
Nu este în sfera clasei căreia i-a fost declarat prieten.
Deoarece nu face parte din domeniul de aplicare al clasei, nu poate fi numit folosind obiectul acelei clase. Poate fi invocată ca o
funcție normală fără ajutorul vreunui obiect.
Spre deosebire de funcțiile membrilor, nu poate accesa direct numele membrilor și trebuie să utilizeze un nume de obiect și un
operator de membru dot cu fiecare nume de membru.
Acesta poate fi declarat fie în partea publică, fie în cea privată a unei clase, fără a-i afecta semnificația.
De obicei, are obiectele ca argumente.
Exemplu de clasă #include<iostream.h>
{
int a;
int b;
public:
valoare setată nulă()
{
a=25;
b=40;
}
media plutitorului prietenului (eșantionul s);
};
Media flotorului (eșantionul S)
{
retur float(s.a+s.b)/2.0;
}
int main()
{
proba X;
X.setvalue();
cout<<"Valoarea medie="<<medie(X);
returnare 0;
}
Scrieți un program pentru a găsi maximum două numere folosind funcția Friend pentru două clase
diferite #include<iostream>
{
int x;
public:
proba1(int a);
prieten vid max(eșantion1 s1,eșantion2 s2)
};
eșantion1::eșantion1(int a)
{
x=a;
}
Exemplu de clasă2
{
int y;
public:
proba2(int b);
prieten vid max(eșantion1 s1,eșantion2 s2)
};
Eșantion2::eșantion2(int b)
{
y = b;
}
void max(eșantion1 s1,eșantion2 s2)
{
Dacă(s1.x>s2.y)
cout<<"Data member in Object of class sample1 is large "<<endl;
altfel
cout<<"Data member in Object of class sample2 is large "<<endl;
}
vid principal()
{
eșantion1 OBJ1(3);
eșantion2 OBJ2(5);
max(OBJ1,OBJ2);
}
Scrieți un program pentru a adăuga numere complexe folosind funcția prieten
#include<iostream>
Complex de clasă
{
float real,img;
public:
complex();
complex (float x, float y)
Prieten complex add_complex(complex C1,complex C2);
};
complex::complex()
{
real = img = 0;
}
complex::complex(float x,float y)
{
real=x;img=y;
}
complex add_complex(complex C1,complex C2)
{
complexul t;
t.real=c1.real+c2.real;
t.img=c1.img+c2.img;
returnarea t;
}
Complex vid::d isplay ()
{
if(img<0)
{img=-img;
cout<<real<<"-i"<<img<<endl
} else { cout<<real<<"+i"<<img<<endl
}
}
int main()
{
complexul OBJ1(2,3);
complexul OBJ2(-4,-6);
complex obj3=add_compex(obj1,obj2);
obj3.display();
returnare 0;
}
Clasa prietenilor:O clasă poate fi, de asemenea, declarată a fi prietena unei alte clase. Când creăm o clasă
de prieteni, atunci toate funcțiile membrilor clasei de prieteni devin, de asemenea, prietenii celeilalte clase.
Acest lucru necesită condiția ca prietenul care devine clasă să fie mai întâi declarat sau definit (declarație
înainte).
#include <iostream.h>
Clasa sample_1
{
Clasa de prieteni sample_2;//Clasa de prieteni declaranți
int a,b;
public:
nul getdata_1()
{
cout<<"Introduceți valorile A și B în clasa sample_1";
cin>>a>>b;
}
nul display_1()
{
cout<<"A="<<a<<endl;
cout<<"B="<<b<<endl;
}
};
Clasa sample_2
{
int c,d,sum;
sample_1 obj1;
public:
nul getdata_2()
{
obj1.getdata_1();
cout<<"Introduceți valorile C & D în clasa sample_2"; cin>>c>>d;
}
nul sum_2()
{
sum=obj1.a+obj1.b+c+d;
}
nul display_2()
{
cout<<"A="<<obj1.a<<endl;
cout<<"B="<<obj1.b<<endl;
cout<<"C="<<c<<endl;
cout<<"D="<<d<<endl;
cout<<"SUM="<<sumă<<sfârșit;
}
};
int main()
{
sample_1 s1;
s1.getdata_1();
s1.display_1();
sample_2 s2;
s2.getdata_2();
s2.sum_2();
s2.display_2();
}
Introduceți valorile A și B în clasa sample_1:1 2

A=1
B=2
Introduceți valorile A și B în clasa sample_1:1, 2, 3, 4
Introduceți valorile C & D în clasa sample_2:A=1
B=2
C=3
D=4
SUM=10
UNITATEA -3
Constructori, distrugători, moștenitori:

Introducere în constructori, constructori impliciti, constructori parametrizați, constructori de copiere mai
mulți constructori într-o clasă, distrugători.
Moștenire:Introducere în moștenire, Definirea claselor derivate, Moștenire unică, Moștenire multiplă,
Moștenire pe mai multe niveluri, Moștenire ierarhică, Moștenire hibridă.
D
Introducere în constructori: C++ oferă o funcție specială de membru numită constructor,
care permite unui obiect să se inițializeze atunci când este creat.
Definiție:- Un constructor este o funcție specială a cărei sarcină este de a inițializa obiectele clasei sale.
Este special deoarece numele său este același nume cu numele clasei. Constructorul este invocat ori de
câte ori este creat un obiect din clasa asociată. Se numește constructor deoarece construiește valorile
datelor membrilor clasei.
Un constructor este declarat și definit după cum urmează:
întreg obj1; => nu numai că creează obiectul obj1, ci și inițializează membrii săi de date m și n la zero. Nu este
nevoie să scrieți nicio declarație pentru a invoca funcția constructor.
CARACTERISTICILE
CONSTRUCTORULUI
> Ele sunt invocate automat atunci când obiectele sunt create.
> Nu au tip de întoarcere, nici măcar nule.
Ele nu pot fi moștenite, deși o clasă derivată poate numi constructorul clasei de
bază.
> Ca și alte funcții c ++, ele pot avea argumente implicite.
> Constructorii nu pot fi virtuali.
>
Ei fac "apeluri implicite" către operatori noi și șterg atunci când este necesară alocarea memoriei.
Constructorii sunt de 3 tipuri:
1. Constructor implicit
2. Constructor parametrizat
3. Constructor de copiere
1 . Constructor implicit: Un constructor care nu acceptă parametri se numește constructor implicit.
Element de clasă #include<conio.h>
{
int m,n;
public:
articol()
{
m=10;
n=20;
}
void put();
};
element nul::p ut() {
cout<<m<<n;
}
vid principal()
{
punctul t;
t.put();
getch();
}
2 . Constructori parametrizați:-Constructorii care iau parametri se numesc constructori
parametrizați.
Element de clasă
{
int m,n;
public:
articol(int x, int y)
{
m = x;
n=y;
}
};
Atunci când un constructor a fost parametrizat, declarația de declarare a obiectului, cum ar fi
punctul t; este posibil să nu funcționeze. Trebuie să transmitem valorile inițiale ca argumente funcției
constructor atunci când este declarat un obiect. Acest lucru se poate face în 2 moduri: articol t = articol
(10,20); apel explicit
poziția T(10,20); Apel implicit

Exemplu:
#include<conio.h>
Element de clasă
{
int m,n;
public:
articol(int x,int y)
{
m = x;
n=y;
}
void put();
};
element nul::p ut()
{
cout<<m<<n;
}
vid principal()
{
punctul T1(10,20);
punctul t2=articol(20,30);
t1.put();
t2.put();
getch();
}
3 . Copy Builder: Un constructor de copii este utilizat pentru a declara și inițializa un obiect
dintr-un alt obiect.
Exemplu:
punctul T2(T1);
sau
articol t2=t1;
1. Procesul de inițializare printr-un constructor de copii este cunoscut sub numele de inițializare copie.
2. t2=t1 nu va invoca copy constructor. T1 și T2 sunt obiecte, atribuie valorile T1 până la T2.
3. Un constructor de copii face referire la un obiect din aceeași clasă ca și el însuși
un argument. #include<iostream.h>
Exemplu de clasă
{
int n;
public:
eșantion()
{
n=0;
}
Eșantion(Int A)
{
n = a;
}
eșantion (eșantion &x)
{
n=x.n;
}
Afișaj gol()
{
cout<<n;
}
};
vid principal()
{
proba A(100);
proba B(A);
proba C = A;
proba D;
D=A;
A.afișaj();
B.afișaj();
C.afișaj();
D.afișaj();
}
Ieșire: 100 100 100 100
Mai mulți constructori într-o clasă: Mai mulți constructori pot fi declarați într-o clasă. Pot exista
oricâți constructori într-o clasă.
Complex de clasă
{
float real,img;
public:
complex()//constructor implicit
{
real = img = 0;
}
complex(float r)//constructor parametrizat cu un singur parametru

{
real=img=r;
}
complex(float r,float i) //constructor parametrizat cu doi parametri

{
real=r;img=i;
}
complex(complex&c)//copiator constructor
{
real = c.real;
img=c.img;
}
sumă complexă(complex c) {
complexul t;
t.real=real+c.real;
t.img=img+c.img;
returnarea t;
}
spectacol nul()
{
Dacă(img>0)
cout<<real<<"+i"<<img<<endl;
altfel
{
img=-img;
cout<<real<<"-i"<<img<<endl;
}
};
vid principal()
{
complexul C1(1,2);
complexul C2(2,2);
Compex C3;
c3=c1.sum(c3);
c3.spectacol();
DESTRUCTORI:Un distrugător, este folosit pentru a distruge obiectele care au fost create de un constructor.
Ca un constructor, destructorul este o funcție membră al cărei nume este același cu numele clasei, dar
este precedat de o tildă.
De exemplu: ~item() { }
1. Un destructor nu acceptă niciodată niciun argument și nici nu returnează vreo valoare.
2. Acesta va fi invocat implicit de compilator la ieșirea din program pentru a curăța spațiul de stocare care
nu mai este accesibil.
3. Este o bună practică să declarați distrugători într-un program, deoarece eliberează spațiu de memorie
pentru utilizare ulterioară.
#include<iostream>
Marcaje de clasă
{
public:
int matematică;
int știință;
Constructor
Marks() {
cout << "Inside Constructor"<<endl;
cout << "C++ Object created"<<endl;
}
Destructor
~Marks() {
cout << "Inside Destructor"<<endl;
cout << "C++ Obiect distrus"<<endl;
}
};
int main( )
{
Marcaje m1;
Marcaje m2;
returnare 0;
}
Ieşire:
În interiorul Constructor
C++ Obiect creat
În interiorul Constructor
C++ Obiect creat
În interiorul Destructor
C++ Obiect distrus
În interiorul Destructor
C++ Obiect distrus
MOȘTENIRE: . Mecanismul derivării unei noi clase dintr-una veche se numește moștenire sau derivare.
Vechea clasă este denumită clasă de bază , iar cea nouă se numește clasă derivată sau subclasă. Clasa derivată
moștenește unele sau toate trăsăturile din clasa de bază.
O clasă poate moșteni, de asemenea, proprietăți de la mai multe clase sau de la mai multe niveluri.
Reutilizarea este o caracteristică importantă a OOP
O clasă derivată poate fi definită prin specificarea relației sale cu clasa de bază, pe lângă propriile detalii.
class derived-class-name : vizibilitate-mode base-class-name {
Două puncte indică faptul că numele clasei derivate este derivat din numele clasei de bază. Modul de
vizibilitate este opțional și, dacă există, poate fi privat, protejat sau public. Valoarea implicită este privată.
Modul vizibilitate specifică dacă caracteristicile clasei de bază sunt derivate din surse private sau publice.
clasa ABC : privat XYZ { Derivare privată

membri ai ABC;
};
clasa ABC:public XYZ
{
membri ai ABC;
};
Derivare publică
clasa ABC:protejat XYZ { // derivare protejatămembri ai ABC;

};
clasa ABC:XYZ Privat în mod implicit
{
membri ai ABC;
};
Atunci când o clasă de bază este moștenită în mod privat de o clasă derivată, membrii publici ai clasei
de bază pot fi accesați numai de funcțiile membre ale clasei derivate.Memburile private ale clasei de bază sunt
inaccesibile obiectelor clasei derivate
Atunci când o clasă de bază este protejată moștenită de o clasă derivată, membrii publici ai clasei de
bază pot fi accesați numai de funcțiile membre ale clasei derivate. Dacă membrii privați ai clasei de bază
urmează să fie moșteniți clasei derivate, atunci declarați-i ca fiind protejați
Atunci când clasa de bază este moștenită public, membrii publici ai clasei de bază sunt moșteniți
public, membrii publici ai clasei de bază devin membri publici ai clasei derivate și, prin urmare, sunt accesibili
obiectelor clasei derivate. În ambele cazuri, membrii privați nu sunt moșteniți și, prin urmare, membrii privați ai
unei clase de bază nu vor deveni niciodată membrii clasei sale derivate
În moștenire, unele dintre elementele de date ale clasei de bază și funcțiile membre sunt "moștenite" în
clasa derivată. Putem adăuga propriile noastre date și funcții membre și astfel extindem funcționalitatea clasei
de bază. Moștenirea, atunci când este utilizată pentru a modifica și extinde capacitatea claselor existente, devine
un instrument foarte puternic pentru dezvoltarea incrementală a programelor
Vizibilitatea membrilor moșteniți

Vizibilitate elate derivată
Baur cUu* vitibility
Derivarea
publică Derivare privată Derivare protejată
Privat —♦ Nu este moștenit Nu este moștenit Nu este moștenit
Protejat ♦ Protejat Privat Protejat
Public — Privat Protejat
Public
Tipuri de moștenire: 1.Moștenire unică 2.Moștenire pe mai multe niveluri 3.Moștenire mutiplecă 4.Moștenire
hibridă 5. Moștenirea ierarhică.
1.MOȘTENIRE UNICĂ: o clasă derivată moștenește dintr-o singură clasă de bază. Este cea mai simplă formă
de moștenire.
Clasa A / /Base
B //Clasa derivată
#include<iostream> folosind spațiul de nume std; clasa A { public: int a,b; void get() { cout<<"Introduceți
oricare două valori întregi"<<endl; cin>>a>>b;
} };
clasa B:public A {
int c;
public:
void add()
{ c=a+b;
cout<<a<<"+"<<b<<"="<<c;
}
};
int main()
{
Bb;
b.get();
b.add();
}
Ieşire:
Introduceți oricare două valori întregi
12
1+2=3
2.MOȘTENIREA PE MAI MULTE NIVELURI: În acest tip de moștenire, clasa derivată moștenește de la o
clasă, care la rândul ei moștenește de la o altă clasă. Super clasa pentru unul, este subclasa pentru celălalt.
clasa A
{
public:
int a,b;
void get()
{
cout<<"Introduceți oricare două valori întregi"<<endl;
cin>>a>>b;
}
};
clasa B:public A
{
public:
int c;
void add()
{
c=a+b;
}
};
clasa C:public B
{
public:
spectacol nul()
{
cout<<a<<"+"<<b<<"="<<c;
}
};
int main()
{
Cc;
c.get();
c.se adaugă();
c.spectacol();
}
Ieşire:
Introduceți oricare două valori întregi
12 14
12+14=26
3 . Moștenire multiplă: În acest tip de moștenire, o singură clasă derivată poate moșteni de la două sau
mai mult de două clase de bază.
Sintaxă:
clasa D : vizibilitatea A, vizibilitatea B,.... {
clasa A
{
public:
int a;
vid getA()
{
cout<<"Introduceți o valoare întreagă"<<endl; Cin>>A;
}
};
clasa B
{
public:
int b;
vid getB()
{
cout<<"Introduceți o valoare întreagă"<<endl; cin>>b;
}
};
clasa C:public A,public B

{
public:
int c;
void add()
{
c=a+b;
cout<<a<<"+"<<b<<"="<<c<<endl;
}
};
int main()
{
C obj;
obj.getA();
obj.getB();
obj.add();
}
Introduceți un număr întreg
valoarea 12 Introduceți un
Valoare întreagă 13 12+13=25
4 . Moștenire hibridă: Moștenirea hibridă este o combinație de două sau mai multe moșteniri, cum ar fi
moșteniri unice, multiple, pe mai multe niveluri sau ierarhice.
aritmetica clasei
{
protejat:
int num1, num2;
public:
void getdata()
{
cout<<"Pentru adăugare:";
cout<<"\nIntroduceți primul număr: ";
cin>>num1;
cout<<"\nIntroduceți al doilea număr: ";
cin>>num2;
}
};
clasa plus:aritmetică publică
{
protejat:
int sumă;
public:
void add()
{
sum=num1+num2;
}
};
Clasa minus
{
protejat:
int n1,n2,dif;
public:
void sub()
{
cout<<"\nPentru scădere:";
cout<<"\nIntroduceți primul număr: ";
Cin>>N1;
cout<<"\nIntroduceți al doilea număr: ";
Cin>>N2;
diff=n1-n2;
} };
Rezultatul clasei:Public plus, Public minus
{
public:
Afișaj gol()
{
cout<<"\nSuma dintre "<<num1<<" și "<<num2<<"= "<<sumă;

cout<<"\nDiferența dintre "<<n1<<" și "<<n2<<"= "<<diff;
}
};
int main()
{
rezultatul z;
z.getdata();
z.add();
z.sub();
z.display();
}
Pentru completare:
Introduceți primul număr: 1
Introduceți al doilea număr: 2
Pentru scădere:
Introduceți primul număr: 3
Introduceți al doilea număr: 4
Suma dintre 1 și 2= 3
Diferența de 3 și 4= -1
5 . Moștenirea ierarhică: Moștenirea este o metodă de moștenire în care una sau mai multe clase
derivate derivă din clasa de bază comună.
#include<iostream.h> clasa A //Clasa de bază {

public:
int a,b;
void getnumber()
{
cout<<"\n\nEnter Number :\t"; Cin>>A;
}
};
clasa B : public A //derivat Clasa 1
{
public:
pătrat gol()
{
getnumber(); Proprietatea clasei Call Base cout<<"\n\n\tPătratul numărului :\t"<<(a*a);
}
};
clasa C :p ublic A //derivată clasa 2
{
public:
cub vid()
{
getnumber(); Proprietatea clasei Call Base cout<<"\n\n\tCube a numărului :::\t"<<(a*a*a);
}
};
int main()
{
B b1; b1 face obiectul clasei derivate 1
b1.pătrat(); funcția de membru al apelului din clasa B C c1; c1 face obiectul clasei derivate 2
c1.cub(); funcția de membru al apelului din clasa C }
Număr de introducere: 2
Pătratul numărului : 4
Numar Introducere: 3
Cubul numărului ::: 27

UNITATEA -4
Indicatori, funcții virtuale și polimorfism:Introducere, gestionarea memoriei, operator nou și ștergeți

operatorul, indicatori către obiecte, acest indicator, indicatori către
Clase derivate,Polimorfism,Polimorfism de compilare în timp,Polimorfism în timp de rulare, Virtual
Funcții,Funcții pur virtuale,Clase de bază virtuale,Destructori virtuali,Funcție
Supraîncărcarea, supraîncărcarea operatorului, reguli pentru operatorii binari și unari ai operatorului.
Introducere în gestionarea memoriei:
ALOCAREA ȘI DEALOCAREA DINAMICĂ A MEMORIEI (nou și ștergere)

C utilizează funcțiile malloc() și calloc() pentru a aloca dinamic memoria în timpul rulării. Utilizează funcția
free() pentru a dealoca memoria alocată dinamic.
C ++ acceptă aceste funcții, definește doi operatori unari noi și ștergeți care îndeplinesc sarcina de alocare și
Alocarea memoriei într-un mod mai bun și mai ușor.
Un obiect poate fi creat utilizând nou și distrus utilizând ștergerea.
Un obiect de date creat în interiorul unui bloc cu nou, va rămâne în existență până când este în mod
explicit
distrus prin utilizarea ștergerii.
operator nou: -
Noul operator poate fi folosit pentru a crea obiecte de orice tip . Prin urmare, noul operator
alocă suficientă memorie pentru a stoca datele obiectelor și returnează adresa memoriei alocate.
Sintaxă:
pointer-variabilă = tip nou de date;
Ex: int *p = int nou;
>
Pentru a crea spațiu de memorie pentru matrice: pointer-variable = tip nou de date[dimensiune];
Ex: int *p = nou int[10];
Operator DElete:
Dacă variabila sau obiectul nu mai este necesar sau este necesar este distrus de operatorul "șterge",
acolo cu o anumită cantitate de memorie este eliberată pentru un scop viitor. Synatx:
ștergeți indicatorul-variabil;
De exemplu: ștergeți p;
>
Dacă dorim să eliberăm o alocare dinamică
array: ștergeți [dimensiune] pointer-variabil;
Program: scrie un program pentru a găsi suma listei de numere întregi #include<iostream> folosind spațiul de
nume std; int main()
{
int n,*p;
cout<<"Introduceți dimensiunea matricei:";
cin>>n;
p=int[n nou];
cout<<"Introduceți lista de numere întregi"<<endl;
pentru(int i=0;i<n;i++)
cin>>p[i];
Logica pentru însumare
int s=0;
pentru( int i=0;i<n;i++)
s=s+p[i];
cout<<"Suma elementelor matricei este\n";
cout<<s;
se elimină [ ]p;
returnare 0;
}
Introduceți dimensiune matrice:5
Introduceți lista de numere întregi
1 2345
Suma elementelor matricei este
15
Membru Operator de dereferențiere: -

1. Indicator către un declarant membru ::*
2. Indicator către operatorul membru ->*
Indicator către un declarator membru ::*
Acest operator este utilizat pentru a declara un indicator membrului clasei #include<iostream.h>
Exemplu de clasă
{public:
int x;
};
int main()
{ eșantionul s; obiect
eșantion int ::*p;//pointerul declerare s.*p=10;
corect
cout<<s.*p;
}
Rezultat:10
2 . Indicator către operatorul membru ->*
Exemplu de clasă
{
public:
int x; void
display() {
}
};
int main()
{
eșantion *ptr;
int sample::*f=&sample::x;
s.x=10;
ptr=&s;
cout<<ptr->*f;
ptr->display();
}
3 . Indicator către operatorul membru .*

Exemplu de clasă
{
public:
int x;
};
int main()
{
eșantion int ::*p;//pointer: declerare
s.*p=10; corect
cout<<s.*p;
}
Indicatori către obiecte:Indicatorii către obiecte sunt utili pentru crearea obiectelor în timpul rulării. Pentru a
accesa operatorul săgeată membri ( ) și operatorul de referențiere sau indirecția (*).
Declarația indicatorului.
className*ptr
ex:
articol *obj;
Aici obj este un indicator către obiectul elementului tip.
Element de clasă
{
Codul INT;
preț flotant;
public:
vid getdata(int a,float b)
{
cod=a;
preț = b;
}
spectacol nul()
{
cout<<"code:"<<code<<"\n"<<"Price:"<<price<<endl;
}
};
Declarație de obiect și indicator către elementul clasei: articol obj;

articol *ptr=&obj;
Membrul poate fi accesat după cum urmează.
a) Accesarea membrilor folosind operatorul dot obj.getdata(101,77.7); obj.show();
b)utilizarea indicatorului
ptr->getdata(101,77.7);
ptr->spectacol();
c)Utilizarea operatorului de referențiere și a operatorului de puncte (*ptr).getdata(101,77.7);
(*ptr).show();
Crearea unei matrice de obiecte folosind indicatorul: item *ptr=new item[10];
Declarația de mai sus creează spațiu de memorie pentru o matrice de 10 obiecte de tip element.
Element de clasă #include<iostream.h>

{
Codul INT;
preț flotant;
public:
void getdata(int a,float b) {
cod=a; preț = b;
}
spectacol nul()
{
cout<<code<<"\t"<<price<<endl;
}
};
int main()
{
int n;
CD INT;
pri plutitor;
cout<<"Introduceți numărul de obiecte care urmează să fie create:";
cin>>n;
articol *ptr=articol nou[n];
punctul *p;
p=ptr;
pentru(int i=0;i<n;i++) {
cout<<"Introduceți datele pentru obiect"<<i+1;
cout<<"\nEnter Code:";cin>>cd;
cout<<"Introduceți preț:";cin>>pri;
p->getdata(cd,pri);
p++;
}
p=ptr;
cout<<"Datele din diverse obiecte sunt "<<endl;
cout<<"Sno\tCode\tPrice\n";
pentru(i=0;i<n;i++)
{
cout<<i+1<<"\t";
ptr->spectacol();
PTR++;
}
returnare 0;
}
Indicatori către clasele derivate: Indicatorii pot fi declarați clasei derivate. Poate fi folosit pentru a
accesa membrii clasei de bază și ai clasei derivate. Un pointer de clasă de bază poate fi, de asemenea, utilizat
pentru a indica obiectul clasei derivate, dar poate accesa numai membrii care sunt moșteniți de la clasa de
bază.
Baza clasei
{
public:
int a;
Void get_a(Int X)
{
a=x;
}
nul display_a()
{
cout<<"In base"<<"\n"<<"a="<<a<<endl;
}
};
clasă derivată:bază publică
{
int b;
public:
vid get_ab(int x,int y)
{
a=x;
b=y;
}
nul display_ab()
{
cout<<"În derivat "<<"\n"<<"a="<<a<<"\nb="<<b<<endl;
}
};
int main()
{
baza b;
baza *bptr;
bptr=&b;//indică obiectul clasei de bază
BPTR->get_a(100);
BPTR->display_a();
derivată d;
derivat *dptr;
dptr=&d;//indică obiectul clasei derivate
DPTR->get_a(400);
DPTR->display_a();
DPTR->get_ab (300.200);
DPTR->display_ab();
bptr=&d;//indică obiectul clasei derivate BPTR->get_a(400);

BPTR->display_a();
returnare 0;
}
Ieşire:
În bază
a=100
În bază
a=400
În derivat
a=300
b=200
În bază
a=400
POLIMORFISMUL RUNTIME FOLOSIND FUNCȚII VIRTUALE

Legare statică și dinamică
Polimorfismul înseamnă "un singur nume‟ -"mai multe forme.
Funcțiile de membru supraîncărcate sunt "selectate" pentru invocarea prin potrivirea argumentelor, atât tipul,
cât și numărul. Aceste informații sunt cunoscute compilatorului la momentul compilării și compilatorul este
capabil să selecteze funcția corespunzătoare pentru un anumit apel la momentul compilării în sine. Aceasta se
numește legare timpurie sau legare statică sau legătură statică. De asemenea, cunoscut sub numele de
polimorfism de compilare a timpului. Legarea timpurie înseamnă că un obiect este legat de apelul său de
funcții la momentul compilării.
Ar fi frumos dacă funcția de membru corespunzătoare ar putea fi selectată în timp ce programul
rulează. Acest lucru este cunoscut sub numele de polimorfism runtime. C++ acceptă un mecanism cunoscut
sub numele de funcție virtuală pentru a obține polimorfismul timpului de rulare.
La momentul rulării, când se știe ce obiecte de clasă sunt luate în considerare, se invocă versiunea
corespunzătoare a funcției. Deoarece funcția este legată de o anumită clasă mult mai târziu după compilare,
acest proces este denumit legare târzie. Este, de asemenea, cunoscut sub numele de legare dinamică ,
deoarece selectarea funcției corespunzătoare se face dinamic în timpul rulării.
Funcționa Operator Virtual

Supraîncărca Supraîncărcarea Funcţii
rea
FUNCȚII VIRTUALE
Polimorfismul se referă la proprietatea prin care obiectele aparținând unor clase diferite sunt capabile
să răspundă la același mesaj, dar forme diferite. O cerință esențială a polimorfismului este, prin urmare,
capacitatea de a se referi la obiecte fără a ține cont de clasele lor.
Când folosim același nume de funcție atât în clasele de bază, cât și în cele derivate, funcția din clasa
bas este declarată virtuală folosind cuvântul cheie virtual care precede declarația sa normală.
Când o funcție devine virtuală, C++ determină ce funcție să utilizeze în timpul rulării pe baza tipului de obiect
indicat de indicatorul de bază, mai degrabă decât a tipului indicatorului. Astfel, făcând indicatorul de bază să
indice diferite obiecte, putem executa diferite versiuni ale funcției virtuale.
clasa de bază
{
public:
Afișaj gol()
{
cout<<"Baza de afișare";
}
Spectacol vid virtual ()
{
cout<<"Arată baza";
}
};
clasa Derivat : baza publică
{
public:
Afișaj gol()
{
cout<<"Display Derived";
}
spectacol nul()
{
cout<<"spectacol derivat";
}
};
vid principal()
{
Baza b;
derivat d;
Baza *ptr;
cout<<"ptr indică la bază";
ptr=&b;
ptr->display(); apeluri de bază
ptr->spectacol(); / /Baza de apeluri
cout<<"PTR indică derivat";
ptr=&d;
ptr->display(); apeluri de bază
ptr->spectacol(); clasa Derivat
}
Ieşire:
ptr indică spre bază

Baza de afișare
Afișați baza
ptr indică derivatul
Baza de afișare
Arată derivat
Când ptr este făcut pentru a indica obiectul d, afirmația ptr->display(); apelează numai funcția
asociate cu Baza, adică Baza::d isplay()
în cazul în care declarația
ptr->spectacol();
apelează versiunea derivată a show(). Acest lucru se datorează faptului că afișarea funcției () nu a fost făcută
virtuală în clasa de bază.
Reguli pentru funcțiile virtuale:
Când sunt create funcții virtuale pentru implementarea legării târzii, respectați câteva reguli de bază
care satisfac cerințele compilatorului.
1. Funcțiile virtuale trebuie să fie membre ale unei anumite clase.

2. Ei nu pot fi membri statici.
3. Acestea sunt accesate utilizând indicatori de obiecte.
4. O funcție virtuală poate fi un prieten al unei alte clase.
5. O funcție virtuală dintr-o clasă de bază trebuie definită, chiar dacă nu poate fi utilizată.
6. Prototipurile versiunii de clasă de bază a unei funcții virtuale și toate versiunile de clasă derivate
trebuie să fie identice. C++ le consideră funcții supraîncărcate, iar mecanismul funcției virtuale este
ignorat.
7. Nu putem avea constructori virtuali, dar putem avea distrugători virtuali.
8. În timp ce un indicator de bază indică orice tip de obiect derivat, inversul nu este adevărat. adică nu
putem folosi un pointer către o clasă derivată pentru a accesa un obiect de tipul clasei de bază.
9. Când un indicator de bază indică o clasă derivată, incrementarea sau descreșterea acesteia nu va face
să indice următorul obiect al clasei derivate. Este incrementat sau descrescător numai în raport cu tipul
său de bază. Prin urmare, nu ar trebui să folosim această metodă pentru a muta indicatorul la următorul
obiect.
10. Dacă o funcție virtuală este definită în clasa de bază, nu este necesar să fie neapărat redefinită în clasa
derivată. În astfel de cazuri, apelurile vor invoca funcția de bază.
SUPRAÎNCĂRCAREA
SUPRAÎNCĂRCAREA OPERATORULUI
C++ are capacitatea de a oferi operatorilor o semnificație specială pentru un tip de date. Mecanismul de a da
astfel de semnificații speciale unui operator este cunoscut sub numele de supraîncărcare a operatorului.
Putem supraîncărca toți operatorii, cu excepția următoarelor:
Operator de acces membru al clasei ("." Și "
.*") Operatorul rezoluției domeniului de aplicare ": :"
Operator dimensiune (dimensiune)
Operator condiționat
Pentru a defini o sarcină suplimentară pentru un operator, specificați ce înseamnă în raport cu clasa la
care se aplică operatorul. Acest lucru se face cu ajutorul unei funcții speciale, numită funcție operator.
Procesul de supraîncărcare implică următorii pași:
1. Creați o clasă care definește tipul de date care urmează să fie utilizat în operațiunea de
supraîncărcare.
2. Declarați operatorul funcției operator op() în partea publică a clasei. Poate fi o funcție de membru
sau o funcție de prieten.
3. Aici op este operatorul care trebuie supraîncărcat.
4. Definiți funcția operatorului pentru a implementa operațiunile necesare.
Ex:
complex complex::operator+(complex c)
{
complexul t;
t.real=real+c.real;
t.img=img+c.img;
returnarea t;
}
Conceptul de supraîncărcare a operatorului
Una dintre caracteristicile unice ale C++ este supraîncărcarea operatorului. Aplicarea supraîncărcării
operatorilor înseamnă ca același operator să răspundă diferit. De exemplu, operatorul + poate fi utilizat ca
operator concatenat, precum și ca operator suplimentar.
Adică 2 + 3 înseamnă 5 (adunare), unde ca

"2"+"3" înseamnă 23 (concatenare).
Efectuarea mai multor acțiuni cu un singur operator este supraîncărcarea operatorului. Putem atribui o
funcție definită de utilizator unui operator. Putem schimba funcția unui operator, dar nu este recomandat să
schimbăm funcțiile reale ale operatorului. Nu putem crea operatori noi folosind această încărcare a operatorului.
Conceptul de supraîncărcare a operatorului poate fi aplicat în următoarele două domenii majore (Beneficii)
1. Extinderea utilizării operatorilor
2. Conversii de date
Reguli care trebuie respectate pentru supraîncărcarea operatorului:
1 . Numai operatorii existenți pot fi supraîncărcați.
2 . Operatorii supraîncărcați trebuie să aibă cel puțin un operand care este al operatorilor definiți de
utilizator
3 . Nu putem schimba sensul de bază al unui operator.
4 . Operatorul supraîncărcat trebuie să respecte caracteristicile minime ale operatorului inițial
5 . Atunci când se utilizează supraîncărcarea operatorului binar prin funcția membru, operandul din
stânga trebuie să fie un obiect din clasa relevantă
Numărul de argumente din lista de argumente a operatorului supraîncărcat depinde
1. Funcția operatorului trebuie să fie fie funcția membru, fie funcția prieten.
2. Dacă funcția operator este o funcție prietenă, atunci va avea un argument pentru operatorul unar
& două argumente pentru operatorul binar
3. Dacă funcția operator este o funcție membru, atunci va avea argumentul zero pentru operatorul
unar și un argument pentru operatorul binar
Supraîncărcarea operatorului unar

Un operator unar înseamnă un operator care lucrează pe un singur operand. De exemplu, ++ este un operator
unar, este nevoie de un singur operand (c ++). Deci, atunci când supraîncărcați un operator unar, nu este nevoie
de nici un argument (deoarece obiectul în sine este considerat argument).
Sintaxă pentru Unary Operator (În interiorul unei clase)
Operator de tip returnareOperatorSimbol( )

{
Corpul funcției
}
Ex:
void operator-()
{
real = -real;
img=-img;
}
Sintaxă pentru operator unar (în afara unei clase)
return-type classname::operator operatorsymbol( )
{
Corpul funcției
}
Exemplul 1: -
Operator de vid++()
{
contra++;
}
Exemplul 2: -
Complex vid::operator-()
{
real = -real;
img=-img;
}
Următorul program simplu explică conceptul de supraîncărcare unară.

#include < iostream.h >
#include < conio.h >
Program Operator
Faptul de supraîncărcare a clasei
{
int a;
public:
fapt ()
{
a=0;
} fapt (int i) {
a=i;
}
Operator de fapt! ()
{
int f=1,i;
faptul t;
pentru (i=1;i<=a;i++)
{
f=f*i;
}
t.a=f;
returnarea t;
}
Afișaj gol()
{
cout<<"Factorialul "<< a;
}
};
vid principal()
{
int x;
cout<<"introduceți un număr";
cin>>x;
faptul s(x),p;
p=!s;
p.afișaj();
}
Ieșire pentru programul de mai sus:

Introduceți un număr 5
Factorialul unui număr dat 120
Explicație:
Am luat "!‟ ca operator la supraîncărcare. Aici numele clasei este fapt. Constructor fără parametri pentru a lua
valoarea inițială a lui "x‟ ca 0. Constructor cu parametru pentru a lua valoarea "x ‟ . Am creat două obiecte,
unul pentru a face factorialul și celălalt pentru a returna factorialul. Aici numărul de parametri pentru o funcție
supraîncărcată este 0. Factorial este operator unar deoarece operează pe un singur element de date.
Supraîncărcarea operatorului găsește factorialul obiectului. Funcția de afișare pentru imprimarea rezultatului.
Supraîncărcarea operatorului unar -
Exemplul 1: -
Scrieți un program pentru a supraîncărca operatorul unar -
#include<iostream>
Complex de clasă
{
float real,img;
public:
complex();
complex (float x, float y);
afișaj vid();
operator nul-();
};
complex::complex()
{
real=0;img=0;
}
complex::complex(float x, float y)
{
real = x;
img=y;
}
Complex vid::d isplay()
{
int imag=img;
if(img<0)
{
imag=-img;
cout<<real<<" -i"<<imag<<endl;
}
altfel
cout<<real<<" +i"<<img<<endl;
}
Complex vid::operator-()
{
real = -real;
img=-img;
}
int main()
{
complexul C(1,-2);
c.afișaj();
cout<<"După unar - operație\n";
-c;
c.afișaj();
}
Exemplul 2: -
Spațiu de clasă
{
int x,y,z;
public:
void getdata(int a,int b,int c);
afișaj vid();
operator nul-();
};
spațiu gol :: getdata(int a,int b,int c)
{
x=a;
y = b;
z=c;
}
spatiu gol :: display()
{
cout<<"y="<<y<<endl;
cout<<"z="<<z<<endl;
}
spațiu gol :: operator-()
{
x=-x;
y=-y;
z=-z;
}
int main()
{
spațiul s;
s.getdata(10,-20,30);
s.afișaj();
-s;
cout<<"după negare\n";
s.afișaj();
}
Ieşire:
x=10
y=-20
z=30
după negare
x=-10
y=20
z=-30
Este posibil să supraîncărcați un operator minus unar folosind o funcție de prieten după cum urmează:
prieten void operator-(spațiu &s);
Exemplul 3: -
Operator minus unar folosind o funcție prieten
Spațiu de clasă
{
int x,y,z;
public:
void getdata(int a,int b,int c);
afișaj vid();
prieten operator vid-(spațiu &);
};
spațiu gol :: getdata(int a,int b,int c)
{
x=a;
y = b;
z=c;
}
spatiu gol :: display()

{
cout<<x<<" "<<y<<" "<<z<<endl;
}
Operator vid-(spațiu &s)
{
s.x=-s.x;
s.y=-s.y;
s.z=-s.z;
}
int main()
{
spațiul S;
S.getdata(10,-20,30);
S.afișaj();
-S;
cout<<"după negare\n";
S.afișaj();
}
Ieşire:
10 -20 30
după negare
-10 20-30
Supraîncărcarea operatorului binar

Un operator binar înseamnă, un operator care lucrează pe doi operanzi. De exemplu, + este un operator binar,
este nevoie de un singur operand (c + d). Deci, atunci când supraîncărcați un operator binar, este nevoie de un
argument (unul este obiectul în sine și celălalt este argumentul trecut).
Sintaxă pentru operator binar (în interiorul unei clase) operator de tip returnare
operatorsymbol(argument) {
Corpul funcției
}
Sintaxă pentru definiția operatorului binar (În afara unei clase ) tip return-type classname::operator
operatorsymbol(argument) {
Corpul funcției
}
Exemplu operator complex+(complex s)

{
complexul t;
t.real=real+s.real;
t.img=img+s.img;
returnarea t;
}
Următorul program explică supraîncărcarea operatorului binar:
Suma clasei
{
int a;
public:
sumă()
{
a=0;
}
sumă(int i)
{
a=i;
}
operator sumă+(sumă p1)
{
suma t;
t.a=a+p1.a;
returnarea t;
}
vid principal ()
{
cout<<"Introduceți două numere:"
int a,b;
cin>>a>>b;
suma x(a),y(b),z;
z.display();
z=x+y;
cout<<"după aplicarea operatorului \n";
z.display();
getch();
}
Ieșire pentru programul de mai sus:
Introduceți două numere 5 6
După aplicarea operatorului
Suma a două numere 11
Explicație: Numele clasei este "sum‟ . Am creat trei obiecte: două pentru a face suma și cealaltă pentru
returnarea sumei. ‟ +‟ este un operator binar care operează asupra membrilor a două obiecte și returnează
rezultatul care este membru al unui obiect.aici numărul de parametri este 1. Suma este afișată în funcția de
afișare.
Scrieți un program pentru a supraîncărca operatorii aritmetici pe numere complexe folosind funcția
membru
Complex de clasă
{
float real,img;
public:
complex(){ }
Complex (Float X, Float Y)
{
real = x;
img=y;
}
operator complex+(complex c) void display();
};
complex complex::operator+(complex c)
{
temperatură complexă;
temp.real=real+c.real;
temp.img=img+c.img;
temperatura de întoarcere;
}
{
int imag=img;
Dacă(img<0)
{
imag=-imag;
cout<<real<<"-i"<<imag;
} altceva cout<<real<<"+i"<<img;
}
int main()
{
complexul C1,C2,C3;
c1=complex(2,5,3,5);
c3=c1+c2;
c3.display();
returnare 0;
}
Supraîncărcarea operatorilor binari folosind prietenii
1. Înlocuiți declarația funcției membru cu declarația funcției prieten în clasa friend complex operator+
(complex, complex)
2. Redefiniți funcția operatorului după cum urmează:
Operator complex+(Complex A, Complex B)
{
complex de retur ((a.x+b.x),(a.y+b.y));
}
Scrieți un program pentru a supraîncărca operatorii aritmetici pe numere complexe folosind funcția
prieten #include<iostream.h>
Complex de clasă
{
float real,img;
public:
complex(){ }
Complex (Float X, Float Y)
{
real = x;
img=y;
}
prieten operator complex+(complex);
afișaj vid();
};
Operator complex+(Complex C1, Complex C2)
{
temperatură complexă;
temp.real=c1.real+c2.real;
temp.img=c1.img+c2.img;
temperatura de întoarcere;
}
{
Dacă(img<0)
{
img=-img;
cout<<real<<"-i"<<img;
}
altfel
cout<<real<<"+i"<<img;
}
int main()
{
complexul C1,C2,C3;
c3=c1+c2;
c3.display();
returnare 0;
}
UNITATEA -5
Șabloane și tratarea excepțiilor:

Introducere, șabloane de clasă, șabloane de clasă cu parametri multipli, șabloane de funcții, șabloane de
funcții cu parametri multipli, șabloane de funcții membre. Tratarea excepțiilor: Noțiuni de bază despre
tratarea excepțiilor, Tipuri de excepții, mecanism de tratare a excepțiilor, mecanism de aruncare și
capturare, rethrarea unei excepții, specificarea excepțiilor.
PROGRAMARE GENERICĂ (Șabloane)

Programarea generică este o abordare în care tipurile generice sunt utilizate ca parametri în algoritmi, astfel
încât acestea să funcționeze pentru o varietate de tipuri de date și structuri de date adecvate.
Un beneficiu semnificativ al programării orientate pe obiecte este reutilizarea codului, care elimină
codificarea redundantă. O caracteristică importantă a șabloanelor numite C ++ întărește acest beneficiu al OOP
și oferă o mare flexibilitate limbajului. Șabloanele acceptă programarea generică, care permite dezvoltarea
componentelor software reutilizabile, cum ar fi funcții, clase etc. sprijinirea diferitelor tipuri de date într-un
singur cadru.
Conceptul de șabloane
Introducere
În loc să scriem funcții diferite pentru diferitele tipuri de date, putem defini comune
funcționa. De exemplu
int max(int a,int b); Returnează maximum două numere întregi float
max(plutitor a, plutitor b); Returnează maximum două flotoare char max(char a,char b); Returnează maximum
două caractere (acest lucru se numește supraîncărcare funcție)
Dar, în loc să scrie trei funcții diferite ca mai sus, C ++ a oferit facilitatea numită "Șabloane". Cu ajutorul
șabloanelor puteți defini o singură funcție comună, după cum urmează:
T max(T a,T b); T se numește tip de date generic
Funcțiile șablon sunt modalitatea de a face rezumate de funcții / clase prin crearea comportamentului funcției
fără a ști ce date vor fi gestionate de o funcție. Într-un sens, aceasta este ceea ce este cunoscut sub numele de
"funcții generice sau programare".
Funcția șablon se concentrează mai mult pe gândirea algoritmică decât pe un mijloc specific al unui singur tip
de date. De exemplu, puteți crea o funcție push de stivă șablonată. Această funcție push poate gestiona
operația de inserare într-o stivă pe orice tip de date, mai degrabă decât să creeze o funcție de împingere a stivei
pentru fiecare tip diferit.
Sintaxă:
Șablon < tipul clasei >
ret_type fun_name(lista parametrilor)
{
--------------Corpul funcției
} //www.suhritsolutions.com
Caracteristicile șabloanelor: -
1. Elimină codul redundant
2. Îmbunătățește reutilizarea codului.
3. Oferă o mare flexibilitate limbajului
Șabloanele sunt clasificate în două tipuri. Sînt
1 . Șabloane de funcții
2 . Șabloane de clasă.
Șabloane de funcții
Șabloanele declarate pentru funcții sunt denumite șabloane de funcții. Un șablon de funcții definește modul în
care poate fi construită o funcție individuală.
Sintaxă:
șablon < tip de clasă,......... >
ret _type fun_ nume(argumente)
{
-----------------Corpul funcției
-----------------
}
ȘABLOANE DE CLASĂ
Șabloanele declarate pentru clase se numesc șabloane de clasă. Un șablon de clasă specifică modul în
care clasele individuale pot fi construite similar cu specificația normală a clasei. Aceste clase modelează o
clasă generică care acceptă operații similare pentru diferite tipuri de date. Forma generală a unui șablon de
clasă
șablon <clasa T> numele clasei {
…; ….
}
O clasă creată dintr-un șablon de clasă se numește clasă șablon. Sintaxa pentru definirea unui obiect dintr-o
clasă de șabloane este:
classname<type> objectname(arglist);
#include<conio.h>
șablon <clasa T> schimb de clasă
{
T a,b;
public:
swap (T x,T y)
{
a=x;
b=y;
}
swapab nul()
{
Temperatura T;
temp=a;
a=b;
b = temp;
}
void showdata()
{
cout<<a<<b;
}
};
vid principal()
{
int m,n;
plutitor m1,n1;
cout<<"Introduceți valori întregi";
cin>>m>>n;
cout<<"Introduceți valori flotante";
cin>>m1>>n1;
swap<int> c1(m,n);
swap<float> c2(m1,n1);
c1.swapab();
c1.showdata();
c2.swapab();
c2.showdata();
}
Șablon de clasă cu parametri multipli
Sintaxă:
șablon <clasa T1, clasa T2,....> numele clasei

{}
#include<iostream.h> șablon <clasa T1, clasa T2> clasa Test

{
T1 a;
T2b;
public:
Test(T1 x,T2 y)
{ a = x; b = y;
}
spectacol nul()
{
cout<<a<<b;
}
};
vid principal()
{
test < flotant, int> test1 (1,23,123);
test<int,char> test2(100,'w‟);
test1.show();
test2.show();
}
ȘABLOANE DE FUNCȚII
La fel ca șablonul de clasă, putem defini, de asemenea, șabloane de funcții care ar fi utilizate pentru a crea o
familie de funcții cu diferite tipuri de argumente.
Formular general:
șablon <clasa T>
return-type function-name (argumente de tip T)
{}
șablon<clasa T>
swap vid (T &x, T &y)
{
T temp = x;
x=y;
y=temp;
}
distracție vidă (int m, int n, float a, float b)
{
cout<<m<<n;
swap(m,n);
cout<<m<<n;
cout<<a<<b;
swap (a, b);
cout<<a<<b;
}
int main()
{
distracție(100.200,11.22,33,44);
returnare 0;
}
Exemplul 2: -
șablon
T max(T a, T b)
{
dacă(a>b)
returnarea a;
altfel
returnarea b;
}
vid principal( )
{
char ch1,ch2,ch3;
cout<<"introduceți două caractere"<< ch2<< ch3;
cin>>CH2>>CH3;
d=max(CH2,CH3);
cout<<"max(ch2,ch3)"<< ch1;
int a,b,c;
cout<<"introduceți două numere întregi:";
cin>>a>>b;
c=max(a,b);
cout<<"max(a,b):"<< c<< endl;
flotor f1,f2,f3;
cout<<"introduceți două flotoare< F1F2 >:";
cin>>f1,f2;
f3=max(f1,f2);
cout<<"max(f1,f2):"<< f3;
}
Ieşire:
introduceți două caractere: A,B
max(ch2,ch3):B
Introduceți două numere întregi:20,10
max (a,b) :20
Introduceți două flotante: 20.5,30.9
Max (F1,F2) :30.9
Șablon de funcții cu parametri multipli

La fel ca în cazul clasei de șabloane, putem utiliza mai multe tipuri de date generice în instrucțiunea
șablonului, utilizând o listă separată prin virgulă, după cum se arată mai jos:
șablon <clasa T1, clasa T2,.> funcție de tip return-
name(argumente de tip T1,T2.) {
#inlcude<șir.h>
template<clas T1, clasa T2> void display(T1 x,T2 y) {
cout<<x<<y;
}
int main()
{
afișaj (1999,"EBG");
afișaj (12.34,1234);
returnare 0;
}
Tratarea excepțiilor
Excepții: Excepțiile sunt anomalii de execuție sau condiții neobișnuite pe care un program le poate întâlni în
timpul executării . Anomaliile pot include condiții precum împărțirea fundului la zero, accesarea unei matrice
în afara limitelor sale sau epuizarea memoriei sau a spațiului pe disc. Atunci când un program îndeplinește o
condiție de excepție, acesta trebuie identificat și tratat.
Excepțiile oferă o modalitate de a transfera controlul dintr-o parte a unui program în alta. Gestionarea
excepțiilor C ++ se bazează pe trei cuvinte cheie: încercați, prindeți și aruncați.
Tipuri de excepții:Există două tipuri de excepții

1.Excepții sincrone
2.Excepții asincrone
1.Excepții sincrone:Erori precum "Index în afara intervalului" și "supraflux" sunt excepții sincrone
2. Excepții asincrone: Erorile generate de orice eveniment dincolo de controlul programului se numesc
excepții asincrone
Scopul tratării excepțiilor este de a oferi un mijloc de detectare și raportare a unei circumstanțe excepționale
Mecanismul de tratare a excepțiilor:

Se spune că o excepție este aruncată în locul în care este detectată o eroare sau o stare anormală. Aruncarea va
face ca fluxul normal al programului să fie întrerupt, cu o excepție ridicată. O excepție este aruncată
programatic, programatorul specifică condițiile unei aruncări.
În excepțiile gestionate, executarea programului va fi reluată la un bloc de cod desemnat, numit bloc
de captură, care cuprinde punctul de aruncare în ceea ce privește execuția programului. Blocul de captură
poate fi, și de obicei este, situat într-o funcție diferită de punctul de aruncare.
Gestionarea excepțiilor C ++ se bazează pe trei cuvinte cheie: încercați, prindeți și aruncați.

Try este folosit pentru a prefața un bloc de afirmații care pot genera excepții. Acest bloc de declarații este cunoscut sub
numele de bloc de încercare. Când este detectată o excepție, aceasta este aruncată utilizând instrucțiunea de aruncare în
blocul de încercare. Blocul de captură prinde excepția aruncată prin declarația de aruncare în blocul de încercare și o
gestionează corespunzător.
#include<iostream>
int main()
{
int a,b;
cout<<"Introduceți oricare două valori întregi";
cin>>a>>b;
int x=a-b;
încerca
{
dacă(x!=0)
{
cout<<"Result(a/x)="<<a/x<<endl;
}
altfel
{ aruncă x;
}
}
captură(int ex)
{
cout<<"Excepție prinsă:Divide By Zero \n";
}
}
MECANISM DE ARUNCARE
Când este detectată o excepție, aceasta poate fi aruncată utilizând instrucțiunea aruncare în oricare dintre
următoarele forme
aruncare(excepție); aruncă excepție;
arunca;
MECANISMUL DE CAPTURARE:
Blocul de captură este cel de mai jos

Catch(tip de date arg) {
Declarații pentru manipulare
Excepţii
}
Declarații privind capturile multiple:
încerca
{
Încercați Blocare
}
captură(tip de date1 arg)
{
bloc de captură1
}
captură(tip de date2 arg)
{
bloc de captură2
} captură(tip de dateN arg)
{
captură blocN
}
• Atunci când se aruncă o excepție, se caută rutina de tratare a excepțiilor pentru o potrivire adecvată.
• Este posibil ca argumentele mai multor declarații de captură să corespundă tipului unei excepții. În
astfel de cazuri, se execută primul handler care se potrivește tipului de excepție
Scrieți un program pentru a prinde mai multe declarații de captură

Test nul(Int X)
{
încerca
{
dacă(x==1) aruncă x;
altfel
dacă(x==0) aruncă "x";
altfel
dacă(x==-1) aruncă 1.0;
cout<<"sfârșitul blocului de încercare"<<endl;
}
captură (char c)
{
cout<<"a prins un personaj"<<endl;
}
captură(int m)
{
cout<<"a prins un întreg"<<endl;

}
captură(dublu d)
{
cout<<"caught a double"<<endl;
}
}
int main()
{
încercare(1);
încercare(0);
încercare(-1);
încercare(2);
returnare 0;
}
Ieşire:
a prins un număr întreg
a prins un personaj
a prins o dublă
Sfârșitul blocului de încercare
Prindeți toate excepțiile:
toate tipurile posibile de excepții și, prin urmare, este posibil să nu fie în măsură să conceapă manipulatori
independenți de capturi pentru a le captura. În astfel de circumstanțe, putem forța o declarație de captură să
cuprindă toate excepțiile în loc de un anumit tip.
captură(...)
{}
Scrieți un program pentru a prinde toate excepțiile

Test nul(Int X)
{
încerca
{
dacă(x==0) aruncă x;
dacă(x==0) aruncă "x";
dacă(x==-1) aruncă 1.0;
}
captură(...)
{
cout<<"excepție prinsă"<<endl;
}
}
int main()
{
încercare(-1);
încercare(0);
încercare(1);
returnare 0;
}
Rearuncarea unei excepții:
Este posibil să se transmită din nou excepția capturată de un bloc de captură unui alt manipulator de
excepții. Acest lucru l-am cunoscut sub numele de Re-aruncare.
#include <iostream>
vid MyHandler()
{ încercați {
arunca "salut";
}
captură (const char*)
{
cout <<"Excepție prinsă în MyHandler\n";
arunca; rearuncare char* din funcție
}
}
int main()
{ cout<< "Start principal "<<sfârșit; încerca
{
MyHandler();
}
captură(const char*)
{
cout <<"Excepție prinsă în interiorul Main\n";
}
cout << "Capătul principal";
returnare 0;
}
Specificarea excepțiilor:
Specificarea funcțiilor de restricționare a excepțiilor pentru a arunca unele excepții specificate numai cu
utilizarea throw(lista de excepții) în antetul funcției.
Formă generală
Tastați function_name(listă de argumente) aruncare(excepții -listă)
{
Declaraţii
încercați {
Declaraţii
}
#include <iostream>
test vid (int x) aruncare (int, float, char)
{
comutator(x)
{
cazul 1:aruncarea X;
sparge;
cazul 2:aruncă "x";
sparge;
cazul 3: aruncare dublă (x);
sparge;
cazul 4:aruncare plutitoare(x);
sparge;
}
}
int main()
{
încerca
{
testul(4);//testul(4) duce la terminarea anormală
}
captură(int i)
{
cout <<"Excepție de tip int prins\n";
}
captură (plutitor F)
{
cout <<"Excepție de tip flotor prins\n";
}
captură (char c)
{
cout <<"Excepție de tip char prins\n";
}
Captură (dublu I)
{
cout <<"Excepție de tip dublu prins\n";
}
returnare 0;
}

Note Digitale: B.Tech (Anul I - SEM II) (2018-19)

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Note Digitale: B.Tech (Anul I - SEM II) (2018-19)

Încărcat de

Drepturi de autor:

Formate disponibile

PROGRAMARE ORIENTATĂ PE OBIECTE

DEPARTAMENTUL CSE & IT

COLEGIUL DE INGINERIE ȘI TEHNOLOGIE

Anul I B.Tech II SEM L T/P/D C

Prezentare generală a limbajului C:

Prezentare generală a limbajului C++:

Programare orientată spre proceduri Programare orientată pe obiecte

Exemplu de procedură orientată Exemple de programare orientată pe obiecte sunt:

Principiile (sau caracteristicile) programării orientate pe obiecte:

Beneficiile programării orientate pe obiecte (OOP)

int i; Această declarație se face în afara și înainte de Main()

5. SUBPROGRAM SAU SECȚIUNE FUNCȚIONALĂ : Aceasta are toate subprogramele sau

6. SECȚIUNEA PRINCIPALĂ A FUNCȚIILOR: Îi spune compilatorului de unde să înceapă execuția de

Spațiu de nume definit de utilizator:

namespace_name spațiului de nume

folosind eșantionul spațiului de nume;

Tipuri de date principale:

Numere întregi semnate: (mașină pe 16 biți):

15 14 13 12 11 10 9 8 7 -1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2

-32768 -2.147.843.648 până la

Tip de date caracter: (char)

Tip de date MEMORIE NECESARĂ SAU GAMA FORMATUL SPECIER

Tipuri în virgulă mobilă:

Exemple de identificatori nevalidi: $amount, ³num', total-general, suma cifrelor, 4num.

Variabile:O locație de memorie numită se numește variabilă.

> Nu ar trebui să folosim cuvinte cheie ca identificatori.

Acestea pot fi precedate de un semn opțional + sau ±.

Număr întreg octal: Se compune dintr-un set de cifre, de la 0 la 7.

Număr întreg hexazecimal: Se compune din setul de cifre, de la 0 la 9 și alfabetele A, B, C, D, E și F. Întregul

Secvență de evadare Caracter

Operatorii C pot fi clasificați ca

> este mai mică decât

Avantajele utilizării operatorului de atribuire prescurtată:

Un operator ternar necesită doi operanzi pentru a opera

& La nivel de biți ȘI

^ Exclusiv pe biți SAU

Operator OR la nivel de biți ( |)

Primul bit de operand Al doilea bit de operand Opel | Opel

Operator Bitwise EXCLUSIV OR ( A )

Primul bit de operand Al doilea bit de operand Opel A Opel

Deplasarea la nivel de biți a operatorului la stânga

Ex: int a=2;

Operatorul virgulă (,)

Mai întâi atribuie valoarea 10 lui x, apoi atribuie 20 lui y și fina

Anonim Operator Simbol

8.6 cop Operator de rezoluție:

3. Indicator către operatorul

Declarații de control:Fluxul de execuție a declarațiilor într-un program se numește control. Declarația de

/*cel mai mare dintre cele două numere*/

/*cel mai mare dintre cele două numere*/

cout<<"B este mai mare decât A\n A="<<b;

Cuibăritul lui dacă-altceva depinde de condițiile cu care avem de-a face.

INSTRUCȚIUNEA COMUTATORULUI sau SELECTAREA MULTIDIRECȚIONAL :

/*program pentru simularea unui calculator simplu */ #include<iostream.h>

cout<<"Introduceți numărul1 numărul operatorului2 : ";

Declarații de control în buclă sau repetări:

În timp ce (condiție de testare)

C Program pentru a găsi suma a n numere naturale */

cout<<"Suma primului"<<n<"numerele naturale este:"<<suma<<endl; returnare 0;

2 . FACEȚI ÎN TIMP CE AFIRMAȚIA:

tlo-while — (Ieșire controlată)

/*c program pentru a găsi suma a n numere naturale */

/*c program pentru a găsi suma a n numere naturale */

15 14 13 12 11 10 9 8 7 -12 +12 +12 +12 +12 +12 +12 +12

/cel mai mare dintre cele două numere/

/cel mai mare dintre cele două numere/

/program pentru simularea unui calculator simplu / #include<iostream.h>

/c program pentru a găsi suma a n numere naturale /

/c program pentru a găsi suma a n numere naturale /

/program de tipărire a numerelor prime până la un anumit număr/

/c program pentru a găsi suma a n numere naturale /