# data[].attributes.body
O introducere detaliată în limbajul de programare C++, inclusiv istoria și utilizarea acestuia.

# data[].attributes.attachment_link.description
Limbajul C++ a fost inventat de către Bjarne Stroustrup în 1979, ca o extindere a limbajului C. Limbajul C a fost inventat în 1969-1973 de către Dennis Ritchie pentru a realiza sistemul de operare Uni

# data[].attributes.body
Explicarea structurii de bază a unui program simplu în limbajul C++.

# data[].attributes.attachment_link.description
Să examinăm acest program linie cu linie:

# data[].attributes.body
Variabile, tipuri de date, operatori și cum să lucrăm cu ele.

# data[].attributes.body
Cum să lucrăm cu programarea orientată pe obiecte în C++.

# data[].attributes.attachment_link.readable_text
Generalități

În programarea procedurală, un program era alcătuit din două componente distincte: date și funcții; funcțiile prelucrează datele la care au acces, prin intermediul parametrilor sau în alt mod.

Programarea orientată obiect - POO (sau Object Oriented Programming - OOP ) este o modalitate de proiectare a programelor în care datele prelucrate și operațiile cu acestea sunt încapsulate în aceeași structură, numită obiect. Funcțiile care fac parte dintr-un obiect au acces la datele care caracterizează acel obiect, iar un program este alcătuit din mai multe obiecte, care interacționează.

Programarea orientată pe obiecte se bazează pe următoarele principii fundamentale:

încapsulare = mecanismul prin care atât datele, cât și funcțiile sunt plasate în aceeași structură, numită clasă și stabilirea nivelului de acces la conținutul acesteia;

abstractizare = identificarea datelor și funcțiilor relevante pentru o anumită clasă;

moștenire = proprietatea claselor de a prelua date și metode ale unor clase definite anterior. Clasa inițială se numește clasă de bază, iar cea nouă se numește clasă derivate;

polimorfism = posibilitatea ca atât clasa de bază, cât și clasa derivată să conțină metode cu același nume, dar diferite ca funcționalitate.

Noțiunile de clasă și obiect

Clasa este un tip de date, similar cu struct, care conține atât câmpuri de tip dată (numite proprietăți), cât și câmpuri de tip funcție (numite și metode). Câmpurile clasei (proprietăți sau metode) se mai numesc membri ai clasei. Astfel avem, date membre și funcții membre.

Obiectul reprezintă o dată de tipul clasei - de exemplu o variabilă. Declararea unei variabile de acest tip se mai numește instanțiere a clasei. Spunem că obiectul este o instanță a clasei.

Pentru membrii unei clase (date sau metode) se precizează anumite caracteristici, numite modificatori (specificatori) de acces, care stabilesc cum se face accesul la acestea:

private - interzic accesul la date și metode în afara clasei;

public - permit accesul la date și metode din afara clasei;

protected - interzic accesul din afara clasei, dar îl permit din clasele derivate - are sens în contextul derivării claselor.

Exemplu

#include <iostream>

using namespace std;

class Fractie{
    private:
        int numarator, numitor;
    public:
		void afiseaza(){
			cout << numarator << "/" << numitor << " ";
		}
		void seteaza(int , int);
};

void Fractie::seteaza(int a , int b){
    numarator = a , numitor = b;
}

int main(){
	Fractie F;
	F.seteaza(3 , 4);
	F.afiseaza();
	/// F.numarator = 7; //eroare, data este privata

    return 0;
}

În exemplul de mai sus:

Fractie este numele clasei;

F este numele obiectului - instanță a clasei;

clasa are două date membre: numarator și numitor. Ele sunt private - nu pot fi accesate din exteriorul clasei;

clasa are două funcții membre: seteaza(), care dă valori datelor membre și afiseaza(), care afișează datele membre în forma specifită unei fracții ordinale. Ele sunt publice.

Observații

accesul la membri clasei, indiferent dacă sunt date sau funcții, se face asemănător cu cel al câmpurilor unei structuri, prin operatorul de acces direct . (punctul), sau, în cazul pointerilor la clase, prin operatorul de acces indirect ->.

Fractie X;
 X.afiseaza();

metodele unei clase pot fi descrise în modul următor:

Principiul încapsulării recomandă să fie publice numai anumite metode ale clasei, prin care să se poată modifica starea obiectului - valorile proprietăților sale, iar acestea din urmă să fie private. Tot private vor fi și metodele care sunt necesarea pentru gestionarea proprietăților obiectului, dar care nu trebuie apelate din exteriorul clasei.

Constructori

