Um vetor especial... Final (string/funções)

Como já disse o objetivo do C em tratar o vetor de caracteres (string) de uma forma especial é para facilitar nossa vida. Vamos ver isto hoje.

Funções especiais para um vetor especial.
Existem uma série de funções para trabalhar com strings em C que, em sua maioria, estão na biblioteca string.h.
Vamos conhecer as mais comuns e as facilidades que elas trazem.

Obtendo uma string (gets)
Até agora usamos a função scanf para obter dados inseridos pelo usuário.
Poderíamos continuar usando scanf para strings também, desta forma abaixo:

 char nome[21];
 scanf("%s",&nome);

Primeiro declaramos um vetor de caracteres chamado nome capaz de armazenar uma string de até 20 caracteres. Depois usamos a função scanf para armazenar neste vetor os caracteres digitados pelo usuário. Observe o uso do especificador de tipo "%s", que se refere a string.
Entretando o C possui uma função especializada para esta obtenção dos dados digitados pelo usuário: gets. Olhe o seu uso abaixo:

 char nome[21];
 gets(nome);

Bem menos digitação, o que significa uma economia de dedos (rsrs).
Ao contrário do que você possa pensar, a função gets está na biblioteca stdio.h e não na string.h.

Verificando o tamanho de uma string (strlen)
Quando definimos um vetor nem sempre sabemos se ele será totalmente preenchido. Na maioria dos casos, definimos um tamanho considerado razoável, que pode ser muito maior que o tamanho que será efetivamente usado. No exemplo acima utilizamos um vetor capaz de armazenar 20 caracteres. Se o usuário digitar um nome como ANA, por exemplo, que tem 3 caracteres nosso programa 'achará' que os 20 caracteres foram preenchidos. Poderíamos achar o tamanho efetivamente ocupado no nosso vetor fazendo um for e incrementando uma variável contadora até que o caracter \0 fosse encontrado.
No entanto o C facilita a nossa vida com uma função própria para isto a strlen. Observe o seu uso abaixo:

 int tamanho;
 tamanho = strlen(nome);

Ela retorna um inteiro com o número de caracteres efetivamente ocupado no nosso vetor.

Comparando strings (strcmp)
Imagine que você tenha que comparar 2 vetores. Seria necessário, avaliar cada item de um vetor e compará-lo com o respectivo item do outro vetor. Além disso, os vetores podem ter tamanhos diferentes.
No caso de strings, poderíamos verificar o tamanho de cada uma delas e, se fossem do mesmo tamanho, comparar os seus caracteres individualmente. Seria uma solução.
Mas não precisamos fazer isto. Temos uma função que faz isso para nós: strcmp. Observe o seu uso:

 char outro_nome[21];
 int result;
 result = strcmp(nome, outro_nome);

Esta função devolve um valor inteiro que corresponde ao resultado da comparação entre as duas strings da seguinte forma:

