C++ Estruturar com exemplo

Por exemplo:

Suponha que você precise armazenar informações sobre alguém, seu nome, cidadania e idade. Você pode criar variáveis ​​como nome, cidadania e idade para armazenar os dados separadamente.

No entanto, poderá ser necessário armazenar informações sobre muitas pessoas no futuro. Isso significa que serão criadas variáveis ​​para diferentes indivíduos. Por exemplo, nome1, cidadania1, idade1 etc. Para evitar isso, é melhor criar uma estrutura.

Quando usar uma Estrutura?

Aqui estão alguns motivos para usar estrutura em C++.

• Use uma estrutura quando precisar armazenar elementos de diferentes tipos de dados em um tipo de dados.
• C++ structs são um tipo de valor em vez de um tipo de referência. Use uma estrutura se não pretende modificar seus dados após a criação.

C++ Inicialização da estrutura

Para criar um C++ estrutura, usamos a palavra-chave struct, seguida por um identificador. O identificador se torna o nome da estrutura. Aqui está a sintaxe para a criação de um C++ estrutura:

Sintaxe:

struct struct_name  
{  
     // struct members
}   

Na sintaxe acima, usamos a palavra-chave struct. O struct_name é o nome da estrutura.

Os membros da estrutura são adicionados entre chaves. Esses membros provavelmente pertencem a tipos de dados diferentes.

Por exemplo:

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

No exemplo acima, Person é uma estrutura com três membros. Os membros incluem nome, cidadania e idade. Um membro é do tipo de dados char, enquanto os 2 restantes são inteiros quando uma estrutura é criada, a memória não é alocada. A memória só é alocada depois que uma variável é adicionada à estrutura.

Criando Instâncias Estruturais

No exemplo acima, criamos uma estrutura chamada Person. Podemos criar uma variável struct da seguinte maneira:

Person p;

O p é uma variável struct do tipo Person. Podemos usar esta variável para acessar os membros da estrutura.

Acessando membros da estrutura

Para acessar os membros da estrutura, usamos a instância da estrutura e o operador ponto (.). Por exemplo, para acessar a idade do membro da struct Person:

p.age = 27;

Acessamos a idade do membro da struct Person usando a instância da struct, p. Em seguida, definimos o valor da idade do membro como 27.

1 exemplo:

#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;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso programa para usar as funções nele definidas.
2. Inclua o namespace std para usar suas classes sem chamá-lo.
3. Crie uma estrutura chamada Person.
4. O início do corpo da estrutura.
5. Crie um membro struct chamado cidadania do tipo inteiro.
6. Crie um membro struct chamado age do tipo inteiro.
7. Fim do corpo da estrutura.
8. Chame a função main(). A lógica do programa deve ser adicionada ao corpo desta função.
9. Crie uma instância da estrutura Person e dê a ela o nome p.
10. Defina o valor da cidadania do membro struct como 1.
11. Defina o valor da idade do membro da estrutura como 27.
12. Imprima o valor da cidadania do membro da estrutura no console junto com algum outro texto.
13. Imprima o valor da idade do membro da estrutura no console junto com algum outro texto.
14. O programa deverá retornar um valor se for executado com sucesso.
15. Fim da função main().

Ponteiros para estrutura

É possível criar um ponteiro que aponta para uma estrutura. É semelhante a como ponteiros apontando para tipos de dados nativos como int, float, double, etc. são criados. Note que um ponteiro em C++ armazenará um local de memória.

2 exemplo:

#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;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso programa para usar suas funções.
2. Inclua o namespace std em nosso programa para usar suas classes sem chamá-lo.
3. Crie uma estrutura chamada Comprimento.
4. Início do corpo da estrutura Length.
5. Crie um membro struct denominado metros do tipo de dados inteiro.
6. Crie um membro struct denominado centímetros do tipo inteiro.
7. Fim do corpo da estrutura Length.
8. Chame a função main().
9. Início do corpo da função main().
10. Crie uma variável de ponteiro *ptr e uma variável normal l do tipo Length.
11. Armazene o endereço da variável l em nosso variável de ponteiro.
12. Exibe uma mensagem no console, solicitando que o usuário insira o valor dos medidores variáveis.
13. Leia o valor inserido pelo usuário através do teclado. Os medidores da função membro são acessados ​​aqui usando a variável de ponteiro.
14. Exibe uma mensagem no console, solicitando que o usuário insira o valor da variável centímetros.
15. Leia o valor inserido pelo usuário através do teclado. A função membro centímetros é acessada aqui usando a variável ponteiro.
16. Exiba os valores lidos do usuário no console junto com algum outro texto.
17. O programa deve retornar um valor após a execução bem-sucedida.
18. Fim do corpo da função main().

Estrutura como argumento de função

Você pode passar uma estrutura para uma função como argumento. Isso é feito da mesma maneira que passar um argumento normal. As variáveis ​​struct também podem ser passadas para uma função. Um bom exemplo é quando você precisa exibir os valores dos membros da estrutura. Vamos demonstrar isso:

3 exemplo:

#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;
}

Saída:

Aqui está uma captura de tela do código:

Explicação do código:

1. Inclua o arquivo de cabeçalho iostream em nosso arquivo. Usaremos então suas funções sem obter erros.
2. Inclua o namespace std em nosso programa para usar suas classes. Não precisaremos chamar o namespace para usar suas classes.
3. Crie uma estrutura chamada Person.
4. Início do corpo da estrutura Person.
5. Crie um membro da estrutura Pessoa. O membro é denominado cidadania e é do tipo inteiro.
6. Crie um membro da estrutura Person. O membro é denominado idade e é do tipo inteiro.
7. Fim do corpo da estrutura Pessoa.
8. Crie uma função que receba a instância de struct Person, p, como argumento.
9. Chame a função principal. O {marca o início do corpo da função main().
10. Crie uma instância de struct Person e dê a ela o nome p.
11. Acesse a variável membro da estrutura cidadania usando a instância da estrutura, p, e atribuindo a ela o valor 1.
12. Acesse a variável do membro da estrutura age usando a instância da estrutura, p, e atribuindo a ela o valor 27.
13. Chame a função e passe para ela a instância da estrutura Person, p, como argumento.
14. A função deve retornar um valor após a execução bem-sucedida.
15. Fim do corpo da função main().
16. Crie o corpo da função.
17. O início do corpo da função.
18. Acesse o valor de cidadania do membro struct e imprima-o no console junto com outro texto.
19. Acesse o valor da idade do membro da estrutura e imprima-o no console junto com outro texto.
20. Fim do corpo da função.

Limitação de um C++ estrutura

A seguir estão as limitações das estruturas:

• O tipo de dados struct não pode ser tratado como tipos de dados integrados.
• Operators como + -, e outros não podem ser usados ​​em variáveis ​​de estrutura.
• As estruturas não suportam ocultação de dados. Os membros de uma estrutura podem ser acessados ​​por qualquer função, independentemente do seu escopo.
• Membros estáticos não podem ser declarados dentro do corpo da estrutura.
• Os construtores não podem ser criados dentro de uma estrutura.

Resumo

• Uma estrutura é uma estrutura de dados que armazena elementos de dados pertencentes a diferentes tipos.
• Enquanto um array armazena elementos de dados de tipo semelhante, uma estrutura armazena elementos de dados de tipos diferentes.
• Uma estrutura deve ser usada quando não se espera que os elementos de dados mudem de valor.
• Os membros de uma estrutura são acessados ​​usando o operador ponto (.).
• Temos que criar uma instância da estrutura.
• Para criar um C++ struct, usamos a palavra-chave struct.
• Os ponteiros que apontam para uma estrutura são criados de forma semelhante à forma como os ponteiros que apontam para tipos regulares são criados.
• Uma struct pode ser passada como argumento para uma função da mesma forma que funções comuns são passadas.