Menú

Classes i objectes en C ++

classes objects c

Proveu El Nostre Instrument Per Eliminar Problemes

Una breu introducció a classes i objectes en C ++.

Les classes i els objectes són els components bàsics de la programació orientada a objectes en C ++. Tota entitat, viva o no viva, es pot representar com a objecte i programar-se en conseqüència mitjançant C ++. Així, es poden representar entitats com un cotxe, un escriptori, una persona, un ocell, un animal, etc.

La classe és un nivell superior a l'objecte i representa la categoria d'objectes. Per tant, la classe actua com un pla que descriu el disseny i els detalls de l’objecte. Això inclou dades que s’utilitzen per descriure l’objecte i diversos mètodes o funcions que poden actuar sobre les dades de l’objecte.

=> Mireu aquí la sèrie d'entrenament C ++ simple.

En aquest tutorial, discutim tots els detalls de la classe i els objectes en C ++ juntament amb la seva representació programàtica.

Classes i objectes en C ++

Què aprendreu:

Classes

Una classe en C ++ es pot veure com un pla o un esquelet d'una entitat concreta. Class és un tipus de dades definit per l'usuari. Conté la informació o dades generals per a aquesta entitat en particular i les funcions que operen en aquesta entitat.

A la sintaxi C ++, definim una classe amb la paraula clau 'class' seguida del nom de la classe.

El nom de la classe va seguit dels detalls de la classe inclosa entre claus i s’acaba amb un punt i coma.

El bloc següent mostra la sintaxi general per a la definició de classe.

Sintaxi general de classes

Com es mostra a la representació anterior, la classe pot tenir especificadors d’accés com públic / protegit / privat. Pot tenir membres de dades i funcions de membre. Les dades i funcions s’anomenen membres de la classe. Per defecte, els membres són privats de la classe, de manera que cap entitat externa no té accés a aquests membres.

Per exemple, un vehicle pot ser una classe generalitzada que tingui propietats com ara un model, un color, un número de xassís, una velocitat mitjana, etc. Pot tenir funcions com changeModel, accelerar, frenar, etc. que realitzen accions als membres de les dades. Podem definir una classe anomenada 'vehicle' que tindrà tots aquests membres i funcions de dades.

Com ja s'ha esmentat, una classe és només un pla per a les entitats. No es necessita cap espai a la memòria quan es defineix. Perquè una classe sigui funcional, hem de definir objectes que puguin fer ús dels membres de la classe.

Objectes

Per tal d’utilitzar la funcionalitat de la classe, hem d’instanciar la classe per crear un objecte. Un objecte és una instància d'una classe. En paraules simples, podem dir que un objecte és una variable de classe tipus.

La sintaxi general per crear un objecte és:

classname object_name;

Un cop creat l'objecte, es pot utilitzar per accedir als membres de les dades i a les funcions d'aquesta classe.

L’accés als membres de la classe (dades i funcions) es fa mitjançant l’operador dot (.), Que també s’anomena operador d’accés membre.

Si obj és el nom de l'objecte i hi ha una funció 'display ()' a la classe, es pot accedir a la funció com a 'obj.display ()'.

No obstant això, hi ha un problema a la declaració anterior. Podem accedir a la funció display () mitjançant un objecte i l’operador de punts si la funció és “pública”.

Especificadors d'accés

A C ++, accedir als membres de les dades i a les funcions de la classe depèn de l’accés que es doni a aquest membre o funció en concret mitjançant un especificador d’accés.

C ++ admet els següents especificadors d'accés:

# 1) Privat

Aquest és l'especificador d'accés per defecte per a una classe en C ++. Això significa que si no s’especifica cap especificador d’accés per als membres d’una classe, es considera privat.

Quan un membre és privat, no s’hi pot accedir fora de la classe. Ni tan sols amb l’objecte i l’operador de punts. Només es pot accedir als membres de dades privades mitjançant les funcions de membre de la classe.

Preguntes i respostes de l'entrevista mysql per a una experiència de 3 anys

No obstant això, hi ha una excepció a aquesta regla, que parlarem en els nostres temes posteriors.

# 2) Públic

Un membre o una funció de dades que es defineix com a públic a la classe és accessible per a tothom fora de la classe. Es pot accedir a aquests membres mitjançant l’operador objecte i punt.

# 3) Protegit

Un membre protegit d’una classe és accessible per a la mateixa classe i per a les classes infantils d’aquesta classe.

Aquest especificador d'accés s'utilitza especialment en cas d'herència i ho discutirem detalladament mentre discutim el tema de l'herència.

