AULA 13 - Programação 1 - Engenharia

De MediaWiki do Campus São José
Revisão de 09h08min de 18 de fevereiro de 2022 por Eraldo (discussão | contribs) (→‎Passando estruturas como parâmetro e retornando estruturas)
(dif) ← Edição anterior | Revisão atual (dif) | Versão posterior → (dif)
Ir para navegação Ir para pesquisar

16 abril 2024

Objetivos

Ao final desta Unidade o aluno deverá ser capaz de:

  • Conceituar estruturas e campos de estruturas em C, através de exemplos de utilização;
  • Criar tipos com 'struct' e definir/declarar estruturas;
  • Inicializar estruturas na definição;
  • Acessar campos de uma estrutura (SEM USAR PONTEIROS) e usar estruturas em sentenças/expressões;
  • Passar estruturas como parâmetros de funções (via cópia) e retornar estruturas em funções;
  • Copiar uma variável estrutura para outra variável;
  • Criar e usar estruturas como campo de outras estruturas;
  • Criar e operar sobre arranjos de estruturas.


Conceito e Aplicação de Estruturas

VER o Vídeo "O que é uma Estrutura no C"

Revendo variáveis criadas a partir de tipos primitivos e variáveis arranjos

As variáveis no C são usadas para armazenar dados que podem ser processados ao longo da execução de um programa. O desenvolvedor deve criar variáveis a partir de um TIPO que pode ser visto como a FORMA (de um bolo...) a partir da qual se cria uma variável.

Escolher o tipo da variável é importante pois impacta:

  • no tamanho da variável;
  • na forma como os dados são armazenados na memória e, portanto, nas operações que podem ser realizadas sobre estes dados;
  • e de forma geral, na organização dos dados e nos algoritmos que podem ser usados para acessar estes dados.


PRG1-GalaxiaEvariavel-1.png PRG1-GalaxiaEvariavel-2.png


Exemplo 1: Se o desenvolvedor precisa armazenar o valor de uma tecla pressionada, possivelmente optará por armazená-la em uma variável tipo char: 

int main()
{
  char tecla;

  scanf("%c", &tecla);
  :
}

Exemplo 2: Se o desenvolvedor precisa armazenar a quantidade total de livros em estoque de uma biblioteca possivelmente optará por uma variável do tipo inteira: 

int main()
{
  int quantidade_livros;

  scanf("%d", &quantidade_livros);
  :
}

Exemplo 3: Se o desenvolvedor precisa armazenar um identificador de usuário talvez opte por armazená-lo como uma string e neste caso precisará de uma variável vetor de char (arranjo unidimensional). 

int main()
{
  char user_id[10];

  :
  scanf("%s", user_id);
  :
}


NOTE que tipos como char, int, float e double são considerados tipos primitivos, no sentido que o compilador C já sabe o que é e como deve operar sobre variáveis criadas a partir destes tipos. Já uma variável arranjo é formada a partir de elementos de um determinado tipo.

A necessidade de o desenvolvedor criar variáveis compostas a partir de tipos já criados

Como visto, o arranjo é uma forma do desenvolvedor criar variáveis para armazenar/organizar dados de forma mais elaborado, organizando-os na forma de vetor/matriz. O próprio desenvolvedor cria o arranjo, especificando o tipo do elemento e a(s) dimensão(ões) do arranjo. Desta forma, pode-se facilmente operar sobre uma sequência de dados.

Entretanto, como um desenvolvedor poderia criar uma variável que armazena diferentes dados (atributos) de um livro, por exemplo:

  • o título,
  • o autor,
  • o ISBN a edição etc?

Neste ponto existe a necessidade de se criar uma variável constituída de partes (campos ou fields) especificados pelo próprio desenvolvedor. Uma variável estrutura pode ser vista como um agrupamento de variáveis (identificadas pelos campos).

PRG1-LivroEstruct-1.png PRG1-LivroEstruct-2.png PRG1-LivroEstruct-3.png

No caso do livro poderia ser criado um tipo struct tipo_livro da forma: 

struct tipo_livro {
   char titulo[30];
   char autor[50];
   char isbn[13];
   int  ano;
};


e na sequência uma variável de nome livro da forma: 

struct tipo_livro livro;

