Ir ao conteúdo
  • Cadastre-se
Mateus Nunes

Utilização de funções em c

Recommended Posts

Boa noite, abaixo segue um pedaço de um código em que estou trabalhando. Um dos requisitos desse trabalho, envolve o uso de funções do tipo void e do tipo float ou double. Notem, por favor, que o pedaço extraído se encontra dentro de um case do switch e que as partes contendo pontos de interrogação se referem-se aquelas em que o uso de funções seria apropriado (eu acredito). Caso alguém aí possa me mostrar como ficaria, pra esse caso em especial, a função, eu agradeço!!

OBS.: meu objetivo é adicionar a função numa biblioteca e chamá-la na função main().

case 1: {int index;
        printf("\t\t\t\tFUNÇÃO AFIM");
        printf("\n\nPara a função do tipo y=ax+b, determine os parâmetros:");
        printf("\n\nDigite o valor de a: ");
        scanf("%f",&a);
        printf("\nDigite o valor de b: ");
        scanf("%f",&b);
        printf("\nInforme o número de pontos, da coordenada x: ");
        scanf("%d",&qtd);
        float mat[qtd][2];
        for(index=0;index<=qtd-1;index++) ///// ???????? função do tipo void (eu acredito), pois apenas preenche a matrix
        {
        printf("Entre com valor real para x%d: ",index+1);
        scanf("%f",mat[index]);
        }
        for(index=0;index<=qtd-1;index++) //////// ???????????? função do tipo void
        {
        mat[index][1]=a*mat[index][0]+b;
        }
        for(index=0;index<=qtd-1;index++) /////// ??????????????????? função do tipo float ou double, pois me retorna um valor
        {
        printf("%dº Ponto(%.2f;%.2f)\n",1+index,mat[index][0],mat[index][1]);
        }}
        break;

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
void preencher_mat_x( unsigned tamanho, float mat[ tamanho ][2] )
{
  int index;
  
  for( index = 0; index < tamanho; index++ )
  {
    printf( "Entre com valor real para x%d: ",index + 1 );
    scanf( " %f", mat[ index ] );
  }
  
  return;
}
void preencher_mat_y( unsigned tamanho, float mat[ tamanho ][2], float a, float b )
{
  int index;

  for( index = 0; index < tamanho; index++ )
    mat[ index ][1] = a * mat[ index ][0] + b;

  return;
}
void show_mat_pontos( unsigned tamanho, float mat[ tamanho ][2] )
{
  int index;

  for( index = 0; index < tamanho; index++ )
    printf("%dº Ponto(%.2f;%.2f)\n",1 + index,mat[ index ][0],mat[ index ][1]);

  return;
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

O que seria unsigned?? Há alguma possibilidade de implementar função float?

Aqui não estou conseguindo fazer dar certo, segue o que fiz abaixo

#include <stdio.h>
#include <locale.h>
#include <math.h>
#include "Biblioteca_Projeto.h"
main()
{
char option,optionf;
float a,b;
double c;
int qtd;



setlocale(LC_ALL,"portuguese");

        printf("\t\t\t\tFUNÇÃO AFIM");
        printf("\n\nPara a função do tipo y=ax+b, determine os parâmetros:");
        printf("\n\nDigite o valor de a: ");
        scanf("%f",&a);
        printf("\nDigite o valor de b: ");
        scanf("%f",&b);
        printf("\nInforme o número de pontos, da coordenada x: ");
        scanf("%d",&qtd);
        float mat[qtd][2];
        preenche_mat_x(qtd,mat[qtd][2]);
        for(index=0;index<=qtd-1;index++)
        {
        mat[index][1]=a*mat[index][0]+b;
        }
        for(index=0;index<=qtd-1;index++)
        {
        printf("%dº Ponto(%.2f;%.2f)\n",1+index,mat[index][0],mat[index][1]);
        }
}

///////////////////////////////////////////////////////////////////////////
CÓDIGO DA BIBLIOTECA
  
void preenche_mat_x(unsigned qtd, float mat[qtd][2])
{
int index;
for(index=0;index<=qtd-1;index++)
        {
        printf("Entre com valor real para x%d: ",index+1);
        scanf("%f",mat[index]);
        }
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

signed(com sinal -1) é um numero negativo e unsigned(sem sinal +1) positivo. O unsigned int é dizer "inteiro sem sinal" ou melhor ainda, se não tem sinal " é positivo". Os números positivos não precisamos por + porém se você por + adiante de um numero positivo tem o mesmo efeito que não por ele. Por conveniência os criadores da linguagem só obrigam por o sinal no caso de negativo, se não levar nenhuma sinal se concedera positivo, então se ver a palavra signed ou unsigned saiba que se trata em relação aos números negativos, tipo: É um numero negativo? Ou não é um numero negativo? No caso de não ser ser negativo é positivo mas como falei as sinais vão relacionadas com saber se um numero é negativo ou não.

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Bom dia @Mateus Nunes

Onde está escrito

preenche_mat_x(qtd,mat[qtd][2]);

O correto é:

preenche_mat_x(qtd,mat);

 

adicionado 1 minuto depois

Lei mais sobre vetores neste link: O que são vetores :: CProgressivo.net

Compartilhar este post


Link para o post
Compartilhar em outros sites

SIM!!! Acabei conseguindo agora a pouco!

 

Cara, está correto dizer que meu programa contém vetores e matrizes????

Fico na dúvida porque a função preenche mat é patricamente um preenche vet, entende?

Compartilhar este post


Link para o post
Compartilhar em outros sites

Boa pergunta!!!

Então seu programa tem matrizes, e toda matriz é um conjunto de vetores.

Se eu quiser posso tratar a matriz como vetor e um vetor como matriz.

Por exemplo uma mat[ 3 ][ 3 ] é o mesmo que um vet[ 9 ], ouve que aconteceu???
Aconteceu a multiplicação dos índices. Com um pouco de aritmética o conceito de matriz e vetor

tornasse mera conveniência

Saiba mais em: Como usar ponteiros :: CProgressivo.net  

Compartilhar este post


Link para o post
Compartilhar em outros sites

Hum....mas e vetores, propriamente ditos?

 

Por exemplo, eu monto uma matriz com 2 linhas e 2 coluna: mat[2][2];

Quando eu digito mat[2][0] e mat[2][1], esse 0 e esse 1 se referem as duas colunas?

 

porque no programa, eu declaro float mat[qtd][2];

Depois, pego os valores de x e preencho um VETOR mat[index], correto?;

O que seria o mat[index][0] e mat[index][1]???

 

Deu pra entender???? Desculpa pela confusão, mas essa lógica não entra na minha cabeça...

Compartilhar este post


Link para o post
Compartilhar em outros sites

AAAAH sim entendi;

44 minutos atrás, Mateus Nunes disse:

Por exemplo, eu monto uma matriz com 2 linhas e 2 coluna: mat[2][2];

Quando eu digito mat[2][0] e mat[2][1], esse 0 e esse 1 se referem as duas colunas?

Sim, de fato uma matriz como no exemplo fica assim dentro da perspectiva mecânica da linguagem:

 

Quadro de Células de Memória (RAM)

C00 => é primeiro local na memória que foi reservado, então quando eu declaro um C[ i ][ j ], seu índices reais são:

C[ i - 1][ j - 1]. No caso acima se i = 2, j = 2 então C[ 2 ][ 2 ], tem índices  C[ 2 - 1][ 2 - 1], o menor valor para linhas e colunas é 0,

maior valor para linha e colunas e i - 1, j - 1 respectivamente para acesso as células de memória. 

 

Observe: Declaramos por exemplo: int C[2][2];

para acessar o primeiro elemento da matriz faremos: C[ 0 ][ 0 ], pois o primeiro elemento é C + 0 * j + 0 = C;

para acessar o segundo elemento da matriz faremos: C[ 0 ][ 1 ], aqui a mecânica da linguagem faz sua mágica

o primeiro índice (linhas) soma ao múltiplo o segundo índice (colunas), logo teremos dentro da mecânica de linguagem

C[0][1] = C + 0 * 2 + 1 = C + 1  = Segundo elemento do Vetor ou linha 1, coluna 2; da matriz ainda podemos...

C[1][1] = C + 1 * 2 + 1 = C + 3  = Quarto elemento do Vetor ou linha 2, coluna 2; da matriz.

Mais por que multiplica a linguagem multiplica por dois, porque este foi o tamanho do vetor informado.

Declaração: float Mat[ linhas ][ colunas ];

Acesso: x =  Mat[ LINHAS - 1][COLUNAS - 1]; //Ultimo elemento da matriz

 

 

44 minutos atrás, Mateus Nunes disse:

porque no programa, eu declaro float mat[qtd][2];

Depois, pego os valores de x e preencho um VETOR mat[index], correto?;

O que seria o mat[index][0] e mat[index][1]???

 

 Aqui acontece a aritmética de ponteiros dentro da mecânica da linguagem.

Com mat[ index ] você esta acessando todos os elementos da primeiro coluna em todas as linhas na memória RAM.

O primeiro par de colchetes de uma matriz representa suas linhas, e segundo suas colunas.

Para acessar os valores da primeiro coluna de todas as linhas fazemos: mat[ index ][ 0 ]; Acessar valor...

Para acessar o local na memória do computador podemos fazer assim para mesma situação:

&mat[ index ][ 0 ]; ou mat[ index ]; isso na função scanf ou qualquer outra que deseja apenas o local na memória de

todas as linhas da primeira coluna e se fosse da segunda coluna?

Faça  assim para segunda coluna: &mat[ index ][1]; ou mat[ index ] + 1;

observe que a expressão [ index ] é o mesmo que index * 2.

Lembre-se que o nome do vetor ou da matriz é sempre o primeiro elemento na memória.

adicionado 5 minutos depois

Bom pensar assim também:

mat[ 3 ][ 2 ];

o segundo par de colchetes é o tamanho do vetor

o primeiro par de colchetes é a quantidade de vetores do tamanho do segundo par [ 2 ]

e mat é o marco 0, ou primeiro elemento da primeira coluna e primeira linha.

 

Assim temos 3 vetores de 2 elemento na forma de uma matriz.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Putz cara, muitíssimo obrigado pela ótima explicação. Uma vez que a professora exige também o uso de vetores, eu dou um jeito de implementar na tarefa 2!

 

Vou te incomodar só uma última vez! Abaixo, segue o código quase pronto (no case 2 do primeiro switch eu devo elaborar uma função que realize algum tipo de processamento em um conjunto de caracteres - vou ver o que faço depois).

 

O que eu gostaria de saber é se há alguma possibilidade de implementar alguma função do tipo int, float ou double e se as funções já utilizadas (void) contam como passagem de parâmetros (acredito que sim, né?).

#include <stdio.h>
#include <locale.h>
#include <math.h>
#include "Biblioteca_Projeto.h"
main()
{
char option,optionf;
float a,b;
double c;
int qtd;



setlocale(LC_ALL,"portuguese");
printf("\t\t\t\tMENU PRINCIPAL");
printf("\n\n1- Valores de y=f(x) para as funções: ");
printf("\n   a- Função Afim;");
printf("\n   b- Função Linear;");
printf("\n   c- Função Constante;");
printf("\n   d- Função Exponencial;");
printf("\n   e- Função Polinomial de Segundo Grau.");
printf("\n2- Indefinido");
printf("\n3- Sair");
printf("\n\nDigite a opção desejada: ");
scanf("%d",&option);
system("cls");

switch(option)
{
case 1: do{
        printf("\t\t\t\tMenu - Funções");
        printf("\n\nFunções: ");
        printf("\n   1- Função Afim;");
        printf("\n   2- Função Linear;");
        printf("\n   3- Função Constante;");
        printf("\n   4- Função Exponencial;");
        printf("\n   5- Função Polinomial de Segundo Grau;");
        printf("\n   6- Voltar ao menu principal.");
        printf("\n\nDigite a opção desejada: ");
        scanf("%d",&optionf);
        system("cls");
        while(getchar() != '\n')continue; //[?] limpa o stream da telca ENTER;

switch(optionf)
{
case 1: {printf("\t\t\t\tFUNÇÃO AFIM");
        printf("\n\nPara a função do tipo y=ax+b, determine os parâmetros:");
        printf("\n\nDigite o valor de a: ");
        scanf("%f",&a);
        printf("\nDigite o valor de b: ");
        scanf("%f",&b);
        printf("\nInforme o número de pontos, da coordenada x: ");
        scanf("%d",&qtd);
        float mat[qtd][2];
        preenche_mat_x(qtd,mat);
        preenche_mat_y(qtd,mat,a,b);
        show_mat_pontos(qtd,mat);}
        break;

case 2: {int index;
        printf("\t\t\t\tFUNÇÃO LINEAR");
        printf("\n\nPara a função do tipo y=ax, determine o parâmetro:");
        printf("\n\nDigite o valor de a: ");
        scanf("%f",&a);
        printf("\nInforme o número de pontos, da coordenada x: ");
        scanf("%d",&qtd);
        float mat[qtd][2];
        preenche_mat_x(qtd,mat);
        for(index=0;index<=qtd-1;index++)
        {
        mat[index][1]=a*mat[index][0];
        }
        show_mat_pontos(qtd,mat);}
        break;

case 3: {int index;
        printf("\t\t\t\tFUNÇÃO CONSTANTE");
        printf("\n\nPara a função do tipo y=b, determine o parâmetro:");
        printf("\n\nDigite o valor de b: ");
        scanf("%f",&b);
        printf("\nInforme o número de pontos, da coordenada x: ");
        scanf("%d",&qtd);
        float mat[qtd][2];
        preenche_mat_x(qtd,mat);
        for(index=0;index<=qtd-1;index++)
        {
        mat[index][1]=b;
        }
        show_mat_pontos(qtd,mat);}
        break;

case 4: {int index;
        printf("\t\t\t\tFUNÇÃO EXPONENCIAL");
        printf("\n\nPara a função do tipo y=c^x, determine o parâmetro:");
        printf("\n\nDigite o valor de c: ");
        scanf("%lf",&c);
        printf("\nInforme o número de pontos, da coordenada x: ");
        scanf("%d",&qtd);
        float mat[qtd][2];
        preenche_mat_x(qtd,mat);
        for(index=0;index<=qtd-1;index++)
        {
        mat[index][1]=pow(c,mat[index][0]);
        }
        show_mat_pontos(qtd,mat);}
        break;

case 5: {int index;
         double a_p;
         float c_p;
        printf("\t\t\t\tFUNÇÃO POLINOMIAL");
        printf("\n\nPara a função do tipo y=ax^2+bx+c, determine os parâmetros:");
        printf("\n\nDigite o valor de a: ");
        scanf("%lf",&a_p);
        printf("\nDigite o valor de b: ");
        scanf("%f",&b);
        printf("\nDigite o valor de c: ");
        scanf("%f",&c_p);
        printf("\nInforme o número de pontos, da coordenada x: ");
        scanf("%d",&qtd);
        float mat[qtd][2];
        preenche_mat_x(qtd,mat);
        for(index=0;index<=qtd-1;index++)
        {
        mat[index][1]=pow(a_p*mat[index][0],2)+b*mat[index][0]+c_p;
        }
        system("cls");
        printf("Pontos (x ; y):");
        for(index=0;index<=qtd-1;index++)
        {
        printf("\n\n%dº Ponto: (%.2f;%.2lf)\n",1+index,mat[index][0],mat[index][1]);
        }}
        break;

case 6: return main();

default: printf("Opção Inválida! Tente novamente.");
}
printf("\n\n");
system("pause");
system("cls");
}while(option!=6);

case 2: //Sei Lá!!!!!!!!

case 3: printf("\n\t\t\t\tFIM DO PROGRAMA!!");
        printf("\n\n\n");
}
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////////////////////

Biblioteca_Projeto
  
void preenche_mat_x(int qtd, float mat[qtd][2])
{
int index;

for(index=0;index<=qtd-1;index++)
{
printf("\nEntre com valor real para x%d: ",index+1);
scanf("%f",mat[index]);
}

return;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void preenche_mat_y(int qtd, float mat[qtd][2], float a, float b )
{
int index;

for( index=0;index<=qtd;index++)
{
mat[index][1]=a*mat[index][0]+b;
}

return;
}
//////////////////////////////////////////////////////////////////////////////////
void show_mat_pontos(int qtd, float mat[qtd][2] )
{
int index;

system("cls");
printf("Pontos (x ; y):");

for(index=0;index<=qtd-1;index++ )
{
printf("\n\n%dº Ponto: (%.2f ; %.2f)\n",1+index,mat[index][0],mat[index][1]);
}

return;
}
///////////////////////////////////////////////////////////////////////////////////
  

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×