C++ Structurați cu exemplu

De exemplu:

Să presupunem că trebuie să stocați informații despre cineva, numele, cetățenia și vârsta acestuia. Puteți crea variabile precum numele, cetățenia și vârsta pentru a stoca datele separat.

Cu toate acestea, poate fi necesar să stocați informații despre multe persoane în viitor. Înseamnă că vor fi create variabile pentru diferiți indivizi. De exemplu, nume1, cetățenie1, vârstă1 etc. Pentru a evita acest lucru, este mai bine să creați o structură.

Când să folosiți o structură?

Iată câteva motive pentru utilizarea structurii în C++.

• Utilizați o structură atunci când trebuie să stocați elemente de diferite tipuri de date sub un singur tip de date.
• C++ Structurile sunt mai degrabă un tip de valoare decât un tip de referință. Utilizați o structură dacă nu intenționați să vă modificați datele după creare.

C++ Inițializarea structurii

Pentru a crea un C++ structura, folosim cuvântul cheie struct, urmat de un identificator. Identificatorul devine numele structurii. Iată sintaxa pentru crearea a C++ structura:

Sintaxă:

struct struct_name  
{  
     // struct members
}   

În sintaxa de mai sus, am folosit cuvântul cheie struct. Numele_structurii este numele structurii.

Membrii structurii sunt adăugați în acolade. Acești membri aparțin probabil unor tipuri de date diferite.

De exemplu:

struct Person  
{  
    char name[30];  
     int citizenship;  
     int age;  
}  

În exemplul de mai sus, Persoană este o structură cu trei membri. Membrii includ numele, cetățenia și vârsta. Un membru este de tip de date char, în timp ce restul de 2 sunt numere întregi când se creează o structură, memoria nu este alocată. Memoria este alocată numai după ce o variabilă este adăugată la structura.

Crearea de instanțe de structură

În exemplul de mai sus, am creat o structură numită Person. Putem crea o variabilă struct după cum urmează:

Person p;

p este o variabilă struct de tip Person. Putem folosi această variabilă pentru a accesa membrii structurii.

Accesarea membrilor Struct

Pentru a accesa membrii structurii, folosim instanța structurii și operatorul punct (.). De exemplu, pentru a accesa vârsta membrului struct Person:

p.age = 27;

Am accesat vârsta membrului struct Person folosind instanța struct-ului, p. Apoi am stabilit valoarea vârstei membrului la 27 de ani.

Exemplu 1:

#include <iostream>    
using namespace std;
struct Person
{
	int citizenship;
	int age;
};
int main(void) {
	struct Person p;
	p.citizenship = 1;
	p.age = 27;
	cout << "Person citizenship: " << p.citizenship << endl;
	cout << "Person age: " << p.age << endl;

	return 0;
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includeți fișierul antet iostream în programul nostru pentru a utiliza funcțiile definite în acesta.
2. Includeți spațiul de nume std pentru a-și folosi clasele fără a-l apela.
3. Creați o structură numită Persoană.
4. Începutul corpului structurii.
5. Creați un membru struct numit cetățenie de tipul întreg.
6. Creați un membru al structurii denumit vârsta de tipul întreg.
7. Sfârșitul corpului structurii.
8. Apelați funcția main(). Logica programului ar trebui adăugată în corpul acestei funcții.
9. Creați o instanță a structurii Person și dându-i numele p.
10. Setați valoarea cetățeniei de membru struct la 1.
11. Setați valoarea vârstei membrului struct la 27.
12. Imprimați valoarea cetățeniei de membru struct pe consolă alături de alt text.
13. Tipăriți valoarea vârstei membrului struct pe consolă alături de alt text.
14. Programul ar trebui să returneze o valoare dacă rulează cu succes.
15. Sfârșitul funcției main().

Indicatori către Structură

Este posibil să creați un pointer care să indice o structură. Este similar cu modul în care sunt create pointerii care indică către tipuri de date native precum int, float, double etc. Rețineți că un indicator în C++ va stoca o locație de memorie.

Exemplu 2:

#include <iostream>
using namespace std;

struct Length
{
	int meters;
	float centimeters;
};

int main()
{
	Length *ptr, l;

	ptr = &l;

	cout << "Enter meters: ";
	cin >> (*ptr).meters;
	cout << "Enter centimeters: ";
	cin >> (*ptr).centimeters;
	cout << "Length = " << (*ptr).meters << " meters " << (*ptr).centimeters << " centimeters";

	return 0;
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includeți fișierul antet iostream în programul nostru pentru a utiliza funcțiile acestuia.
2. Includeți spațiul de nume std în programul nostru pentru a-i folosi clasele fără a-l apela.
3. Creați o structură numită Lungime.
4. Începutul corpului structurii Lungime.
5. Creați un membru struct numit meters de tip de date întreg.
6. Creați un membru al structurii numit centimetri de tipul întreg.
7. Sfârșitul corpului structurii Lungime.
8. Apelați funcția main().
9. Începutul corpului funcției main().
10. Creați o variabilă pointer *ptr și o variabilă normală l de tip Length.
11. Stocați adresa variabilei l în nostru variabila pointer.
12. Afișează un mesaj pe consolă, solicitând utilizatorului să introducă valoarea pentru contoarele variabile.
13. Citiți valoarea introdusă de utilizator prin tastatură. Contoarele de funcții membre sunt accesate aici folosind variabila pointer.
14. Afișează un mesaj pe consolă, solicitând utilizatorului să introducă valoarea pentru centimetri variabili.
15. Citiți valoarea introdusă de utilizator prin tastatură. Funcția membru centimetri este accesată aici folosind variabila pointer.
16. Afișați valorile citite de utilizator pe consolă alături de alt text.
17. Programul trebuie să returneze o valoare la executarea cu succes.
18. Sfârșitul corpului funcției main().

Structura ca argument al funcției

Puteți trece o structură unei funcții ca argument. Acest lucru se face în același mod ca și transmiterea unui argument normal. Variabilele struct pot fi, de asemenea, transmise unei funcții. Un bun exemplu este atunci când trebuie să afișați valorile membrilor structurii. Să demonstrăm asta:

Exemplu 3:

#include<iostream>
using namespace std;

struct Person
{
	int citizenship;
	int age;
};

void func(struct Person p);

int main()
{
	struct Person p;

	p.citizenship = 1;
	p.age = 27;

	func(p);
	return 0;
}
void func(struct Person p)
{
	cout << " Person citizenship: " << p.citizenship<<endl;
	cout << " Person age: " << p.age;
}

ieșire:

Iată o captură de ecran a codului:

Explicația codului:

1. Includeți fișierul antet iostream în fișierul nostru. Apoi vom folosi funcțiile sale fără a primi erori.
2. Includeți spațiul de nume std în programul nostru pentru a-i folosi clasele. Nu va trebui să apelăm spațiul de nume pentru a-i folosi clasele.
3. Creați o structură numită Persoană.
4. Începutul corpului structurii Persoană.
5. Creați un membru al struct Person. Membrul este numit cetățenie și este de tipul întreg.
6. Creați un membru al struct Person. Membrul se numește vârstă și este de tipul întreg.
7. Sfârșitul corpului structurii Persoană.
8. Creați o funcție care ia ca argument instanța struct Person, p.
9. Apelați funcția principală. { marchează începutul corpului funcției main().
10. Creați o instanță de struct Person și dându-i numele p.
11. Accesați variabila membru struct cetățenie folosind instanța structului, p și atribuindu-i valoarea 1.
12. Accesați variabila membru struct vârsta folosind instanța structului, p și atribuindu-i valoarea 27.
13. Apelați funcția și transmiteți-i instanța structurii Person, p, ca argument.
14. Funcția trebuie să returneze o valoare după executarea cu succes.
15. Sfârșitul corpului funcției main().
16. Creați corpul funcției.
17. Începutul corpului funcției.
18. Accesați valoarea cetățeniei membrilor struct și imprimați-o pe consolă alături de alt text.
19. Accesați valoarea de vârstă a membrului struct și imprimați-o pe consolă alături de alt text.
20. Sfârșitul corpului funcției.

Limitarea a C++ structura

Următoarele sunt limitările structurilor:

• Tipul de date struct nu poate fi tratat ca tipuri de date încorporate.
• Operatori ca + -, iar altele nu pot fi folosite variabile de structură.
• Structurile nu acceptă ascunderea datelor. Membrii unei structuri pot fi accesați de orice funcție, indiferent de domeniul acesteia.
• Membrii statici nu pot fi declarati in interiorul corpului structurii.
• Constructorii nu pot fi creați în interiorul unei structuri.

Rezumat

• O structură este o structură de date care stochează elemente de date aparținând unor tipuri diferite.
• În timp ce o matrice stochează elemente de date de un tip similar, o structură stochează elemente de date de diferite tipuri.
• O structură ar trebui utilizată atunci când elementele de date nu sunt de așteptat să își schimbe valoarea.
• Membrii unei structuri sunt accesați folosind operatorul punct (.).
• Trebuie să creăm o instanță a structurii.
• Pentru a crea un C++ struct, folosim cuvântul cheie struct.
• Pointerii care indică către o structură sunt creați în mod similar cu modul în care sunt creați pointerii care indică către tipuri obișnuite.
• O structură poate fi transmisă ca argument unei funcții în același mod în care sunt transmise funcțiile obișnuite.