Definição/declaração de Estruturas e Acesso aos Campos

VER o Vídeo "Definindo Estruturas no C"

No C é possível criar tipos de dados que representam uma estrutura. Veja o exemplo que se segue. 

#include <stdio.h>

int main()
{
    struct TUsuario /* struct TUsuario é o nome do tipo que está sendo criado */
    {
        char userID[20];
        char senha[20];
        int  num_acessos;
    } Usuario; /* aqui é definida uma variável do  tipo struct TUsuario */

    /* acessando os campos da estrutura Usuario */
    scanf("%s", Usuario.userID);
    scanf("%s", Usuario.senha);
    Usuario.num_acessos = 0;

    return 0;
}

Na realidade nada impede que se crie um vetor de estruturas, como no exemplo abaixo: 

#include <stdio.h>

int main()
{
    struct TUsuario /* struct TUsuario é o nome do tipo que está sendo criado */
    {
        char userID[20];
        char senha[20];
        int  num_acessos;
    } Usuario; /* aqui é definida uma variável do  tipo struct TUsuario */

    /* aqui uma tabela/vetor de estruturas */
    struct TUsuario TabelaUsuario[20];

    /* acessando os campos da estrutura Usuario */
    scanf("%s", Usuario.userID);
    scanf("%s", Usuario.senha);
    Usuario.num_acessos = 0;

    /* acessando o campo 10 da tabela de estruturas */
    scanf("%s", TabelaUsuario[10].userID);
    scanf("%s", TabelaUsuario[10].senha);
    TabelaUsuario[10].num_acessos = 0;

    return 0;
}

Neste exemplo, foi definido um tipo (modelo) para o registro (struct TUsuario) e foi criada uma variável chamada Usuario a partir deste tipo. Na sequência foi criada mais uma variável (um vetor de estruturas) chamada TabelaUsuario. Note que basta usar as palavras chave struct Usuario para criar novas variáveis. O tipo completo é definido uma única vez no início.

Exercícios

1. Criar um tipo estrutura que permita representar um retângulo. Criar duas variáveis retângulo e mostrar como as áreas destes retângulos poderiam ser somadas.

Solução 
#include <stdio.h>


struct tipo_retang{
  float lado1;
  float lado2;
};

main()
{
  struct tipo_retang x,y;
  float area_final;

  x.lado1=5.5;
  x.lado2=6.7;

  y.lado1=2.3;
  y.lado2=7.9; /* poderia entrar com scanf: scanf("%f",&y.lado2); etc */

  area_final = x.lado1*x.lado2 + y.lado1*y.lado2;

  printf("Área total dos dois retângulos = %f \n", area_final);  
}


Struct figure.jpg

2. Criar um tipo estrutura que permita armazenar os coeficientes de uma equação do segundo grau. Implementar um código para calcular o DELTA da equação.

solução Ex. 2 
//Autor : Victor Cesconetto De Pieri
#include <stdio.h>
 
struct coeficientes_equacao {
  float a,b,c;
  } eq;

int main()
{
  float delta;

  printf("Entre com o 'a' da equação\n");
  scanf("%f", &eq.a);
  printf("Entre com o 'b' da equação\n");
  scanf("%f", &eq.b);
  printf("Entre com o 'c' da equação\n");
  scanf("%f", &eq.c);  
  delta = (eq.b*eq.b) - 4*eq.a*eq.c;
  printf("delta : %f\n", eq.delta);
  return 0;
}

3. Criar um programa que define uma struct para armazenamento do nome e das notas bimestrais de um aluno. Criar uma turma de alunos como um arranjo de estruturas de tamanho 5. Atualizar a turma usando estrutura usando o scanf.

solução Ex. 3 
#include <stdio.h>

#define NUM_MAX 5

struct t_aluno {
  char nome[30];
  char matricula[11];
  float b1,b2,b3,b4;
} Turma[NUM_MAX];

