Estrutura C++ com exemplo

O que é um Struct em C++?

Um ESTRUTURA é uma estrutura de dados C++ que pode ser usada para armazenar juntos elementos de diferentes tipos de dados. Em C++, uma estrutura é um tipo de dados definido pelo usuário. A estrutura cria um tipo de dados para agrupar itens de diferentes tipos de dados em um único tipo de dados.

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, pode ser necessário armazenar informações sobre muitas pessoas no futuro. Isso significa que variáveis ​​para diferentes indivíduos serão criadas. Por exemplo, nome1, cidadania1, idade1 etc. Para evitar isso, é melhor criar uma estrutura.

Neste tutorial de C++, você aprenderá:

• O que é um Struct em C++?
• Quando usar uma estrutura?
• Inicialização de estrutura C++
• Criando instâncias de estrutura
• Acessando membros do struct
• Ponteiros para estrutura
• Estrutura como argumento de função
• Limitação de uma estrutura C++

Quando usar uma estrutura?

Aqui estão algumas razões para usar a estrutura em C++.

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

Inicialização de estrutura C++

Para criar uma estrutura C++, 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 uma estrutura C++:

Sintaxe:

struct struct_name  
{  
     // struct members
}   

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

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

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 de estrutura

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

Person p;

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

Acessando membros do struct

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

p.age = 27;

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

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

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 definidas nele.
2. Inclua o namespace std para usar suas classes sem chamá-lo.
3. Crie um struct chamado Person.
4. O início do corpo da estrutura.
5. Crie um membro de estrutura chamado cidadania do tipo integer.
6. Crie um membro de estrutura chamado age do tipo integer.
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 struct Person e dê a ela o nome p.
10. Defina o valor da cidadania do membro do struct como 1.
11. Defina o valor da idade do membro do struct como 27.
12. Imprima o valor da cidadania do membro struct no console junto com outro texto.
13. Imprima o valor da idade do membro struct no console junto com algum outro texto.
14. O programa deve retornar um valor se for executado com êxito.
15. Fim da função main().

Ponteiros para estrutura

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

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

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 Comprimento.
5. Crie um membro de estrutura chamado medidores do tipo de dados inteiro.
6. Crie um membro de estrutura chamado centímetros do tipo inteiro.
7. Fim do corpo da estrutura Comprimento.
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 Comprimento.
11. Armazene o endereço da variável l em nossa variável de ponteiro.
12. Exiba uma mensagem no console, solicitando que o usuário insira o valor dos medidores de variáveis.
13. Leia o valor inserido pelo usuário por meio do teclado. Os medidores de função de membro são acessados ​​aqui usando a variável de ponteiro.
14. Exiba uma mensagem no console, solicitando que o usuário insira o valor para centímetros variáveis.
15. Leia o valor inserido pelo usuário por meio do teclado. A função de membro centímetros é acessada aqui usando a variável de 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 um 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 do struct. Vamos demonstrar isso:

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

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. Em seguida, usaremos 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 um struct chamado Person.
4. Início do corpo da struct Person.
5. Crie um membro da struct Person. O membro se chama cidadania e é do tipo inteiro.
6. Crie um membro da struct Person. O membro é nomeado age e é do tipo integer.
7. Fim do corpo da struct Person.
8. Crie uma função que use 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 cidadania da variável de membro do struct usando a instância do struct, p, e atribuindo-lhe o valor 1.
12. Acesse a variável de membro do struct age usando a instância do struct, p, e atribuindo-lhe o valor 27.
13. Chame a função e passe para ela a instância da struct 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 do 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 uma estrutura C++

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

• O tipo de dados struct não pode ser tratado como tipos de dados integrados.
• Operadores 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 de seu escopo.
• Membros estáticos não podem ser declarados dentro do corpo da estrutura.
• Construtores não podem ser criados dentro de uma estrutura.

Resumo:

• Um struct é uma estrutura de dados que armazena elementos de dados pertencentes a diferentes tipos.
• Enquanto um array armazena elementos de dados de um tipo semelhante, um struct armazena elementos de dados de tipos diferentes.
• Um struct deve ser usado 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 uma estrutura C++, usamos a palavra-chave struct.
• Ponteiros que apontam para um struct são criados de forma semelhante à criação de ponteiros que apontam para tipos regulares.
• Uma estrutura pode ser passada como argumento para uma função da mesma forma que funções comuns são passadas.