C ++ Struct com exemplo

Índice:

Anonim

O que é um Struct em C ++?

Um STRUCT é 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 C ++, você aprenderá:

  • O que é um Struct em C ++?
  • Quando usar uma estrutura?
  • Inicialização de Struct C ++
  • Criação de instâncias estruturais
  • Acessando membros da estrutura
  • Ponteiros para a estrutura
  • Argumento de Estrutura como Função
  • Limitação de uma estrutura C ++

Quando usar uma estrutura?

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

  • Use uma estrutura 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 uma estrutura se você não pretende modificar seus dados após a criação.

Inicialização de Struct C ++

Para criar uma estrutura C ++, usamos a palavra-chave struct, seguida por um identificador. O identificador se torna o nome da estrutura. Esta é 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 da estrutura 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.

Criação de instâncias estruturais

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

Person p;

Op é uma variável de estrutura do tipo Person. Podemos usar essa 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 de struct Person:

p.age = 27;

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

Exemplo 1:

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

Resultado:

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 uma estrutura chamada Person.
  4. O início do corpo da estrutura.
  5. Crie um membro de estrutura denominado cidadania do tipo inteiro.
  6. Crie um membro de estrutura denominado idade 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 da estrutura 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 ao lado de algum outro texto.
  13. Imprima o valor da idade do membro da estrutura 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 a 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. Observe que um ponteiro em C ++ armazenará um local de memória.

Exemplo 2:

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

Resultado:

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 denominado metros de tipo de dados inteiro.
  6. Crie um membro de estrutura denominado 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. Exibir uma mensagem no console, pedindo ao usuário para inserir o valor para medidores variáveis.
  13. Leia o valor inserido pelo usuário por meio do teclado. Os medidores de função membro são acessados ​​aqui usando a variável de ponteiro.
  14. Exibir uma mensagem no console, pedindo ao usuário para inserir o valor para centímetros variáveis.
  15. Leia o valor inserido pelo usuário por meio do teclado. Os centímetros da função membro são acessados ​​aqui usando a variável de ponteiro.
  16. Exibe os valores lidos do usuário no console ao lado de 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 ().

Argumento de Estrutura como 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 ​​de estrutura 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:

Exemplo 3:

#includeusing 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<

Resultado:




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. 

  2. Inclua o namespace std em nosso programa para usar suas classes. Não precisaremos chamar o namespace para usar suas classes.
    3. 

  3. Crie uma estrutura chamada Person.
    4. 

  4. Início do corpo da estrutura Person.
    5. 

  5. Crie um membro de struct Person. O membro é denominado cidadania e é do tipo inteiro.
    6. 

  6. Crie um membro de struct Person. O membro é denominado idade e é do tipo inteiro.
    7. 

  7. Fim do corpo da estrutura Person.
    8. 

  8. Crie uma função que leva a instância de struct Person, p, como o argumento.
    9. 

  9. Chame a função principal. O {marca o início do corpo da função main ().
    10. 

  10. Crie uma instância de struct Person e dê a ela o nome p.
    11. 

  11. Acesse a variável de membro da estrutura cidadania usando a instância da estrutura, p, e atribuindo a ela o valor 1.
    12. 

  12. Acesse a variável de membro da estrutura idade usando a instância da estrutura, p, e atribuindo a ela o valor 27.
    13. 

  13. Chame a função e passe para ela a instância da estrutura Person, p, como o argumento.
    14. 

  14. A função deve retornar um valor após a execução bem-sucedida.
    15. 

  15. Fim do corpo da função main ().
    16. 

  16. Crie o corpo da função.
    17. 

  17. O início do corpo da função.
    18. 

  18. Acesse o valor de cidadania do membro da estrutura e imprima-o no console junto com outro texto.
    19. 

  19. Acesse o valor de idade do membro da estrutura e imprima-o no console junto com outro texto.
    20. 

  20. Fim do corpo da função.
    21. 




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.
    • 

  • 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:


    

  • Uma estrutura é uma estrutura de dados que armazena elementos de dados pertencentes a diferentes tipos.
    • 

  • Enquanto uma matriz armazena elementos de dados de um tipo semelhante, uma estrutura armazena elementos de dados de diferentes tipos.
    • 

  • 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 uma estrutura C ++, usamos a palavra-chave struct.
    • 

  • Ponteiros que apontam para uma estrutura são criados da mesma forma que ponteiros que apontam para tipos regulares são criados.
    • 

  • Uma estrutura pode ser passada como um argumento para uma função da mesma maneira que as funções comuns são passadas.
    •