int main()
{
  int i;
  
  for(i=0;i<NUM_MAX;i++) {
  	printf("Entre com o nome do aluno\n");
  	scanf("%s", Turma[i].nome);
  	printf("Entre com a matrícula do aluno\n");
  	scanf("%s", Turma[i].matricula);
  	printf("Entre com a nota do bimestre 1\n");
  	scanf("%f", &Turma[i].b1);
  	printf("Entre com a nota do bimestre 2\n");
  	scanf("%f", &Turma[i].b2);
  	printf("Entre com a nota do bimestre 3\n");
  	scanf("%f", &Turma[i].b3);
  	printf("Entre com a nota do bimestre 4\n");
  	scanf("%f", &Turma[i].b4);
  }    
        return 0;
}

4. Acrescentar um código no final da função main para calcular a média da turma para cada um dos bimestres.

solução Ex. 4 
#include <stdio.h>
#define NUM_MAX 3
 
struct TAluno {
  char nome[30];
  char matricula[11];
  float b1,b2,b3,b4;
} Turma[NUM_MAX];
 
int main(){
  int i;
  float soma_b1=0,soma_b2=0,soma_b3=0,soma_b4=0
  float media_b1=0,media_b2=0,media_b3=0,media_b4=0; 
  
  for(i=0;i<NUM_MAX;i++){
      printf("Entre com o nome do aluno: ");
      scanf("%s", Turma[i].nome);
      printf("Entre com a matrícula do aluno: ");
      scanf("%s", Turma[i].matricula);
      printf("Entre com a nota do bimestre 1: ");
      scanf("%f", &Turma[i].b1);
      printf("Entre com a nota do bimestre 2: ");
      scanf("%f", &Turma[i].b2);
      printf("Entre com a nota do bimestre 3: ");
      scanf("%f", &Turma[i].b3);
      printf("Entre com a nota do bimestre 4: ");
      scanf("%f", &Turma[i].b4);
  }    

  for(i=0;i<NUM_MAX;i++) {
      soma_b1 = (soma_b1+Turma[i].b1); /* usando media_b1 para soma acumulada */
      soma_b2 = (soma_b2+Turma[i].b2);
      soma_b3 = (soma_b3+Turma[i].b3);
      soma_b4 = (soma_b4+Turma[i].b4);
  }
  media_b1 = (media_b1/NUM_MAX);
  media_b2 = (media_b2/NUM_MAX);
  media_b3 = (media_b3/NUM_MAX);
  media_b4 = (media_b4/NUM_MAX);

  printf("A media do B1 => %.2f\n",media_b1);
  printf("A media do B2 => %.2f\n",media_b2);
  printf("A media do B3 => %.2f\n",media_b3);
  printf("A media do B4 => %.2f\n",media_b4);
  return 0;
}

5. Repensar a estrutura TAluno para que as notas bimestrais sejam representadas como um vetor de floats. Fazer um código para calcular a média anual de cada aluno. Armazenar as médias anuais da turma em um vetor de floats.

solução Ex. 5 
#include <stdio.h>
 
#define NUM_MAX 3
 
struct TAluno {
  char nome[30];
  char matricula[11];
  float b[4];
} Turma[NUM_MAX];
 
void print_aluno(struct TAluno aux)
{
  printf("Nome -> %s\n", aux.nome);
  printf("Matrícula -> %s\n", aux.matricula);
  printf("Bimestre 1 -> %f\n", aux.b[0]);
  printf("Bimestre 2 -> %f\n", aux.b[1]);
  printf("Bimestre 3 -> %f\n", aux.b[2]);
  printf("Bimestre 4 -> %f\n", aux.b[3]);          
}
 
main()
{
  int i,j;
  float media[NUM_MAX]={0,0,0}; 
 
  for(i=0;i<NUM_MAX;i++) {
      printf("Entre com o nome do aluno\n");
      scanf("%s", Turma[i].nome);
      printf("Entre com a matrícula do aluno\n");
      scanf("%s", Turma[i].matricula);
      for(j=0;j<4;j++) {
          printf("Entre com a nota do bimestre %d\n", j+1);
          scanf("%f", &Turma[i].b[j]);
      }
  }    
 
  /* calculo das médias bimestrais da turma */
  /* separado do primeiro for para caracterizar a diferença de entrada de dados do processamento ... */
  for(i=0;i<NUM_MAX;i++) {
      for(j=0;j<4;j++)
            media[i]=media[i]+Turma[i].b[j]; /* usando media_b1 para soma acumulada */
      media[i]=media[i]/4;
  }
}