- result será menor que 0 (ou seja, um inteiro negativo) se nome for diferente e/ou menor que outro_nome;
- result será 0 se, e somente se, nome for igual a outro_nome (entenda por igual o mesmo número de caracteres, e os mesmo caracteres (um 'A' é diferente de um 'a') na mesma posição relativa (índice) em cada vetor;
- result será maior que 0 (ou seja, um inteiro positivo) se nome for diferente e/ou maior que outro_nome.

Em sua forma mais comum, só é verificado o resultado diferente de ou igual a 0.

Copiando uma string em outra (strcpy)
Para copiar o conteúdo de um vetor para outro vetor é necessário copiar item a item, e ainda verificar se o tamanho dos 2 vetores é compatível.
Seria possível copiar um vetor de 20 inteiros em um vetor de 10?
No caso das strings, temos uma função para fazer esta cópia: strcpy. Observe o seu uso:

 strcpy(nome, outro_nome);

Aqui estamos copiando o conteúdo de outro_nome em nome. Preste bastante atenção a isto, porque é muito fácil confundir.
Um detalhe importante é que alguns compiladores(acho que a maioria) permite copiar uma string maior em uma menor sem perda de dados. Na verdade a string menor é aumentada. Como isto é possível? Vejamos a próxima função.

Juntando strings (strcat)
Como juntar 2 vetores afim de formar 1 único vetor?
Poderíamos criar um 3o vetor cujo tamanho fosse igual a soma dos 2, e copiar todos os itens de cada um dos 2 vetores.
No caso de strings, temos uma função que faz isto para nós: strcat. Observe o seu uso:

 strcat(nome, outro_nome);

Ela concatena (que palavra estranha rsrs; prefiro junta ou acrescenta) outro_nome no final de nome. O tamanho de nome será a soma do tamanho anterior de nome com o tamanho de outro_nome.


Existem outras funções especializadas para o trabalho com strings. A medida que elas forem necessárias para a solução de algum problema proposto, nós falaremos sobre elas.
Para encerrar, vou deixar um pequeno código para exemplificar as funções que vimos neste post.

#include "stdio.h"
#include "stdlib.h"
#include "string.h"
 
int main(){
 char nome[21], outro_nome[21];
 char igualdade[10], frase[16] = "As strings sao ";
 int tam_nome, tam_outro;
     
 printf("Digite um nome (no maximo 20 caracteres): ");
 gets(nome);
 tam_nome = strlen(nome);
 printf("Digite um outro nome (no maximo 20 caracteres): ");
 gets(outro_nome);
 tam_outro = strlen(outro_nome);
 if (strcmp(nome, outro_nome) == 0)
    strcpy(igualdade,"iguais");
 else
    strcpy(igualdade,"diferentes");
 printf("%s tem %d caracteres e %s tem %d caracteres\n", nome, tam_nome, outro_nome, tam_outro);
 strcat(frase, igualdade);
 printf("%s\n", frase);
 printf("Se juntar %s e %s ", nome, outro_nome);
 strcat(nome, outro_nome);
 printf("o novo tamanho de %s sera %d\n", nome, strlen(nome));   
 system("pause");
}

Viu como é fácil?

Um vetor especial... Parte I (string/conceitos)

Hoje vamos falar sobre um vetor que o C trata de forma especial: o vetor de caracteres, também chamado de string.

A comunicação entre o homem e a máquina!
Como já aprendemos aqui, um vetor é um agrupamento de variáveis do mesmo tipo. Até agora trabalhamos com vetores de inteiros. Apesar de termos usado vetores de caracteres desde este post.
Você talvez não tenha percebido ainda, mas tudo o que está digitado aqui são vetores de caracteres. Uma palavra é formada de letras (caracteres) agrupadas (vetor).
Este é o tipo de vetor mais utilizado em programas que interagem com o usuário (mesmo nos programas com interface gráfica).
Por ser muito usado, este vetor é tratado de forma especial pelo C. Não que ele seja mais complicado, mas sim para facilitar o trabalho dos programadores (no caso, nós).
Vejamos como isto é feito.

Não acaba onde termina!
Como já falamos, um vetor em C sempre começa com o índice 0 (zero), mas não possui nenhum restrição quanto ao seu tamanho, ficando sob a responsabilidade do programador.
Relembrando: Se declararmos um vetor de inteiros com o tamanho 5 (int vet[5]), o seu último elemento será o que tem o índice 4 (tamanho do vetor - 1), mas se fizermos uma atribuição usando o índice 5 (vet[5] = 10), ela será aceita (apesar de estar errada). O compilador não tem como saber onde termina este vetor.
No caso do vetor de caracteres é necessário indicar este fim para que o compilador saiba onde ele acaba. Isto é feito com um caracter especial (\0).
Observe a figura abaixo:



Esta é a forma como o C armazena a palavra CASA. Um vetor de caracteres terminado por \0.
A forma de declarar e inicializar este vetor é:

  char vet[5] = {'C', 'A', 'S', 'A'};

ou como é mais comum:

  char vet[5] = "CASA";

Acredito que esta 2a forma é familiar. É ela que temos usado com a função printf. Observe que a palavra CASA tem 4 letras, mas nosso vetor tem tamanho 5, ou seja, existe um caracter a mais para guardar o \0.
No próximo post veremos como esta forma especial que o C trata os vetores de caracteres facilita nossa vida.

Aproveitando o post, gostaria de desejar a todos um ótimo Natal, com saúde, amor e paz, que são as coisas que realmente importam. Um abraço a todos.

Vetores x Funções

Recebi um comentário (neste post) com uma pergunta. Gostaria de agradecer o comentário e incentivar outras pessoas a fazer o mesmo. TEM ALGUMA DÚVIDA SOBRE O QUE ASSUNTO DO POST: PERGUNTE NOS COMENTÁRIOS!
Como o objetivo do blog é tornar o C mais fácil, sempre que receber alguma dúvida, responderei, no próprio comentário, quando for simples, ou num novo post, quando esta resposta necessitar de uma atenção maior (como é o caso hoje). Claro que observando a sequência dos assuntos (não venha me perguntar sobre árvores balenceadas ainda, na hora certa vou falar sobre elas).
A pergunta é esta: "Como faço para criar uma função que preencha e some vetores?
Ou não tem como fazer isso com função?"
A resposta é SIM. Antes de mostrar como, vamos ver (e rever) um simples detalhe.

No post em que falamos sobre ponteiros, aqui, vimos que o nome de um vetor corresponde ao seu endereço. Isto significa que um vetor sempre estará acessível a qualquer parte do programa (se conheço o endereço, posso acessar), bastando saber o seu nome. Assim, um vetor SEMPRE é passado às funções por referência, não tendo, nem ao menos, a necessidade de usar o & antes do nome do vetor.
Visto isto, vamos ao como.

//SOMANDO VETORES USANDO FUNÇÕES
#include "stdio.h"
#include "stdlib.h"
 
const int TAM=5;
 
int ler_int(){
 int digitado;
     
 printf("Digite um valor inteiro: ");
 scanf("%d",&digitado);
 return digitado;
}
 
void mostra_int(int num){
 printf("%d ",num);
}
 
void preenche_vetor(int vet[]){
 int i;
      
 for(i = 0; i < TAM; i++)
    vet[i] = ler_int();
}
 
void soma_vetores(int vet1[], int vet2[], int vet3[]){
 int i;
      
 for(i = 0; i < TAM; i++)
    vet3[i] = vet1[i] + vet2[i];           
}
 
void exibe_vetor(int vet[]){
 int i;
      
 printf("\n");
 for(i = 0; i < TAM; i++)
    mostra_int(vet[i]);
 printf("\n\n");
}
 
int main(){
 int vetor_A[TAM], vetor_B[TAM], vetor_C[TAM];
     
 printf("Preenchendo o 1o vetor\n");
 preenche_vetor(vetor_A);
 exibe_vetor(vetor_A);
 printf("Preenchendo o 2o vetor\n");    
 preenche_vetor(vetor_B);
 exibe_vetor(vetor_B);
 printf("Somando os vetores...\n");    
 soma_vetores(vetor_A, vetor_B, vetor_C);
 printf("\n\n");
 printf("Exibindo o vetor resultante da soma\n");    
 exibe_vetor(vetor_C);
 system("pause");
}

O código acima soma o conteúdo de 2 vetores (vetor_A e vetor_B) num 3o vetor (vetor_C).
Na linha 5 definimos e inicializamos uma constante inteira TAM que armazena o tamanho dos nossos vetores. Não é obrigatório, mas é uma excelente prática de programação. Por quê?
Neste exemplo trabalhamos com vetores de 5 elementos. Se decidirmos aumentar o tamanho desses vetores para 10 elementos, só precisaremos alterar uma única linha de código. Se não tivéssemos usado a constante precisaríamos alterar 4.
Uma novidade está na linha 19, é a forma de especificar um vetor como um parâmetro de uma função. A sintaxe formal é esta:

 <tipo de retorno> nome da função (<tipo de dados do vetor> nome do vetor [])

Note que não é necessário informar o tamanho do vetor.
Poderíamos inclusive usar a seguinte sintaxe (que é muito comum em programas profissionais):

 <tipo de retorno> nome da função (<tipo de dados do vetor>* nome do vetor)

O nome de um vetor corresponde ao seu endereço na memória, portanto, podemos tratá-lo como um ponteiro. Pode fazer um teste se quiser.
Já quando chamamos a função, linha 46, não é necessário o uso dos [].
Um erro muito comum é colocar os [] com o tamanho do vetor dentro deles. Ao fazer isto, ao invés de se passar o vetor inteiro, está sendo passada à função um único elemento do vetor, e pior ainda, um elemento que nem faz parte do vetor, já que por iniciar em 0(zero), o último elemento de um vetor é igual a tamanho do vetor - 1.
O restante de código já é (acredito ;)conhecido.

Mais alguma dúvida?

(Para pensar: Uma função pode retornar um vetor?)

Dividir para conquistar! Final (valor x referência)

Encerrando a nossa série sobre modularidade (existem outras coisas a falar, mas elas merecem atenção especial, ou seja, um post só para elas), vamos ver com mais detalhes como as variáveis 'caminham' entre as funções.

Como vimos no post anterior desta série (aqui), as variáveis declaradas entre as {} de uma função são locais à função, ou seja, não são acessíveis por outras funções do programa. No entanto, vimos, aqui, que é possível passar o retorno de uma função, que geralmente é uma variável local da função, para outras funções. Como isso acontece?

Não te conheço, mas sei o que você tem!
A forma correta de chamar uma função é passando os argumentos para os parâmetros que ela utiliza para fazer o seu trabalho. No exemplo que vimos na 1a parte desta série, para somar dois números, na linha 25 passamos as variáveis num1 e num2 como argumentos para a função soma_int que utiliza as variáveis val1 e val2 para fazer o seu trabalho.
Na verdade não passamos as variáveis, e sim o seu conteúdo. O que acontece realmente é que o conteúdo da variável num1 é copiado para a variável val1, e o conteúdo da variável num2 é copiado para a variável val2.
Esta operação é chamada de passagem por valor, porque os valores armazenados nos argumentos são copiados para os parâmetros.
Uma vez que a função trabalha com uma cópia do conteúdo das variáveis num1 e num2, o seu conteúdo permanece intacto, e a função soma_int consegue fazer o seu trabalho corretamente (todos ficam satisfeitos rsrs).
Mas, e se precisarmos alterar o conteúdo das variáveis num1 e num2? Seria possível?
Vejamos isto na prática. Observe o código abaixo.

//TROCANDO O CONTEÚDO DE VARIÁVEIS USANDO FUNÇÕES
#include <stdio.h>
#include <stdlib.h>
 
int ler_int(){
 int num;
 
 printf("Digite um numero inteiro: ");
 scanf("%d", &num);
 return num;
}
 
void troca(int val1, int val2){
 int aux;
     
 aux = val1;
 val1 = val2;
 val2 = aux;
}
 
void exibe_int(int val1, int val2){
 printf("\nO valor de num1 = %d e num2 = %d.\n", val1, val2);
}
 
int main(){
 int num1, num2;
     
 num1 = ler_int();
 num2 = ler_int();
 exibe_int(num1, num2);
 troca(num1, num2);
 exibe_int(num1, num2);
 system("pause");
}

Antes de executar este código, vamos falar sobre a função troca, que aparece na linha 13. Na linha 14, declaramos uma variável aux, que usaremos para salvar o valor armazenado na variável val1 antes de armazenar nela o valor da outra variável, val2, como mostrado nas linhas 16 e 17. O valor salvo em aux, ou seja o valor anterior de val1, será agora armazenado em val2.
Agora que entendemos como funciona a função troca, pode executar o código e observar o resultado.
Acredito que você já sabe o porquê dele não funcionar. Se não sabe, veja a razão.
Quando a função troca é chamada na linha 31, dentro da main, ela recebe os valores das variáveis num1 e num2, que são copiados para as variáveis val1 e val2 que são os seus parâmetros. Na verdade, os valores que são trocados são os de val1 e val2, e não os valores de num1 e num2 como desejado.
Para resolver situações como estas, entra em ação um recurso que já conhecemos: os ponteiros.

Não adianta se esconder... Eu sei onde você mora!
Se você não se recorda do funcionamento de um ponteiro, dê uma olhada aqui.
Agora observe como fica o nosso código usando este recurso.

//TROCANDO O CONTEÚDO DE VARIÁVEIS USANDO FUNÇÕES
#include <stdio.h>
#include <stdlib.h>
 
int ler_int(){
 int num;
 
 printf("Digite um numero inteiro: ");
 scanf("%d", &num);
 return num;
}
 
void troca(int* val1, int* val2){
 int aux;
     
 aux = *val1;
 *val1 = *val2;
 *val2 = aux;
}
 
void exibe_int(int val1, int val2){
 printf("\nO valor de num1 = %d e num2 = %d.\n", val1, val2);
}
 
int main(){
 int num1, num2;
     
 num1 = ler_int();
 num2 = ler_int();
 exibe_int(num1, num2);
 troca(&num1, &num2);
 exibe_int(num1, num2);
 system("pause");
}

Agora funcionou! Você sabe me dizer porquê?
Este uso de ponteiros para tornar possível o acesso a variáveis locais de outras funções é chamado de passagem por referência. Porque na verdade, não se passa o valor da variável, mas a sua referência, ou seja, o seu endereço na memória, que como sabemos, torna possível acessar e alterar esta variável.
Viu como é fácil (os ponteiros são nossos amigos rsrs).
Até a próxima.

Dividir para conquistar! Parte II (local x global)

Continuando o que começamos aqui, hoje, como prometido, vamos falar sobre o 'comportamento' das variáveis quando usamos modularidade.

Vamos brincar de esconde-esconde?
Existe um conceito em C chamado de escopo. Já procurei uma definição literal para a esta palavra e não encontrei. Então como costumo fazer, vamos à pratica.

#include "stdio.h"
#include "stdlib.h"
 
int b = 5;
 
int main(){
 int a, c;
     
 a = 6;
 c = a + b;
 printf("\na = %d, b = %d e c = %d.\n",a,b,c);
 {
    int a, c;
        
    a = 15;
    c = a + b;
    printf("\na = %d, b = %d e c = %d.\n",a,b,c);
    b = c;
 }
 c = a + b;
 b = 2 * a;
 printf("\na = %d, b = %d e c = %d.\n",a,b,c);
 system("pause");
}

Observe o código acima. Aliás, não só observe, fique curioso e coloque ele para rodar no seu micro. Já colocou? Viu a saída?
Vamos entender.
A princípio só vemos declarações de variáveis e atribuições. Mas na linha 12 vemos algo diferente (que acredito não ser comum em códigos fonte profissionais, mas funciona rsrs). Como sabemos, as {} separam um bloco de comandos, geralmente estes blocos estão ligados a instruções de decisão e repetição (if, while, for), e também a funções; mas elas também funcionam sozinhas, como mostrado neste código.
Observe os comandos das linhas 7 e 13, e das linhas 10 e 16. São os mesmos comandos, só as variáveis envolvidas que são diferentes, apesar de terem os mesmos nomes.
Como já vimos, aqui, os nomes das variáveis são 'etiquetas' (rótulos) que identificam endereços de memória. Apesar de estarem usando a mesma 'etiqueta', os endereços das variáveis declaradas nas linhas 7 e 13 são diferentes. O C não se confunde por causa das {}.
Quando são feitas as operações dentro das {}, são usadas as variáveis declaradas dentro das {}. Assim o valor da variável a que é impresso no printf da linha 11 é um, e o da linha 17 outro. O valor de a impresso pelo printf na linha 21 é o mesmo impresso pelo printf da linha 11, pois é a mesma variável. A atribuição da linha 15 não altera o seu valor, já que ela altera outra variável, que por acaso (neste caso, propositalmente) tem o mesmo nome. Dizemos que as duas variáveis tem escopo diferente.
Quando se trata de funções, dizemos que a variável declarada entre as {} do bloco de comandos de uma função é uma variável local da função. Ela fica 'escondida' dentro das {}, e para todas as outras funções é como se ela nem existisse.
Lembra do que já falamos sobre funções. Uma função é uma 'caixa preta', não precisamos saber como ela faz as coisas, apenas os parâmetros que ela precisa e o retorno que fornece (isto quando ela precisa de parâmetros e dá algum retorno). Ela pode usar uma série de variáveis, mas não precisamos tomar conhecimento da existência delas.
Em oposição a isto, existe um tipo de variável chamada de global. Temos um exemplo de uma variável assim na linha 4 do nosso código exemplo acima: é a variável b.
Ela é declarada e inicializada fora de qualquer bloco, fora até mesmo da função main. Observe que utilizamos o valor de b para fazer a operação de soma da linha 10, e usamos este mesmo valor na soma da linha 16, que está dentro das {}.
Por ser global, esta variável é 'vista' por qualquer parte do programa (funções, inclusive), e também pode ser alterada em qualquer parte do programa.
Fazemos uma alteraçao no valor da variável b na linha 18, que está dentro das {}, e este novo valor de b é usado na soma que é realizada na linha 20, fora das {}, e depois alterado na linha 21.
Até o próximo post.

Dividir para conquistar! Parte I (funções)

Até o presente momento vimos exemplos de códigos fontes pequenos, com uma utilidade muito pequena (coisa muito difícil de encontrar no 'mundo real'), e portanto, muito fácil de acompanhar, compreender o seu funcionamento e eliminar os seus erros.
Eu já disse algumas vezes aqui no blog que é fácil encontrar códigos fonte com mais de 1000 linhas. Imagine a dificuldade para acompanhar um código desses!
E imagine a quantidade de tempo que 1 programador levará para concluir este código!
Para resolver estas questões o C usa uma metodologia chamada de modularidade.

O que é modularidade?
Imagine que você fosse o chefe de um grupo que deveria criar uma maquete de uma fábrica. Lógico que você iria dividir este trabalho de criação em várias partes. Dividindo entre os componentes do grupo cada uma dessas partes de acordo com o que cada um sabe fazer. Não seria inteligente deixar alguém fazer algo que não é sua especialidade tendo na equipe um especialista nesta tarefa.
Isto é modularidade!
Dividir uma tarefa grande em várias partes menores e especializadas. Quando digo especializada, quero dizer que idealmente, cada módulo fará uma única tarefa.(O que você prefere? Ser atendido por um médico especializado na sua doença ou por um clínico geral?)
Cada um desses módulos é chamado de função.
As funções podem ser classificadas de acordo com seus parâmetros e retorno.

O que são parâmetros? E retorno?
Algumas funções precisam de dados para cumprir a tarefa para a qual foram criadas. Esses dados são chamados de parâmetros da função.
Voltando ao exemplo da maquete, se você quiser um prédio em sua maquete, terá que dizer a quem irá fazê-lo quantos andares ele terá, qual a cor dele, se terá entrada lateral, etc. Se essas informações não forem passadas, o responsável não saberá como fazê-lo, ou poderá fazê-lo da forma que ele quiser, que pode não ser a que você desejava.
De posse dessas informações (argumentos), o prédio será construído conforme especificado, seguindo esses parâmetros.
Existem funções que precisam de vários parâmetros, outras que precisam de apenas 1 parâmetro, e ainda, as que não precisam de nenhum paramêtro.
Se você quisesse a sua maquete bem realista, poderia pedir a um componente do grupo que fizesse alguns carros populares para ficar no estacionamento da fábrica. Este componente é especialista em fazer carros populares, portanto, não é necessário passar nenhuma informação para ele. Ele fará os carros e entregará.
Já o retorno é o dado que a função devolve depois de fazer o seu trabalho.
No exemplo da maquete, seria o prédio e os carros.
Diferente dos parâmetros, o retorno só permite duas configurações: 1 ou nenhum.
Você pode se perguntar: Mas não seriam vários carros?
Você está certo. O que acontece na verdade, é que o responsável por fazer os carros, os faz um a um. E também os entrega um a um.
Neste exemplo da maquete, você é o chefe da equipe, o coordenador do projeto. Você passa a tarefa para o componente, e ele devolve o trabalho pronto. Você apenas agrupa o resultado. Pode ser que inclusive, você tenha que passar o resultado final do trabalho de um componente para um outro componente como a matéria-prima deste.
Num programa em C, esta função de coordenação é feita pela função main (sim, a main é uma função!).
Vamos ao exemplo de um programa que faz a soma de 2 números inteiros digitados pelo usuário usando este conceito de modularidade.
Antes de ver o código propriamente dito, vamos pensar nas funções que precisamos para executar essa tarefa.
1o precisamos de uma função que receba os valores inteiros digitados pelo usuário e devolva estes valores. Como sabemos ela não pode devolver os 2 valores de uma só vez. Então ela deve ler um valor e retornar este único valor. Depois ela será executada de novo para o outro valor.
Esta função precisa de algum parâmetro? A resposta é NÃO. Ela é especializada em ler inteiros, e inteiros são sempre inteiros. Acredito que ela não necessite de nenhum. E tem algum retorno? Com certeza. São os valores digitados pelo usuário.

2o precisamos de uma função que faça a soma propriamente dita.
Esta função precisa de parâmetros? Com certeza. São os valores digitados pelo usuário, que vieram da função anterior.
E tem algum retorno? Com certeza. É o resultado da soma.

3o precisamos de uma função que mostre ao usuário o resultado da soma.
Esta função precisa de algum parâmetro? Com certeza. É o resultado da soma retornado pela função anterior.
E tem algum retorno? A resposta é NÃO. Já que o valor vai ser mostrado e nada mais será feito no programa, não existe esta necessidade.

Vamos ver uma representação gráfica disto:



As setas indicam 'o caminho' das variáveis. As vermelhas indicam as variáveis que as funções retornam para a função main, e as pretas indicam as variáveis que a função main passa para as funções. (Eu iria usar outras cores, mas não poderia deixar de fazer esta homenagem ao HEXA DO MENGÃO! rsrs)

Uma função em C, é declarada da seguinte forma:

 <tipo de retorno> nome da função (<tipo do parâmetro> nome do parâmetro, <tipo do parâmetro> nome do parâmetro, ..., <tipo do parâmetro> nome do parâmetro){
    comandos da função
}

Vamos ao código, que eu explico os detalhes depois.

//EXEMPLO DO USO DE FUNÇÕES
#include <stdio.h>
#include <stdlib.h>
 
int ler_int(){
 int num1;
 printf("Digite um numero inteiro: ");
 scanf("%d", &num1);
 return num1;
}
 
int soma_int(int val1, int val2){
 return val1 + val2;
}
 
void exibe_result(int resultado){
 printf("O resultado da operacao eh %d.\n", resultado);
}
 
int main(){
 int num1, num2, result;
     
 num1 = ler_int();
 num2 = ler_int();
 result = soma_int(num1, num2);
 exibe_result(result);
 system("pause");
}

A 1a função, que se encontra na linha 5, é a ler_int. Pelo seu cabeçalho, vemos que é uma função que devolve um valor inteiro e não necessita de nenhum parâmetro. Vejamos o que esta função faz.
Na linha 6 é declarada uma variável inteira num1, que será usada para receber o valor digitado pelo usuário e retornar este valor para a função main.
Observe a linha 7 onde é mostrada ao usuário uma mensagem indicando o que ele deve fazer. Poderíamos ter algum código para verificar se o valor digitado está dentro de uma faixa específica, dentre outras coisas.
Na linha 8, o valor digitado pelo usuário é armazenado na variável inteira num1 usando o scanf. Até aqui não há nada que já não vimos antes.
A novidade está na linha 9. Observe o uso da palavra reservada return. É assim que é feito o retorno (será por isso que ele tem esse nome?) do valor para a função main. Neste caso, o valor retornado será o que está armazenado na variável inteira num1.
Na linha 12, temos a nossa 2a função, que é a soma_int. Esta função retorna um valor inteiro e necessita de 2 parâmetros inteiros (não é obrigatório que os parâmetros sejam do mesmo tipo retornado pela função, poderia ser de qualquer tipo e em qualquer quantidade, como já vimos).
Um outro detalhe interessante está na linha 13. Observe que é retornado o resultado da soma dos valores passados como parâmetros. Poderíamos ter declarado uma variável inteira, ter atribuído o resultado desta soma à variável e, só então, retornar o valor armazenado nela. A escolha de uma forma ou outra é exclusiva do programador. Eu, particularmente, prefiro como se encontra no código.
A 3a função, exibe_result, que aparece na linha 16, já começa com uma novidade.
Como vimos acima, esta função não retorna nenhum valor. A forma em C de especificar isto é usando o tipo void (lembra dele?). Isto significa que a função não retorna NADA. Além disto, ela necessita de 1 parâmetro, que é o que vai ser exibido, neste caso o resultado da soma que é retornado pela função soma_int.
A última função deste código é a main, que aparece na linha 20. Como já falei antes é ela que coordena o 'trabalho' das outras funções. Vamos ver como ela faz isto.
Na linha 21 são declaradas 3 variáveis inteiras. Elas são necessárias para receber o valor retornado pelas funções (se uma função devolve um valor, ele tem que ser armazenado em algum lugar ou será perdido).
Observe que uma destas variável tem o nome de num1, o mesmo nome daquela variável usada pela função ler_int, lá na linha 6. Antes que você reclame, deixe-me falar uma coisa: elas tem o mesmo nome, mas são a mesma 'pessoa' (rsrs).
A variável num1 de ler_int, só 'existe' enquanto a função ler_int está em execução. E enquanto isto a variável num1 da main, fica 'desativada'.
Dizemos que essas variáveis são locais. Mais a frente falaremos detalhadamente sobre isto. Por enquanto basta saber isto.
Na linha 23, está a 1a chamada da função ler_int. Este é o nome técnico usando para indicar que uma função será executada. Observe que é feita uma atribuição nesta mesma linha. Como já falamos, é para salvar o retorno da função.
Quando não existe um retorno, a forma da chamada é igual a da linha 26: somente o nome da função e os argumentos (os valores que são passados para preencher os parâmetros de uma função são chamados de argumentos) que ela necessita, se ela necessitar de algum.
Acredito que o restante do código agora ficou fácil de entender.
Uma outra coisa interessante a respeito das funções, é que é possível passar o retorno de uma função diretamente como argumento para outra função, sem precisar armazená-lo em uma variável.
Olhe este código abaixo e veja se consegue entender o que ele faz.

//EXEMPLO DO USO DE FUNÇÕES
#include <stdio.h>
#include <stdlib.h>
 
int ler_int(){
 int num1;
 printf("Digite um numero inteiro: ");
 scanf("%d", &num1);
 return num1;
}
 
int soma_int(int val1, int val2){
 return val1 + val2;
}
 
void exibe_result(int resultado){
 printf("O resultado da operacao eh %d.\n", resultado);
}
 
int main(){
 
 exibe_result(soma_int(ler_int(), ler_int()));
 system("pause");
}

Fácil não é?
Até a próxima.

Tá apontando o quê? (ponteiros)

Além dos tipos básicos e dos tipos estruturados (que vimos aqui e comentamos alguma coisa aqui), o C possui um tipo de dados especial: o tipo ponteiro.

A função principal do ponteiro é ... APONTAR (não é brincadeira!).
Vamos ver como isso funciona.

Eu sei onde você está!
Podemos imaginar um ponteiro como uma posição na memória onde está armazenado algum valor que pode ser alterado. Então um ponteiro é uma variável?

SIM e NÃO (rsrs).

A diferença entre um ponteiro e uma variável está no tipo de valores que eles podem armazenar. Enquanto uma variável pode armazenar caracteres, números inteiros e reais; um ponteiro armazena endereços de memória.
No post em que falamos sobre vetores (aqui), vimos a relação entre as variáveis e a sua posição na memória. Observe a figura abaixo (que é a última daquele post).



Se você clicou no link e viu o post sobre vetores, irá reparar que a numeração abaixo dos 'quadrinhos' está diferente. Por quê?

É diferente... mas é a mesma coisa!
Enquanto no referido post os números abaixo dos 'quadrinhos' indicavam os índices do vetor, neste se referem aos endereços de memória.
Um ponteiro que apontasse para o 3o elemento deste vetor estaria armazenando o valor 52.
Repare que os valores de endereço aumentam (ou diminuem) de 4 em 4. Isto acontece porque, neste exemplo, são necessários 4 bytes para armazenar um valor inteiro. Portanto, o ponteiro de que falamos acima é um ponteiro para inteiros. Se fosse um vetor de caracteres, onde cada caracter é armazenado em 1 byte, precisaríamos de um ponteiro para caracteres.

E qual é a vantagem de usar um ponteiro?
Antes de ver um ponteiro em ação (rsrs), vamos ver a sua sintaxe.

 int *pint;

O comando acima declara uma variável do tipo ponteiro para inteiros com o nome pint. Se quisermos apontar para um float o comando seria:

 float* pfl

Não é necessário que o nome do ponteiro comece com p (embora seja uma boa prática), nem que tenha o tipo da variável. Só deve ter o tipo e o *, que pode estar tanto junto ao nome como ao tipo.

Uma das vantagens no uso de um ponteiro está no fato de que além de apontar para o endereço de uma variável, também é possível ter acesso ao conteúdo desta variável usando o ponteiro. A esta operação se dá o nome de dereferenciar um ponteiro.

Como sempre, vamos ver isso na prática.

//EXEMPLO DO USO DE UM PONTEIRO
#include <stdio.h>
#include <stdlib.h>
 
int main(){
 int* pnum;
 int num = 10;
 
 pnum = &num;
 printf("O valor inicial de num eh %d.\n",*pnum);
 *pnum += 2;
 printf("O valor atual de num eh %d.\n",num);
 num--;    
 printf("O valor final de num eh %d.\n",*pnum);    
 system("pause");
}

O código acima é muito simples, mas mostra alguns fundamentos muito importantes. Vamos entender o que ele faz.
Na linha 6 definimos uma variável ponteiro para inteiros chamada de pnum. Na linha 7 definimos uma variável inteira num e a inicializamos com o valor 10.
Um ponteiro armazena endereços de memória. E é isso que fazemos na linha 9. Atribuimos o endereço da variável inteira num ao ponteiro para inteiros pnum.
Observe que a variável é do mesmo tipo do ponteiro. Se não fosse esta atribuição seria NÃO poderia ser feita.
Na linha 10 exibimos o valor de num dereferenciando o ponteiro pnum.
Além de acesso ao conteúdo da variável, também podemos alterá-lo usando o ponteiro, o que é mostrado na linha 11 e comprovado na linha 12. Acredito que agora você já saiba o que fazem as outras linhas (rsrs).
Você deve estar se perguntando o por quê de usar um ponteiro ao invés da própria variável. Isto vai se tornar claro quando falarmos sobre modularidade, que é a possibilidade de dividir um programa em várias partes, sendo que as variáveis de cada parte estão 'escondidas' das outras partes.

Outro uso muito comum de ponteiros é como uma forma alternativa de acessar elementos de um vetor. Esse acesso é feito através da aritmética de ponteiros.

Vetor x Ponteiro
Os dados armazenados numa variável do tipo ponteiro são endereços de memória (quantas vezes eu já repeti isso???). Esses endereços são sempre valores numéricos. E com esses valores podemos fazer algumas operações aritméticas (SOMENTE SOMA E SUBTRAÇÃO).
Observe este dois comandos aplicados a um ponteiro para inteiro pnum:

 (*pnum)++;
 pnum++;

O 1o comando incrementa o conteúdo da posição de memória apontada por pnum, ou seja, se na posição apontada por pnum estiver um inteiro com o valor 11, após este comando o valor deste inteiro passa a ser 12.
Já o 2o comando incrementa o valor armazenado em pnum. Como pnum é um ponteiro para inteiros, que estamos supondo necessitarem de 4 bytes para serem armazenados na memória, ao valor de pnum será somado 4.
Por exemplo, digamos que no código exemplo que usamos acima o endereço da variável inteira num fosse 38. Este valor foi atribuido ao ponteiro para inteiros pnum. Então o conteúdo de pnum é 38. Ao executar este 2o comando este conteúdo passa a ser 42. Ou seja, pnum não estará mais apontando para num, e passará a apontar para uma posição de memória na qual não sabemos o que está armazenado. Isto é extremamente perigoso, pois torna possível alterar algo que não deveria ser alterado.
Se para uma única variável isto é perigoso, para um vetor é um ótimo recurso, afinal um vetor é um grupo de variáveis do mesmo tipo armazenadas em sequência na memória.
Observe como ficaria o 2o exemplo do post sobre vetores utilizando aritmética de ponteiros.

//PROGRAMA QUE RECEBE 100 NÚMEROS INTEIROS
#include <stdio.h>
#include <stdlib.h>
 
int main(){
 int vetor[100], i;
 int* pvet;
     
 pvet = vetor;
 printf("Digite 100 numeros inteiros:\n");
 for(i=0; i < 100; i++){
    printf ("Valor %d: ",i+1);
    scanf("%d", pvet++);
 }
 system("pause");
}

Na linha 6 declaramos um vetor de 100 inteiros e uma variável inteira i que será usada para dar ao usuário uma noção de quantos valores ele já digitou. Na linha 7 definimos uma variável ponteiro para inteiros chamada pvet. Na linha 9 atribuimos o endereço do vetor ao ponteiro pvet (Numa atribuição, o nome de um vetor corresponde ao seu endereço). Na linha 13, dentro do for, é feita a leitura do valor digitado pelo usuário para a posição de memória apontada por pvet, que da 1a vez é a 1a posição do vetor, e depois o conteúdo de pvet é incrementado, passando a apontar para a próxima posição do vetor.

Viu como não é tão difícil quanto parece?