Utilização de funções em c

Mateus Nunes · 21 de novembro de 2016

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;

Ansi C · 21 de novembro de 2016

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

Mateus Nunes · 21 de novembro de 2016

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]);
        }
}

vangodp · 21 de novembro de 2016

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.

Mateus Nunes · 21 de novembro de 2016

Valeu vangodp!!!!

Ansi C · 21 de novembro de 2016

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

Mateus Nunes · 21 de novembro de 2016

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?

Ansi C · 21 de novembro de 2016

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

Mateus Nunes · 21 de novembro de 2016

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

Ansi C · 21 de novembro de 2016

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.

Mateus Nunes · 21 de novembro de 2016

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