Prenguem l'exemple següent per entendre millor aquests especificadors d'accés.

#include #include using namespace std; class ABC{ int var1 = 10; public: string name; void display() { cout<<'var1 ='<

Sortida:

var1 = 10
nom = c

En aquest programa, tenim dos membres de dades dels quals var1 de tipus int és privat (no s'ha especificat l'accés a l'especificador. El valor per defecte és privat). Un altre membre és el nom de la cadena, que es declara públic. Tenim una altra pantalla que mostra el valor de tots dos membres.

A la funció principal, declarem un objecte abc de la classe ABC. A continuació, establim valors als membres de les dades i també la visualització de la funció de trucada mitjançant l’objecte ‘abc’.

Tanmateix, quan el compilador troba la línia abc.var1 = 20; generarà un error que 'var1 és variable privada'.

Això es deu al fet que no podem accedir a membres de dades privades d'una classe fora de la classe. Per tant, hi ha un error. Però hi podem accedir dins de la funció i, per tant, quan generem el valor de var1 a la funció de visualització; no llença cap error.

Per tant, la sortida del programa mostra el valor inicial amb què es declara var1.

Fins ara, hem vist els detalls sobre les classes, els objectes i els especificadors d’accés; ara prenem un exemple complet d’un exemple de classe. Aquesta classe té membres de dades: student_id, student_name i student_age. També té funcions de membre per llegir la informació dels estudiants i mostrar la informació dels estudiants.

Per tal de facilitar les coses als lectors, hem declarat tots els membres de la classe com a públics.

El programa següent mostra la implementació completa.

#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; void read_studentInfo(); void print_studentInfo() { cout<<' Student ID : '<student_id; cout<>student_name; cout<>student_age; } int main() { student s1; s1.read_studentInfo(); s1.print_studentInfo(); }

Sortida:

Introduïu l’identificador de l’alumne: 1

Introduïu nom_estudiant: abc

Introduïu student_age: 12

DNI d’estudiant: 1
Nom de l’alumne: abc
Edat dels estudiants: 12

Per tant, tenim una classe completa definida anteriorment. L'única diferència notable és que hem definit una funció 'print_studentInfo' dins de la classe mentre que una altra funció 'read_studentinfo' es defineix fora de la classe. Aquestes són les dues maneres en què es poden definir les funcions de membre per a una classe.

Tingueu en compte que la funció que es defineix fora encara té una declaració / prototip dins de la classe. A més, es defineix fora de la classe mitjançant el fitxer operador de resolució d'abast (: :) . A continuació, a la funció principal, creem un objecte de classe per a estudiants i després cridem funcions per llegir i mostrar les dades.

Constructors

Fins ara en aquest tutorial, hem creat un objecte senzill i després assignem valors a cada membre de la classe de la funció principal després de llegir aquests valors de l'entrada estàndard.

En aquest tema, veurem una funció especial que s’utilitza per inicialitzar l’objecte durant la seva creació. Aquesta funció especial s'anomena constructor.

Un constructor és una funció membre de la classe, però difereix de la funció membre normal de les maneres següents:

  1. El constructor no té cap valor de retorn, és a dir, el constructor mai no retorna cap valor.
  2. És una funció de membre públic de la classe.
  3. S'utilitza per inicialitzar els membres de les dades i construir l'objecte de la classe.
  4. El compilador el crida automàticament quan es crea l'objecte.

Tipus de constructors

C ++ admet els següents tipus de constructors.

# 1) Constructor per defecte

Un constructor per defecte és el constructor bàsic i no té paràmetres. Podem crear un objecte senzill sense cap paràmetre mitjançant el constructor per defecte.

El constructor per defecte té la sintaxi següent:

classname() { //constructor code }

Si una classe no té un constructor per defecte, el compilador la crea.

# 2) Constructor parametritzat

Un constructor parametritzat és aquell que té una llista de paràmetres mitjançant la qual podem inicialitzar els membres de la classe. Quan declarem un objecte en un constructor parametritzat, hem de passar valors inicials a la funció del constructor com a paràmetres.

Una funció constructora parametritzada es veu com es mostra a continuació.

classname(argument list){ //constructor code }

Un constructor parametritzat s’utilitza per sobrecarregar els constructors. Veurem més informació sobre la sobrecàrrega en els nostres temes posteriors.

Un constructor parametritzat s'utilitza per inicialitzar membres de dades de diferents objectes. En fer-ho, podem passar diferents valors dels membres de les dades a diferents objectes.

# 3) Còpia de constructors

C ++ admet un tercer tipus de constructor conegut com a constructor de còpia. La seva forma general és

classname (const classname & obj);

Com es mostra a la declaració anterior, en el constructor de còpies es crea un nou objecte utilitzant els valors d’un altre objecte de la mateixa classe. El paràmetre que es passa al constructor és la referència constant d'un objecte els valors del qual s'utilitzaran per a la construcció del nou objecte.

Un constructor de còpies se sol cridar en les situacions següents:

  1. Quan un objecte de classe es retorna per valor.
  2. Quan un objecte es passa a una funció com a argument i es passa per valor.
  3. Quan un objecte es construeix a partir d’un altre objecte de la mateixa classe.
  4. Quan el compilador genera un objecte temporal.

Tot i això, no podem garantir que el constructor de còpies es cridi segurament en tots els casos anteriors, ja que el compilador C ++ té una manera d’optimitzar les operacions de còpia.

Un constructor de còpies realitza còpies entre membres entre objectes. Igual que el constructor per defecte, el compilador C ++ crea un constructor de còpia per defecte si no en proporcionem cap al nostre programa. Però quan una classe té determinats membres de dades com a punters, referències o qualsevol assignació de recursos en temps d'execució, hem de tenir el nostre propi constructor de còpies definit per l'usuari.

La raó és que el constructor de còpies per defecte només realitza una còpia poc profunda dels membres de les dades, és a dir, que tots dos objectes compartiran la mateixa ubicació de memòria. Això està bé per als membres de dades senzills que no són punteres.

Tanmateix, quan es tracta de punteres o de qualsevol altre membre de dades dinàmiques, ens agradaria que les dades es dirigissin a una nova ubicació de memòria. Aquesta és la còpia profunda i només es pot aconseguir mitjançant un constructor de còpia definit per l'usuari.

A continuació es mostra un programa C ++ complet que implementa els tres tipus de constructors i el seu ús en la construcció d’un objecte.

es pot fer una gran quantitat d'objectes a Java
#include #include using namespace std; class student{ public: int student_id; string student_name; int student_age; //default constructor student(){ student_id = 1; student_name = 'abc'; student_age = 10; } //parameterized constructor student(int id,string name,int age){ student_id = id; student_name = name; student_age = age; } //copy constructor student(const student& st){ student_id = st.student_id; student_name = st.student_name; student_age = st.student_age; } void print_studentInfo() { cout<<' Student ID : '<

Sortida:

********** s **********
DNI d’estudiant: 1
Nom de l’alumne: abc
Edat dels estudiants: 10

********** s2 **********
DNI d’estudiant: 2
Nom de l’alumne: xyz
Edat dels estudiants: 12

A continuació es mostra la captura de pantalla del mateix.

sortida de constructors

En aquest programa, hem definit un estudiant de classe similar al definit en el programa anterior. La diferència és que en lloc de llegir els valors dels membres de dades des de l'entrada estàndard a través d'una funció, definim tres constructors.

És absolutament possible que una classe tingui més d’un constructor. Tenim un constructor predeterminat que inicialitza els membres de les dades fins als valors inicials. A continuació, definim un constructor parametritzat que passa els valors inicials com a paràmetres al constructor.

A continuació, definim un constructor de còpies al qual passem una referència constant a un objecte de la classe dels estudiants.

A la funció principal, creem tres objectes per separat mitjançant tres constructors. El primer objecte s es crea amb el constructor per defecte. El segon objecte s1 es crea amb el constructor parametritzat, mentre que el tercer objecte s2 es crea amb un constructor de còpia.

Fixeu-vos en la creació del tercer objecte s2. Aquí assignem l'objecte s1 ja creat al nou objecte s2. Així, quan construïm un objecte nou amb l'objecte ja existent, el compilador crida un constructor de còpies.

Operador de tasques

També podem assignar els valors d’un objecte a un altre mitjançant un operador d’assignació (=). En aquest cas, tindrem una afirmació com s1 = s.

La diferència entre el constructor de còpia i l’operador d’assignació és que, mentre el constructor de còpia construeix un objecte nou, l’operador d’assignació només assigna els valors d’un membre de l’objecte a RHS al de l’objecte a LHS. Això vol dir que els objectes dels dos costats d'un operador d'assignació han d'existir abans de l'assignació.

Destructors

Un destructor també és una funció especial com un constructor, però implementa la funcionalitat que és exactament oposada al constructor. Mentre que el constructor s’utilitza per crear un objecte, un destructor s’utilitza per destruir o eliminar un objecte.

Algunes de les característiques del destructor són:

  • Un nom de destructor és el mateix que el nom de classe, però comença amb un signe de titlla (~).
  • El destructor no té cap tipus de retorn.
  • Un destructor no té arguments.
  • Només hi pot haver un destructor en una classe.
  • El compilador sempre crea un destructor per defecte si no proporcionem cap per a una classe.

La sintaxi general d'un destructor és:

~classname(){ //cleanup code }

El destructor d'una classe se sol anomenar en les situacions següents:

  1. Quan l'objecte surt de l'abast, es crida automàticament al destructor de classes.
  2. De la mateixa manera, el destructor es diu quan el programa acaba l'execució. Això significa que tots els objectes també deixen d’existir. Per tant, es cridarà el destructor de cada objecte.
  3. El destructor de la classe també es diu quan s’executa l’operador ‘delete’ per suprimir un objecte.
  4. També podem trucar explícitament al destructor per realitzar qualsevol activitat de neteja un cop hàgim acabat la funcionalitat de l'objecte.

L'exemple que es mostra a continuació mostra el funcionament d'un destructor.

#include using namespace std; class sample{ public: sample(){ cout<<'Constructor::sample called'<

Sortida:

Constructor :: mostra anomenada

Aquesta és una classe de mostra

Destructor :: ~ mostra anomenada

A continuació es mostra la captura de pantalla de la sortida anterior.

sortida destructora

Hem definit una mostra de classe en què hem definit un constructor, un destructor i una visualització de funcions. A la funció principal, creem un objecte object de mostra de classe i després cridem a la funció de visualització d’aquest objecte.

Després d'això, s'executa un retorn 0. A la sortida, podem veure que en el moment en què torna la funció de visualització i el control del programa arriba a la sentència return 0, s’executa el destructor. Això significa que s'executa en el moment en què l'objecte surt de l'abast.

Punter 'aquest'

C ++ utilitza un concepte especial relacionat amb els objectes, que es coneix com a punter 'aquest'. El punter 'això' sempre apunta a l'objecte actual. Així, segons la situació, sempre que hem de fer referència a l'objecte actual, fem servir el punter 'aquest'.

Sabem que cada vegada que es crea una instància de la classe, és a dir, un objecte, es fa una còpia separada dels membres de la classe de l’objecte. Però quan es tracta de les funcions membres de la classe, tots els objectes comparteixen la mateixa còpia.

Llavors, quan un o més objectes accedeixen simultàniament a les funcions de membre, com ens assegurem que les funcions de membre accedeixin i modifiquin els membres de dades adequats?

Aquest és el lloc on 'aquest' punter entra en acció. El compilador passa un punter implícit amb el nom de la funció com a 'això'. Això s'anomena el punter 'això'.

El punter 'això' es passa com un argument ocult a totes les trucades de funció membre. Normalment és una variable local. Per tant, el punter 'aquest' és un punter constant i el seu contingut és l'adreça de memòria de l'objecte actual.

Tingueu en compte que aquest punter només està disponible per a funcions de membres no estàtiques i no per a funcions estàtiques. Això es deu al fet que no és necessari accedir a les funcions estàtiques mitjançant un objecte. Es pot accedir directament mitjançant el nom de classe.

Normalment fem servir el punter 'això' en situacions en què es passen les variables membres i els paràmetres per inicialitzar les variables membres que comparteixen el mateix nom. També l’utilitzem quan hem de retornar l’objecte actual de la funció.

Vegem la demostració d’aquest “punter” a continuació.

#include using namespace std; class Sample { private: int num; char ch; public: Sample &setParam(int num, char ch){ this->num =num; this->ch = ch; return *this; } void printValues(){ cout<<'num = '<

Sortida:

num = 100
ch = A

Al programa anterior, tenim una classe anomenada Sample, amb dos membres num i ch. Tenim una funció membre setParam que passa els paràmetres amb els mateixos noms, num i ch per establir els valors de les variables membres.

Dins de la funció, assignem aquests valors a les variables membres de l’objecte actuals que indica aquest punter. Un cop establerts els valors, l'objecte actual 'això' es retorna de la funció.

A la funció principal, primer creem un objecte de classe Sample, obj i cridem a una funció setParam per establir els valors i després cridem a la funció printValues ​​per imprimir els valors.

com veure un fitxer MKV

Conclusió

Hem après els blocs bàsics d’OOP en C ++ en aquest tutorial. Comprendre les classes i els objectes són els requisits principals, per començar, OOP en C ++. També hem conegut detalladament els constructors i destructors amb exemples.

Al nostre proper tutorial, coneixerem les llistes d'inicialitzadors en C ++.

=> Mireu aquí la sèrie d'entrenament C ++ simple.

Lectura recomanada

^