Iniciando estruturas na definição

Variáveis do tipo "estrutura" também podem ser iniciadas na declaraçao/definição. Veja o exemplo abaixo. 

#include <stdio.h>


struct tipo_retang{
  float lado1;
  float lado2;
};

main()
{
  struct tipo_retang x = {5.5,6.7},
                     y = {2.3,7.9};
  float area_final;

  area_final = x.lado1*x.lado2 + y.lado1*y.lado2;

  printf("Área total dos dois retângulos = %f \n", area_final);  
}


Copiando Estruturas


Pode-se copiar dados de uma estrutura para outra simplesmente copiando seus campos um a um. Vamos a um exemplo.A variável Ontem é copiada para variável Hoje. Elas possuem a mesma composição: horas, minutos e segundos (tipo struct THoras). Note que para realizar esta cópia não é necessário que as variáveis tenham exatamente a mesma estrutura (tipo). Basta os campos envolvidos serem de tipo compatíveis. 

#include <stdio.h>
  
struct THoras{
   int hora;
   int minuto;
   int segundo;
};

struct THoras Ontem = {2,10,57};

void main()
{
     struct THoras Hoje;
     Hoje.hora = Ontem.hora;
     Hoje.minuto = Ontem.minuto;
     Hoje.segundo = Ontem.segundo;     

     printf("Hora hoje = %d, Minuto hoje = %d e Segundo hoje %d\n", Hoje.hora, Hoje.minuto, Hoje.segundo);
}


Entretanto, é possível copiar inteiramente uma estrutura, sem precisar citar seus atributos. Veja o exemplo abaixo: 

#include <stdio.h>
  
struct THoras{
   int hora;
   int minuto;
   int segundo;
};

struct THoras Ontem = {2,10,57};

void main()
{
     struct THoras Hoje;
     Hoje = Ontem;

     printf("Hora hoje = %d, Minuto hoje = %d e Segundo hoje %d\n", Hoje.hora, Hoje.minuto, Hoje.segundo);
}

Estruturas dentro de estruturas

Vamos ver um exemplo com estruturas definidas dentro de estruturas: 

#include <stdio.h>
  
struct TEndereco{
     char rua[50];
     char numero[10];
};

struct TCidadao{
  char nome[50];
  char cpf[20];
  struct TEndereco endereco;
  int num_filhos;
};

void main()
{
  struct TCidadao Cidadao;

  printf("Entre com o nome\n");
  scanf ("%s",Cidadao.nome);

  printf("Entre com o cpf\n");
  scanf ("%s",Cidadao.cpf);

  printf("Entre a rua\n");
  scanf ("%s",Cidadao.endereco.rua);

  printf("Entre a numero\n");   
  scanf ("%s",Cidadao.endereco.numero);

  printf("Entre com o número de filhos\n");
  scanf ("%d",&Cidadao.num_filhos);
  
}

Exercício

  1. Faça um código adicional para imprimir o conteúdo lido na estrutura.
solução 
#include <stdio.h>
 
struct TEndereco{
     char rua[50];
     char numero[10];
};
 
struct TCidadao{
  char nome[50];
  char cpf[20];
  struct TEndereco endereco;
  int num_filhos;
};

void print_cidadao(struct TCidadao aux)
{
  printf("Nome: %s - CPF: %s\n", aux.nome, aux.cpf);
  printf ("Rua %s Número %s\n", aux.endereco.rua, aux.endereco.numero); 
  printf("Numero de filhos %d\n", aux.num_filhos);
}

int main(void){

  struct TCidadao Cidadao;
 
  printf("Entre com o nome\n");
  scanf ("%s",Cidadao.nome);
  getchar();
 
  printf("Entre com o cpf\n");
  scanf ("%s",Cidadao.cpf);
  getchar();
 
  printf("Entre a rua\n");
  scanf ("%s",Cidadao.endereco.rua);
  getchar();
 
  printf("Entre a numero\n");   
  scanf ("%s",Cidadao.endereco.numero);
  getchar();
 
  printf("Entre com o número de filhos\n");
  scanf ("%d",&Cidadao.num_filhos);

  print_cidadao(Cidadao);
  return 0;
}

