Funções em C : Como, Porquê e usos.

A Função em C,  - e em praticamente todas as outras linguagens de programação-, pode ser definida como um trecho de código, responsáveis por executar determinada função. A função pode ou não receber e devolver parâmetros de entrada e saída.

Por que utilizar? 

Reutilização de código - Vamos supor que hoje eu desenvolva um projeto em C de uma calculadora científica. E neste projeto separei em funções todos os cálculos necessários para o funcionamento da calculadora. Posteriormente, desenvolvo outro projeto para cálculo de impostos de determinada empresa. Em vista que já possuo métodos de cálculos que podem calcular alíquotas, taxas, percentuais e etc, é visível o ganho de tempo que posso ter aproveitando o código de um projeto em outro. Utilizando o conceito de funções, esse ganho é muito facilitado.

Manutenção mais fácil -  Colocando o código dentro de uma função, em caso de necessidade de alteração deste código, somente se altera uma vez. No caso de não utilização de função, em todos os lugares onde o código é repetido, teria que ser alterado ( o que é um prato cheio para se esquecer algo e ter um trabalhão para se achar depois.

Modularização do programa - Em programas de grande porte, as funções podem ser utilizadas somente para melhorar a leitura e compreensão do código. Da maneira que desenvolvemos até agora, ao desenvolver grandes programas, dar manutenção aos mesmos pode ser complicado, principalmente se o código inicial for de outra pessoa. Pode ser mais fácil, criar uma função para leitura de dados, outra para o processamento e outra para exibição do resultado final.

Depois de toda essa teoria, vamos a prática - e para exemplificar, faremos o seguinte exercício :

O usuário digitará quantos números quiser, e o programa retornará se o número digitado é primo ou não.

Segue o código comentado:



#include <stdio.h> 
#include <stdbool.h> /*Esta biblioteca nos permite usar os parâmetros TRUE e FALSE 

Criação da função - com o parâmetro de entrada V_NUMERO
O tipo da função BOOL determina que a função retorne um valor VERDADEIRO ou FALSO.
*/
bool verifica_numero_primo(int v_numero)
{
int v_cont;     /*Contador 1 até v_numero*/
int v_resto_div;
int v_cont_primo;

v_cont = 1;
v_cont_primo = 0;

 while( v_numero >= v_cont )
  {
 
   v_resto_div = v_numero % v_cont ; /* operador % pega o resto da divisão, de 1 até o numero digitado*/

   if(v_resto_div == 0)  /* conta a quantidade de divisões que tiverem 0 como resto*/
   {
    v_cont_primo = v_cont_primo + 1;
   }
 
   v_cont++ ; /*O comando ++ soma 1 a variável atual */
  }

  if(v_cont_primo <= 2) /*Se for menor ou igual a 2, o numero é primo( divisível por 1 e por ele mesmo
Retorno da função: verdadeiro ou falso
*/
  {
  return (true);
  }else{
  return (false);
  }
}

 /*Código principal */
int main() {

 int v_numero; /*Numero que sera verificado - digitado pelo usuário em tela */
 bool v_primo; /* tipo bool - armazena true ou false*/
 int tecla;

 do {

 /*Lê numero que sera verificado */
 printf("Digite um numero \n");
 scanf("%d", &v_numero);

 /*Chama a função e armazena o retorno dela na variável v_primo
    Para funções sem retorno, pode-se utilizar o tipo void
 */
 v_primo = verifica_numero_primo(v_numero);

 if (v_primo == true) {
  printf("\nO numero %d e primo", v_numero);
 }else{
  printf("\nO numero %d nao e primo", v_numero);
 }
 printf("\n Digite ENTER para sair ou qualquer outra tecla para processar outro numero\n");

  fflush(stdin); /*Limpa buffer do teclado*/

 tecla = getchar(); /* Lê o carácter digitado em tela, se for igual a 13 ( código do enter na tabela ASCII, sai do programa, caso contrário, executa novamente*/ 

} while(tecla != 13 & tecla != 10);

}

Obs.: Utilizei o código do Enter para encerrar a execução do programa. Por padrão, o código do enter na tabela ASCII é 13, mas no computador que estou por exemplo, este código é igual a 10.

Obrigado e até a próxima.

Números aleatórios em C

Demorou mais saiu ! Mais um exercício de C, nos voltando agora para a escolha randômica de números .

Para demonstrar a utilização dos números randômicos em C, faremos um pequeno programa que nos dara 6 números de 1 a 60 ( Dai jogar na mega-sena é com você).

Segue o código explicado:


 #include <stdio.h>
#include <time.h> 

/*Por que incluir a biblioteca TIME.H ? Basicamente por que nosso computador não gera 
números aleatórios, alias a função do computador é executar comandos de maneira exata.
Portanto, utilizaremos funções da biblioteca TIME.H que, utilizando o tempo (milesimos, etc)
nos gerará números pseudo-aleatórios */

#define MAX 60
#define QTDE 6

int main() {
  int i;
  int num[QTDE];

  srand(time(NULL));
  
  /*A função SRAND inicializa os valores de calculo da funcao RAND com o tempo atual
  isso evita que todas as vezes que exercutarmos o programa, exibirmos os mesmos valores*/
 
   for(i=0; i< QTDE; i++)
  {
  num[i] =  (rand() % MAX );
  /* O complemento do comando rand, %MAX, limita o número máximo que será gerado 
 pela função. O mesmo é definido pela constante MAX(60) */
  }
 
  /*Exibição dos valores*/
  printf("Numeros sorteados: \n");
  for(i=0; i< QTDE; i++)
  {
   printf(" %d ", num[i]) ;
  }
 
  return 0;
}

Execução:

Por que números aleatórios?

Em grandes sistemas comerciais, realmente a utilização deste recurso é muito pouca, ou quase nenhuma. Mas imagine um jogo de luta, onde o adversário sempre te ataca da mesma forma repetidamente. Meio chato né? Um comportamento "aleatório" é necessário neste caso. Principalmente no ramo de jogos, e quaisquer outros desenvolvimentos onde esta interação com o usuário é necessária, existe a necessidade de se utilizar deste recurso.

Sugestões de melhoria no algoritmo !

Vamos supor que eu queira utilizar o programa acima para jogar na loteria. Para isso, precisamos garantir que o programa não calcule aleatoriamente o mesmo número( isso é possível). Para facilitar para o usuário também seria bom exibir o resultado de forma crescente. Que tal implementar essas modificações?

Média ponderada com Vetor em C

Bom dia!,

Considerando o último post, onde utilizamos vetores para cálculo de uma média aritmética, adaptei o mesmo programa para cálculo de uma média ponderada.
Ex.: Nota 1 tem Peso 1, Nota 2 tem peso 2 e Nota 3 tem peso 3. Simulando as notas 5, 10 e 7 com estes pesos, temos :

(5 * 1) + (10 * 2 ) + ( 7 * 3) / 1+ 2 + 3 =
5+ 20 + 21 / 6 =
46 / 6 = 7,66

Testando o programa:

Segue abaixo o código do programa, comentado:

int main(int argc, char *argv[]) {

int num_media[QTDE]; /* Vetor de variavel numerica(int) com 10 posicoes*/

int peso_media[QTDE]; /* Vetor de variavel numerica(int) com 10 posicoes*/

int indice;

float media;

int qtde_pesos; 

for(indice = 0; indice < QTDE ; indice ++){

printf ("\n Digite o valor %i  \n", indice +1 );

scanf("%d", &num_media[indice]); /*Le os valores e armazena no indice. 

A variável que está entre [ ] define em qual posição o valor será armazenado*/

printf ("\n Digite o peso do valor %i  \n", indice +1 );

scanf("%d", &peso_media[indice]);

}

for(indice = 0; indice < QTDE ; indice ++){

/* Executa o mesmo laço acima, porem com os vetores preenchidos*/

/* Soma todos os valores, multiplicados por seus pesos*/

media = media + ( num_media[indice] * peso_media[indice] );

qtde_pesos = qtde_pesos + peso_media[indice] ; /* Soma os pesos para posterior divisão*/

}

media = media / qtde_pesos; /*Divide a soma pela quantidade de termos*/

/*Exibe o resultado*/

printf ("\n A media ponderada E %f", media);

return 0;

}

Vetor em C - Primeiro exercício

Bom dia!

Hoje começaremos a trabalhar com vetores. Em programação, podemos utilizar destes vetores para facilitar a resolução de determinados problemas e dar maior flexibilidade ao código, assim como facilitar a manutenção do mesmo.

Ex.: Faça um programa que receba 10 números e mostre a média aritmética simples dos mesmos.

Para resolução deste exercício, não parece muito inteligente criar 10 variáveis, soma-las e dividi-las por 10.  Se houver uma alteração e for necessário receber 15 números, teriam que ser criadas mais 5 variáreis, mais 5 impressões e 5 leituras na tela ?

Com a utilização de vetores, podemos deixar nosso código com uma customização e manutenção mais fácil, conforme código abaixo:

#include <stdio.h>
#include <stdlib.h>

#define QTDE 10

int main(int argc, char *argv[]) {

int num_media[QTDE]; /* Vetor de variável numérica(int) com 10 posições*/
int indice;
float media;

for(indice = 0; indice < QTDE ; indice ++){
/*Esta é a primeira vez que utilizamos o comando FOR nos nossos exercícios
é uma estrutura de repetição que trabalha com contador, onde se define 3 passos :
indice = 0 ; Define o inicio do laço
indice < QTDE ; A condição para o fim da execução do laço, quando o indice for 
menor do que a quantidade especificada acima (10), o laço não será mais executado;
indice ++ ; corresponde ao comando indice = indice + 1; 
*/
printf ("\n Digite o valor %i do vetor \n", indice +1 ); /* O índice vai de 0 a 9. Somamo                        mais 1 para ir de 1 a 10*/
scanf("%d", &num_media[indice]); /*Le os valores e armazena no índice. 
A variável que está entre [ ] define em qual posição o valor será armazenado*/
}

for(indice = 0; indice < QTDE ; indice ++){
/* Executa o mesmo laço acima, porem com o índice preenchido*/
/* Soma todos os fatores*/
media = media + num_media[indice];
}

media = media / QTDE; /*Divide a soma pela quantidade de termos*/
/*Exibe o resultado*/
printf ("\n A media aritmetica E %f", media);

return 0;
}

   O legal é que alterando o valor de QTDE, o programa passa a funcionar de acordo com a quantidade definida. Bem mais prático, né?

Programa de cálculo do Fatorial em C

Bom dia,

Seguindo nossa sequência de exercícios, em linguagem C, hoje calcularemos o Fatorial de determinados números definidos pelo usuário. Como o cálculo em si é simples, adicionei a este programa algumas sugestões que dei em exercícios anteriores, como só aceitar números positivos e  
dar a opção ao usuário de executar o programa novamente.
Segue abaixo o código comentado:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {

int num1;
unsigned long int total; /* Como o calculo do fatorial pode retornar numeros altos, declaramos 
a variavel int (numero inteiro) como unsigned long, onde não considera os numeros negativos. 
o long int  tem 16 bits(pode variar de acordo com seu processador) o que o faz suportar numeros         de  -2147483647, até + 2147483647. Com o undigned, esse valor vai de 0 até +4294967294*/
char continua;

do { /* A estrutura DO faz basicamente a mesma coisa que o WHILE, porém com a diferenca                         que a verificação da condição é feita no final, o que obriga a executar no minimo uma                         vez código entre o DO / WHILE*/

/* Entrada de dados*/
do{
printf("\n Digite um numero positivo para calculo de seu fatorial \n");
scanf("%d", &num1);
}while(num1 < 0); /* Não permite números negativos*/


/*o fatorial é o produto de determinado numero de 1 até N
No nosso programa multiplicamos n * n -1 até 1
Porem todas as variaveis quando criadas, estão zeradas
Para a primeira multiplicação, consideramos o valor de 1 * N*/

total = 1;

/* Processamento */
while(num1 != 0)
{
total = total * num1;
if (num1 > 1 ){
printf("%d * ", num1);
}else {
printf("%d ", num1);
}
num1 = num1 - 1;
}

  printf(" = %d", total);

fflush(stdin); /* Necessário para limpar o buffer do teclado, caso contrario não irá ler a operação*/

do{

printf("\n Deseja calcular outro numero ? (Y / N ))\n");
scanf("%c", &continua);

fflush(stdin); /* Necessário para limpar o buffer do teclado, caso contrario não irá ler a operação*/

/*&& = Operador "E". Ex.: Se continua diferente de Y e continua diferente de y, etc  */
if (continua != 'Y' && continua != 'y' && continua != 'N' && continua != 'n' )
{
printf("\n Opcao invalida !!! \n ");
}
/*Só sai do loop com uma operacao valida*/
}while(continua != 'Y'  && continua != 'y' && continua != 'N'  && continua != 'n' );

/*Se o usuario digitar Y, calcula outro fatorial, caso contrario termina o programa */
}while (continua == 'Y' || continua == 'y' );

return 0;

}


Fiquem a vontade para testar e melhorar o código!

Programa de cálculo da Sequência Fibonacci em C

Bom dia!

A sequência Fibonacci é uma sequência de números inteiros, que começa com 0 e 1 e segue com a soma dos dois últimos número dessa sequência. Ex.:

   0, 1  (Para calcular o próximo número = 0 + 1 = 1),

O que gera o próximo número dessa sequência :

0, 1, 1 (1+1 = 2)
0, 1, 1, 2 (1+2 = 3)
0, 1, 1, 2, 3.

Um algoritmo bem legal de ser implementado em C. Vamos ao código:

#include <stdio.h>
#include <stdlib.h>

int main() {

int v_qtde; /*Quantidade de numeros exibidos */

int num1, num2;
int prox_num;

printf("\n Sequencia Fibonacci \n");

v_qtde = 0;

while(v_qtde < 2) { /*Somente aceita numeros maiores que 2 */

printf("\n Digite a quantidade de numeros que deseja exibir : \n");
scanf("%d", &v_qtde);

if(v_qtde <= 2)
{
printf("\n A quantidade deve ser um número maior do que 2");
}
}

num1 = 0 ; /*Inicio da sequencia*/
num2 = 1;

printf("\n %d", num1);
printf("\n %d", num2);

while(v_qtde > 2) /*Calcula e exibe numeros*/
{
prox_num = num1 + num2; /*Soma os dois ultimos numeros para obter o proximo*/
num1 = num2; /*Atribui o segundo numero ao primeiro*/
num2 = prox_num; /*Atribui a soma dos dois numeros anteriores ao segundo numero*/

printf("\n %d", prox_num); /*Exibicao*/

v_qtde = v_qtde - 1; /*Diminui a quantidade, pois um item foi exibido*/
}
}

No programa acima, somente serão aceitos mais de dois termos para exibição, onde você pode usar essa lógica para aprimorar o  Programa para exibição de números Primos e não permitir termos negativos.

Você também pode adaptar esse programa para aceitar 1 ou 2 números.

Até +.

Programa de cálculo de números Primos em C

Bom dia!,

Lembram do algoritmo de exibição dos números primos ? (clique aqui) . Resolveremos o mesmo utilizando a linguagem C hoje.

Segue o código comentado abaixo:

int main() {

int v_qtde; /*Quantidade de numeros primos exibidos */
int v_cont1, v_cont2;
int v_cont_primo;
int v_resto_div;

v_cont_primo = 1;

/*Lê qtde numeros primos exibidos */

printf("Digite a quantidade de numeros primos que deseja exibir : \n");
scanf("%d", &v_qtde);

printf("Numeros primos : \n");

v_cont1 = 0;

while( v_qtde != 0 ) /* Enquanto a quantidade for diferente de 0 */
{
v_cont1 = v_cont1 + 1;
v_cont_primo = 0;
v_cont2 = 1;

while(v_cont1 >= v_cont2 ) /*Enquanto os contadores forem diferentes,
o contador 2 percorrerá de 1 até contador1 para verificar a quantidade de 
números divisíveis onde o resto for igual a 0. */
{

v_resto_div = v_cont1 % v_cont2 ; /* operador % pega o resto da divisao*/


if(v_resto_div == 0)  /* conta a quantidade de divisoes que tiverem 0 como resto*/
{
v_cont_primo = v_cont_primo + 1;
}

v_cont2 = v_cont2 + 1;

}

if(v_cont_primo <= 2) /*Se for menor ou igual a 2, o numero é primo( divisível por 1 e por ele mesmo*/
{
printf("\n  %d", v_cont1);
v_qtde = v_qtde - 1 ; /*Subtrai a quantidade, até 0*/
}

}

printf("\n");

return 0;
}

Testando:

Acho legal comparar esse programa com o inicial feito em português estruturado.

Obs.: Tente digitar um número negativo. Boa sorte na resolução deste problema !