Constructorul reprezintă un mecanism prin care datele membre ale unui obiect dintr-o clasă primesc valori la instanțierea (declararea/crearea) obiectului.

constructorii sunt metode (funcții membre) ale clasei și se apelează la instanțierea obiectului

constructorul:

este o metodă a clasei

are același nume cu clasa

este o funcție fără tip; la declarare/definire în locul tipului funcție nu se scrie nimic, nici măcar void

o clasă poate avea mai mulți constructori, care diferă prin numărul și tipul parametrilor

constructorii sunt funcții; blocul lor poate conține orice fel de instrucțiuni care reflectă logica clasei pe care o definim!

Exemplu
class Fractie{
    private:
        int numarator, numitor;
        void simplifica(){
        	int a = numarator, b = numitor , r;
            while(b)
            	r = a % b, a = b, b = r;
            numarator /= a, numitor /= a;
        }
    public:
		void afiseaza(){
			cout << numarator << "/" << numitor << endl;
		}
		void seteaza(int a , int b){
            numarator = a , numitor = b;
        }
		Fractie(){
			numarator = 0, numitor = 1;
		}
		Fractie(int a){
			numarator = a, numitor = 1;
		}
		Fractie(int a , int b){
			if(b == 0)
				b = 1;
			numarator = a, numitor = b;
            simplifica();
		}
};

int main(){
	Fractie x;
	x.afiseaza();
	Fractie y(3);
	y.afiseaza();
	Fractie z(3 , 2);
	z.afiseaza();
	return 0;
}
Observații

în lipsa unui constructor definit de programator, se va apela constructorul implicit - el permite declararea obiectelor, alocând memorie pentru ele;

dacă o clasă are constructor cu parametri, constructorul implict nu mai există. În consecință, nu se pot declara obiecte fără parametri, ceea ce este de multe ori necesar. De aceea, dacă o clasă are constructor, este necesar să aibă și constructor fără parametri, prin care un datele membre ale obiectului declarat să primească valorile pe care le consideram implicite.

Constructor de copiere

Constructorul de copiere creează un obiect inițilizândul cu un alt obiect, din aceeași clasă, care există deja. El se folosește pentru:

inițializarea unui obiect cu un alt obiect

transmiterea prin valoare a unui obiect ca parametru pentru o funcție

copierea unui obiect returnat de o funcție

Clasele au un constructor de copiere implicit, care realizează copierea bit-cu-bit a conținutului obiectului. Acest mod de copiere nu este corect atunci când obiectul conține date alocate dinamic, caz în care este mecesară definirea unui constructor de copiere explicit.

Sintaxa este:

NumeClasa (const NumeClasa &);

Exemplu:

Fractie(const Fractie & F)
{
	numarator = F.numarator();
    numitor = F.numitor();
    simplifica();
}

Destructor

Destructorul este o metodă publică care se apelează la eliminarea din memorie a unui obiect. O clasă poate avea un singur destructor, iar numele lui este identic cu al metodei, dar precedat de caracterul ~. Destructorul, similar cu destructorul, este o funcție fără tip. Destructorul nu are parametri.
Exemplu
class Fractie{
    private:
        int numarator, numitor;
    public:
		void afiseaza(){
			cout << numarator << "/" << numitor << endl;
		}
		...
		~Fractie(){
			cout << "Fractia " << numarator << "/" << numitor << " a fost eliminata." << endl;
		}
};

int main(){
	Fractie x(1 , 4);
	x.afiseaza();

	return 0;
}

Regula celor Trei

Dacă o clasă are nevoie de unul dintre următoarele:

un constructor de copiere

operator de atribuire

destructor

atunci, foarte probabil, are nevoie de toate trei!
Funcții prietene

Uneori este necesar ca din interiorul unor funcții care nu sunt metode ale unui obiect să accesăm membrii privați ai acestuia. Acest lucru poate fi realizat prin intermediul funcțiilor prietene. Ele:

sunt declarate în interiorul clasei; prototipul lor este precedat de cuvântul cheie friend

funcția prieten are un parametru de tipul clasei; în funcție se pot accesa membrii privați ai acesteia

funcțiile prietene nu sunt metode ale clasei; ele nu pot accesa direct membrii clasei, ci numai membrii parametrului de tipul clasei

Exemplu:

class Fractie{
    private:
        int numarator, numitor;
    public:
		...
		friend void Afiseaza(Fractie F);
};

void Afiseaza(Fractie F)
{
	cout << F.numarator << "/" << F.numitor << endl;
}

int main(){
	Fractie x(1 , 4);
	Afiseaza(x);

	return 0;
}

Cuvântul cheie this

În definiția metodelor unei clase, cuvântul cheie this reprezintă un pointer către obiectul curent.