Iniciando Estruturas cujos campos são estruturas

Como todas variáveis no C, é possível iniciar um variável estrutura na sua definição. Vejamos o exemplo a seguir, onde uma variável chamada Cidadao tem todos os seus campos iniciados na sua definição. Note que inclusive um campo que também é estrutura está sendo iniciado. 

#include <stdio.h>
 
struct TEndereco{
     char rua[50];
     char numero[10];
};
 
struct TCidadao{
  char nome[50];
  char cpf[20];
  struct TEndereco endereco;
  int num_filhos;
};
 
void main()
{
  struct TCidadao Cidadao = {"Maria",
                             "42342342234",
                             {"Rua AlfaBeta","145"},
                             5;
                            };
 
  printf("Rua do cidadao = %s\n", Cidadao.endereco.rua);
 
}

Passando estruturas como parâmetro e retornando estruturas

Estruturas podem ser passadas como parâmetros de funções e podem ser retornadas com o comando return. Na realidade, a criação de um tipo estrutura é normalmente acompanhado de um conjunto de funções que permitem realizar OPERAÇÕES sobre as mesmas (ver a noção de tipo abstrato de dados). Por exemplo, uma estrutura que representa um número complexo pode ser acompanhada de um conjunto de funções que operam sobre estes números.


Se não for usado o operador "&" , um parâmetro que é estrutura será passado por cópia. Não apresentaremos agora a passagem por endereço pois necessita do conceita de ponteiro. Observe o exercício abaixo. 

 1#include <stdio.h>
 2  
 3struct TEndereco{
 4     char rua[50];
 5     char numero[10];
 6};
 7
 8struct TCidadao{
 9  char nome[50];
10  char cpf[20];
11  struct TEndereco endereco;
12  int num_filhos;
13};
14
15void print_struct (struct TCidadao aux)
16{
17  printf("nome=%s cpf=%s\n", aux.nome, aux.cpf);
18  printf("endereço inicial do aux %p\n", &aux);
19}
20
21void main()
22{
23  struct TCidadao Cidadao;
24
25  printf("Entre com o nome\n");
26  scanf ("%s",Cidadao.nome);
27
28  printf("Entre com o cpf\n");
29  scanf ("%s",Cidadao.cpf);
30
31  printf("Entre a rua\n");
32  scanf ("%s",Cidadao.endereco.rua);
33
34  printf("Entre a numero\n");   
35  scanf ("%s",Cidadao.endereco.numero);
36
37  printf("Entre com o número de filhos\n");
38  scanf ("%d",&Cidadao.num_filhos);
39  
40  print_struct(Cidadao);
41
42  printf("endereço inicial do Cidadao %p\n", &Cidadao);
43}

O que podemos concluir com os endereços que foram mostrados??? Vamos a mais um exemplo que MOSTRA como uma estrutura pode ser retornada por uma função. NOTE que é retornada a cópia da estrutura.

 1#include <stdio.h>
 2  
 3struct TEndereco{
 4     char rua[50];
 5     char numero[10];
 6};
 7
 8struct TCidadao{
 9  char nome[50];
10  char cpf[20];
11  struct TEndereco endereco;
12  int num_filhos;
13};
14
15struct TCidadao ler_struct()
16{
17  struct TCidadao aux;
18
19  printf("Entre com o nome\n");
20  scanf ("%s",aux.nome);
21
22  printf("Entre com o cpf\n");
23  scanf ("%s",aux.cpf);
24
25  printf("Entre a rua\n");
26  scanf ("%s",aux.endereco.rua);
27
28  printf("Entre a numero\n");   
29  scanf ("%s",aux.endereco.numero);
30
31  printf("Entre com o número de filhos\n");
32  scanf ("%d",&aux.num_filhos);
33
34  return aux;
35}
36
37void print_struct (struct TCidadao aux)
38{
39  printf("nome=%s cpf=%s\n", aux.nome, aux.cpf);
40  printf("endereço inicial do aux %p\n", &aux);
41}
42
43void main()
44{
45  struct TCidadao Cidadao;
46
47  Cidadao = ler_struct();
48
49  print_struct(Cidadao);
50
51  printf("endereço inicial do Cidadao %p\n", &Cidadao);
52}


Usando typedef com Estruturas

A palavra RESERVADA typedef pode ser usada para redefinir o nome de um tipo. No exemplo abaixo o tipo float também poderá ser representado por MEU_FLOAT 

#include <stdio.h>

typedef float MEU_FLOAT;

MEU_FLOAT x;

int main()
{
    x = 0.5;
    return 0;
}

O typedef pode ser usado para abreviar e apoiar a construção de estruturas: 

#include <stdio.h>

typedef struct {
                float lado1;
                float lado2;
               } tipo_retang;

int main()
{
    tipo_retang retang1;

    retang1.lado1 = 2.5;
    retang1.lado2 = 4.5;
    return 0;
}

No exemplo acima a struct foi usada no typedef sem um nome específico (na realidade, este nome é opcional). O nome tipo_retang veio após a declaração da estrutura. Este identificador pode agora ser usado sem struct. Note no exemplo abaixo como retang1 r retang2 foram definidas. São declarações equivalentes. 

#include <stdio.h>

typedef struct tretang {
                float lado1;
                float lado2;
               } tipo_retang;

int main()
{
    tipo_retang retang1;
    struct tretang retang2;

    retang1.lado1 = 2.5;
    retang1.lado2 = 4.5;

    retang2.lado1 = 3.5;
    retang2.lado2 = 5.5;
    return 0;
}

Fazendo Busca em Arranjo Unidimensional de Estruturas


PRG1-BuscaEstrutura.png 

#include <stdio.h>
#include <string.h>

#define TAM_ID 10
#define TAM_NOME 30
#define TAM_USERS 5

typedef struct {
                char userID[TAM_ID];
                char nome[30];
                int cont;
               } tipo_usuario;

/* Variável Global - Tabela de Usuários do Sistema */
tipo_usuario usuarios[TAM_USERS] = {
        {"joaos","joao da silva", 0},
        {"marias","maria da silva", 0},
        {"joses","jose da silva",0},
        {"laras","lara da silva",0},
        {"eraldo","eraldo e silva",0},
        };

/* Função que busca um usuário na tabela:
 * ENTRADA: string correspondente ao userID
 * SAIDA (retorno): retorna -1 se usuário não existe ou retorna o índice
 * do usuário na tabela
*/
int buscar_indice_usuario(char userID[])
{
    int i, flag = 1;

    for (i = 0; i < TAM_USERS && flag; i++){
        if (strcmp(userID,usuarios[i].userID)==0)
            flag = 0; /* encerra a busca - usuário encontrado */
    }
    if (flag)
        return -1;
    else
        return i-1;
}

int main()
{
    int i;
    i = buscar_indice_usuario("marias");
    if (i>-1)
        printf("Nome completo = %s \n", usuarios[i].nome);
    return 0;
}

Aplicação de estruturas - Representação de números complexos

Um número complexo possui dois componentes reais que podem ser representados por duas variáveis float ou double. Observe que a declaração separada destes componentes prejudica a legibilidade do código e a construção de algoritmos eficientes para o tratamento destes números. Na sequência apresentamos exercícios que representam números complexos em estruturas.

  1. Implementar uma estrutura que permita representar um número complexo no formato retangular. Em adição, implemente uma função que permita somar dois números complexos retornando um número complexo com o valor da soma.
    Solução Ex. 1 
    #include <stdio.h>

struct tcomplexo {
  float x;  /* parte real */
  float y;  /* parte imaginária */
};

struct tcomplexo add_complex(struct tcomplexo num_A, struct tcomplexo num_B)
{
  struct tcomplexo temp;

  temp.x = num_A.x + num_B.x;
  temp.y = num_A.y + num_B.y;
  return temp;
}

int main(void)
{
  struct tcomplexo num_1, num_2, num_3;

  num_1.x = 1.5;
  num_1.y = 2.5;
  num_2.x = 3.5;
  num_2.y = 1.5;  
  num_3 = add_complex(num_1, num_2);
  /* implementar aqui m printf para mostrar o valor de num_3...*/

  return 0;
}
  2. Implementar uma função que retorna o quadrante de um número complexo. O quadrante será um número inteiro 1, 2, 3 ou 4. Caso o número seja (0,0) retornar 0. Caso esteja sobre o eixo x retornar 5 e caso esteja sobre o eixo y retornar 6.
  3. Implementar uma função que retorne o módulo de um número complexo.
    • Observação: Quando utilizar a biblioteca matemática [[<math.h>]] deve-se compilar o código com a opção -lm. Por exemplo: gcc -o arquivo arquivo.c -lm
    Solução Ex. 2 
    #include <stdio.h>