Este necesar în următoarele situații:

parametrii unor metode au același nume cu datele membre. Exemplu: clasa fracție conține câmpul numarator și o metodă are un parametru cu același nume, atunci parametrul poate fi referit prin identificatorul numarator, iar câmpul prin expresia this->numarator sau (*this).numarator;

uneori este necesar ca o metodă să returneze obiectul curent, sau o referință la obiectul curent;

Exemplu:

class Fractie{
    private:
        int numarator, numitor;
    public:
		...
		Fractie & creste(int n)
		{
			this->numarator += n * this->numitor; // aici this nu este necesar
			return * this;
		}
		friend void Afiseaza(Fractie F);
};

void Afiseaza(Fractie F)
{
	cout << F.numarator << "/" << F.numitor << endl;
}

int main(){
	Fractie x(1 , 4);
	Afiseaza(x);
	x.creste(2).creste(3);
	Afiseaza(x);
	return 0;
}

Un exemplu complet

Programul de mai jos implementează clasa Fractie și reprezintă o soluție pentru problema #spfractii :

respectă principiul încapsulării;

conține:

proprietăți (private);

metode private;

metode publice;

constructor;

constructor de copiere;

funcții prietene;

this. Prin intermediul său, metodele vor returna obiectul curent, fapt ce permite înlănțuirea acestora - vezi apelul funcției Produs().

#include <iostream>

using namespace std;

class Fractie{
	private:
		int numarator, numitor;	// proprietăți
		void simplifica();		// metodă privată
	public:
		Fractie(int _numarator = 0, int _numitor = 1); // constructor
		Fractie(const Fractie &);	// constructor de copiere
		Fractie & citeste();	//	metodă publică
		Fractie & scrie();		// metodă publică
		friend Fractie Suma(Fractie , Fractie);	// functie prietena
		friend Fractie Produs(Fractie , Fractie);	// functie prietena
};

Fractie::Fractie(const Fractie & F)
{	// constructor de copiere
	numarator = F.numarator;
	numitor = F.numitor;
	simplifica();
}

Fractie::Fractie(int _numarator /* = 0 */, int _numitor /* = 1 */)
{	// constructor
	numitor = _numitor, numarator = _numarator;
	simplifica();
}
Fractie & Fractie::citeste()
{
	// citeste numaratorul si numitorul obiectului curent
	// returnează obiectul curent
	cin >> numarator >> numitor;
	return * this;
}

Fractie & Fractie::scrie()
{
	// afisează numaratorul si numitorul obiectului curent
	// returnează obiectul curent
	cout << numarator << " " << numitor <<endl;
	return * this;
}

void Fractie::simplifica()
{	//metoda privata; realizeaza simplificarea fractiei merorate în obiectul curent
	int a = numarator, b = numitor;
	while(b)
	{
		int r = a % b;
		a = b;
		b = r;
	}
	numarator /= a;
	numitor /= a;
}

Fractie Suma(Fractie F, Fractie G)
{
	// funcție prietenă. Putem accesa datele private ale obiectelor F , G
	int x = F.numarator * G.numitor + F.numitor * G.numarator,
		y = F.numitor * G.numitor;
	Fractie Rez(x , y); // s-a apelat constructorul pentru crearea obiectului. Aici s-a făcut simplificarea
	return Rez; // s-a apelat costructorul de copiere
}

Fractie Produs(Fractie F, Fractie G)
{
	// funcție prietenă. Putem accesa datele private ale obiectelor F , G
	int x = F.numarator * G.numarator,
		y = F.numitor * G.numitor;
	return Fractie(x , y); // se apelează constructorul de copiere. Aici se face simplificarea
}

int main()
{
	Fractie A , B;
	A.citeste(), B.citeste();
	Fractie S = Suma(A , B);
	S.scrie();
	Produs(A , B).scrie();
	return 0;
}

# data[].attributes.attachment_link.description
Generalități În programarea procedurală, un program era alcătuit din două componente distincte: date și funcții; funcțiile prelucrează datele la care au acces, prin intermediul parametrilor sau în a

# data[].attributes.body
Utilizarea șabloanelor pentru a crea funcții și clase generice.

# data[].attributes.attachment_link.description
În acest exemplu, funcțiile au un comportament diferit: versiunea cu int înmulțește argumentele, în timp ce versiunea cu double le împarte. Aceasta nu este o idee prea bună, în general. De obicei, se așteaptă ca două funcții cu acelasi nume să aibă un comportament asemănător - cel puțin, dar acest exemplu arată că se poate și altfel. Două funcții surpaîncărcate (adică două funcții cu același nume) au definiții complet diferite; întotdeauna, ele sunt două funcții diferite, pentru care doar numele este la fel.

# data[].attributes.body
Cum să tratăm excepțiile și să scriem cod robust.

# data[].attributes.attachment_link.description
Explore this post and more from the Cplusplus community

# data[].attributes.body
O listă cu compilatoare gratuite și cum să le utilizăm.

# data[].attributes.attachment_link.title
13 Cele mai bune gratuit C++ IDE (Editor și compilator) pentru Windows

# data[].attributes.attachment_link.description
C++ este un limbaj de programare orientat pe obiecte de uz general dezvoltat de Bjarne Stroustrup. Conține caracteristicile limbajului de programare C, precum și Simula67 (un prim limbaj orientat pe obiecte).

# data[].attributes.body
Biblioteci frecvent utilizate care facilitează programarea.

# data[].attributes.attachment_link.description
Bibliotecile sunt librării de funcții predefinite, pe care le includem în directiva de preprocesare.La nivel de liceu, folosim 7 dintre acestea: iostream, fstream, cstring, algorithm, cmath, climits și iomanip.

# data[].attributes.body
O listă de resurse pentru a practica algoritmii și problemele în C++.

# data[].attributes.attachment_link.readable_text
Vă invităm să participați la concursul InfoPRO, organizat de un grup de profesori și absolvenți olimpici, pentru a sprijini elevii în condițiile dificile provocate de pandemie.
UPDATE 23 octombrie 2020:
Pbinfo a fost mutat în casă nouă! Mulțumim tuturor celor care au contribuit la reușita acestui demers!
UPDATE 11 octombrie 2020:
Dulapul a fost livrat, a fost montat și așteaptă să fie ocupat. Credem că "evenimentul" se va petrece în săptămâna 19-23 octombrie.
UPDATE:
Suma necesară a fost obținută, ba chiar depășită. S-au adunat 4588.40 RON, care vor fi utilizați în scopul precizat. Surplusul va fi folosit pentru o achiziție ulterioară, când se va dovedi necesară.

Mulțumesc sincer tuturor celor care s-au implicat! Am fost impresionat de solidaritatea pe care ați dovedit-o!

Cu stimă,
prof. Silviu Candale
Mulțumim celor care au ajutat: Text inițial
Dragi utilizatori,

Pbinfo funcționează prin intermediul a 5 sisteme de calcul interconectate. Ele se află în acest moment într-un spațiu care în viitorul apropiat nu va mai fi disponibil.

Pentru ca Pbinfo să funcționeze în continuare, ele vor fi mutate într-un alt spațiu, în care trebuie obligatoriu închise într-un dulap pentru echipamente de rețea, de care nu dispunem în acest moment.

Costul de achiziție/montaj pentru dulap și accesorii (ventilator, tăvi, role) este de aproximativ 3500 LEI.

Dacă observați erori în funcționarea pbInfo, vă rugăm să le raportați, adăugând un răspuns la această postare sau folosind formularul de contact.
Înainte de a posta, verificați următoarele:
dacă programul pare corect dar obține 0 puncte:

s-ar putea să afișeze mai mult decât se cere. Acest articol vă poate ajuta.

verificați să corespundă citirile/scrierile din program cu cele din enunț. Poate se cere să lucrați cu fișiere și lucrați cu tastatura, sau invers.

verificați să nu existe variabile neinițializate. Comportamentul programului este impredictibil în acest caz!

dacă programele C++ cu șiruri de caractere nu funcționează corect:

pe site se folosesc compilatoarele GNU. NU toate funcțiile disponibile în alte versiuni apar aici. De exemplu strrev, itoa nu pot fi folosite. Lista funcțiilor permise!

dacă folosiți funcția C/C++ strcpy pentru a șterge sau insera caractere, acest articol vă poate ajuta.

dacă nu vă puteți autentifica, încercați să ștergeți cookie-urile din browser sau să folosiți alt browser. Foarte probabil este o eroare locală.

dacă ați rezolvat o problemă și pe site nu apare imediat ca rezolvată, aveți răbdare. Va apărea în cel mult 10 minute!

Mulțumim!
Pentru rezolvarea problemelor cu șiruri de caractere în C/C++ țineți cont de aceste informații!!!

# data[].attributes.attachment_link.description
Vă invităm să participați la concursul InfoPRO, organizat de un grup de profesori și absolvenți olimpici, pentru a sprijini elevii în condițiile dificile provocate de pandemie. UPDATE 23 octombrie 2020: Pbinfo a fost mutat în casă nouă! Mulțumim tuturor celor care au contribuit la reușita acestui demers!