#include <math.h>
 
struct tcomplexo {
  float x;
  float y;
};

float calc_mod_complex(struct tcomplexo num_A)
{
  float temp;

  temp = sqrtf(num_A.x*num_A.x + num_A.y * num_A.y);
  return temp;
}

main()
{
  struct tcomplexo num_1;
  float result_mod;

  num_1.x = 1.5;
  num_1.y = 2.5; 
 
  result_mod = calc_mod_complex(num_1);  
}
  4. Implementar um programa que cria duas matrizes 2X2 de números complexos no formato retangular. Adicionalmente, implementar uma função para somar estas matrizes. Reusar a função de soma de número já implementada.
    Solução Ex. 3 
    #include <stdio.h>
#include <math.h>

#define NUM_LIN 2
#define NUM_LIN 2
#define NUM_COL 2

struct tcomplexo {
  float x;
  float y;
};

struct tcomplexo add_complex(struct tcomplexo num_A, struct tcomplexo num_B)
{
  struct tcomplexo temp;
 
  temp.x = num_A.x + num_B.x;
  temp.y = num_A.y + num_B.y;
  return temp;
}

void add_mat_complex(struct tcomplexo mat_A[NUM_LIN][NUM_COL],struct tcomplexo mat_B[NUM_LIN][NUM_COL], struct tcomplexo mat_C[NUM_LIN][NUM_COL])
{
  int i,j;
  
  for (i=0;i<NUM_LIN;i++)
     for (j=0;j<NUM_COL;j++)
         mat_C[i][j]=add_complex(mat_A[i][j], mat_B[i][j]);
}

int main(void)
{
  struct tcomplexo mat1[NUM_LIN][NUM_COL]={
                              {{.x=2.5,.y=2.7,}, {.x=1.5,.y=2.3,}},
                              {{.x=1.9,.y=2.6,}, {.x=3.5,.y=7.3,}}
                            },
                   mat2[NUM_LIN][NUM_COL]={
                              {{.x=4.5,.y=2.8,}, {.x=1.6,.y=8.3,}},
                              {{.x=0.9,.y=2.9,}, {.x=7.5,.y=4.3,}}
                            },    
                   mat3[NUM_LIN][NUM_COL];

  add_mat_complex(mat1,mat2,mat3);
  /* fazer função para imprimir matriz complexa... */
}
  5. Implementar uma função converte_para_polar que recebe como parâmetro um número complexo na forma retangular (uma struct). A função deve retornar uma struct contendo o número complexo na forma polar.Usar as funções sqrt[1] e atan [2] da biblioteca matemática. Como converter:
    ou
    Solução 4 
    #include <math.h>

struct TComplexoRet {
  float x,y;
};

struct TComplexoPolar {
  float mod,ang;
};

struct TComplexoPolar convert_polar(struct TComplexoRet a)
{
  struct TComplexoPolar aux;
  
  aux.mod = sqrtf(powf(a.x,2)+powf(a.y,2));
  aux.ang = atan(a.y/a.x);  
  return aux;
}

main()
{
 struct TComplexoRet w;
 struct TComplexoPolar y;
 
 w.x = 11.5;
 w.y = 4.6;
 y = convert_polar(w); 
}
  6. Implementar uma função que retorne a multiplicação de dois números complexos fornecidos como parâmetro.
    Solução 5 
    //Autor : Victor Cesconetto De Pieri

#include <stdio.h>
#include <math.h>

struct tcomplexo {
  float x;
  float y;
};

float calc_num_imag(struct tcomplexo num_A, struct tcomplexo num_B) {

  float temp_imag = num_A.x * num_B.y + num_A.y * num_B.x;

  return temp_imag;
}

float calc_num_real(struct tcomplexo num_A, struct tcomplexo num_B) {

  float temp_real = num_A.x * num_B.x + num_A.y * num_B.y * (-1);

  return temp_real;
}

int main() {
  struct tcomplexo num_1;
  struct tcomplexo num_2;
  float real, imag;
  num_1.x = 2.5;
  num_1.y = 1;
  num_2.x = 2.5;
  num_2.y = 1;
  real = calc_num_real(num_1, num_2);
  imag = calc_num_imag(num_1, num_2);

  printf("Resultado : %f + %fi\n", real, imag);

}

Aplicação no Controle de Acesso

O exemplo a seguir implementa uma parte do programa de controle de acesso usando estruturas. Neste exemplo a tabela de usuários já vem inicializada nos campos UserID e Senha. A função strcmp da BIBLIOTECA DO C para comparação de strings. Ela retorna 0 caso as strings a serem comparadas sejam iguais. Note que deve ser incluído string.h 

#include <stdio.h>
#include <string.h>
 
/**********************************************/
/***PROGRAMA DE CONTROLE DE ACESSO**/
/**********************************************/
 
/** VARIÁVEIS GLOBAIS DESTE MÓDULO ****/

struct TRegistroUsuario {
  char UserId[10];
  char Senha[10];
};

/* Tabela de Usuários */
struct TRegistroUsuario TabelaUsuarios[4] = {
  {"joao","abcd"},
  {"maria","xxxx"},
  {"jose","yyyy"},
  {"lara","zzzz"},
};

 
char userID[20];
 
 
/** FUNÇÔES DESTE MÓDULO ****/
 
void mostrar_menu_entrada_usuario()
{
  printf("*******************************\n");
  printf("Entre com o seu USERID para ter acesso\n"); 
  printf("*******************************\n");
}
 
/** Função que implementa as tarefas do administrador **/
 
void  administrar()
{
}
 
/** Função que valida um usuário e abre a porta **/
 
void tratar_usuario()
{
  char senha[10];
  int userEncontrado=1;
  int i;
 
 
 /* 
     Loop para encontrar o usuário na tabela. 
     Ao final do loop a variavel i conterá o índice do usuário (menos 1)(se ele estiver
     na tabela
  */
  for (i=0;i<4 && userEncontrado; i++) {
     if( strcmp(userID, TabelaUsuarios[i].UserId)==0)
        userEncontrado=0;
  }
 
  /* se usuário encontrado abre a porta */
  if (userEncontrado==0) {
     printf("Bom dia %s! Entre com a senha\n", userID);
     scanf("%s",senha);
     i--; /* o indice do sujeito é i-1 */
     if(strcmp(senha,TabelaUsuarios[i].Senha)==0) 
        printf("Abrir porta!!!\n");
     else
        printf("Senha Inválida\n");
  }
}
 
void main()
{
  for(;;) {
     mostrar_menu_entrada_usuario();
     scanf("%s",userID);
     if (strcmp(userID, "admin")==0) {
        administrar();
     } else {
        tratar_usuario();
     }
 }   
}

Exercícios:

  1. Implementar um contador de acesso que permita bloquear o usuário após 3 tentativas seguidas. Note que caso o usuário acerte a senha, este contador deverá ser zerado.
  2. Implementar uma funcionalidade do administrador para desbloquear o usuário bloqueado.
  3. No programa de controle de senha inserir um campo na estrutura do usuário de forma a acomodar uma mensagem de boas vindas particularizada para cada usuário. A mensagem "DEFAULT" é Bom dia!
  4. mplementar na função administrar a inserção da mensagem no exercício anterior.
  5. Na solução acima criar uma função que procura usuário na tabela (já que este código é utilizado em mais do que um lugar). A função deve receber o UserID a ser procurado e deve retornar um inteiro correspondente ao índice do usuário encontrado ou -1 se não for encontrado. Use esta função para no desbloqueio do usuário.

Referências

https://www.geeksforgeeks.org/memory-layout-of-c-program/

https://docs.cs50.net/2017/fall/notes/5/lecture5.html#data-structures

http://www.mathwarehouse.com/programming/passing-by-value-vs-by-reference-visual-explanation.php

Disponível em “https://wiki.sj.ifsc.edu.br/index.php?title=AULA_13_-_Programação_1_-_Engenharia&oldid=181754”