Voltar aos artigos

Aprendendo a Programar em C - O início

Uma introdução à linguagem C no estilo do primeiro capítulo do K&R: hello world, compilação, variáveis, laços, entrada e saída, arrays, funções, passagem de parâmetros e escopos.

Capa do artigo Aprendendo a Programar em C - O início

Introdução

Ponteiros, structs, alocação de memória, manipulação de bits - tudo muito assustador - mas é por estar tão perto do hardware que o C é uma das melhores linguagens pra se aprender a programar, sem abstrações que escondem conceitos fundamentais. Precisa de uma simples lista? Aloque memória para cada nodo, use ponteiros para encadear os nodos na memória do computador, armazene o ponteiro do primeiro nodo para conseguir iterar a lista. Mas chega de spoiler, bora pro vídeo.

Hello World

Não podemos começar de outro jeito senão criando o clássico hello world, um programa que simplesmente imprime hello, world na tela, começamos criando um arquivo hello com a extensão .c:

  #include <stdio.h>

  int main() {
    printf("hello, world\n");
  }
hello, world

C é uma linguagem compilada, então antes de executar qualquer programa, precisamos compilar. Em sistemas UNIX normalmente temos o comando cc, esse comando aponta pra um compilador C como o gcc ou clang.

Pra compilar nosso hello world, basta executar cc hello.c, e agora você terá um arquivo chamado a.out, esse é o programa compilado, ao executar temos o nosso hello, world impresso na tela. Perceba que não executei apenas a.out no terminal, adicionei um ./ na frente, vamos entender isso. Em sistemas Unix um nome de arquivo é entendido como um comando no terminal, o sistema irá buscar arquivos executáveis com esse nome nos diretórios especificados na variável de sistema PATH, e se não encontrar irá gerar o erro command not found. Por esse motivo que muitas vezes durante a instalação de programas você vai querer adicionar o diretório bin do programa no PATH pra poder executar como um comando a partir de qualquer lugar do sistema. Pra executar arquivos fora do PATH, precisamos informar o caminho do arquivo, mas isso não significa que temos que digitar o caminho completo desde a raiz do sistema de arquivos até a nossa pasta - esse é o caminho absoluto. Ao invés disso podemos utilizar caminhos relativos: ./ representa o diretório atual e ../ representa o diretório pai. Com isso em mente fica simples executar o arquivo a.out, basta digitar no terminal ./a.out. Se o arquivo a.out estivesse em um nível acima, poderíamos subir de nível com o comando cd .. ou executar diretamente com o comando ../a.out.

Agora vamos entender cada parte desse programa. Em alto nível, um programa em C consiste de funções e variáveis. Esse programa declara a função main, normalmente você pode nomear a função como desejar, mas essa função tem um papel especial, é o ponto de entrada do programa, quando rodamos ./a.out a execução começa a partir da função main. Normalmente a main irá chamar outras funções para completar a tarefa do programa. Algumas serão escritas por você, mas muitas outras são disponibilizadas em formas de biblioteca, como é o caso da função printf que imprime algo na tela (ou melhor, na saída padrão como veremos adiante).

A primeira linha do programa é uma instrução ao compilador pra importar a biblioteca stdio, que contém funções de entrada e saída, como a função printf. Sem essa linha o compilador não teria conhecimento da função printf e geraria um erro de compilação:

  int main() {
    printf("hello, world\n");
  }

É fundamental saber ler erros, aqui o compilador está dizendo que houve uma Declaração implícita da função 'printf', ou seja, a função foi chamada sem ter sido declarada, e a seguir mostra exatamente a linha onde aconteceu o problema. Mas não acaba aqui, ainda fornece uma dica de como resolver: basta incluir a biblioteca stdio.h que declara printf.

Funções são essenciais pra modularizar o código, por exemplo sem uma função como a printf, toda vez que algo precisasse ser impresso teríamos que replicar o código responsável pela impressão, e perceba que não precisamos nos preocupar em como essa função é implementada, apenas conhecendo a interface da função conseguimos implementar o hello world. Bacana, mas e como é que conhecemos o contrato da função? É pra isso que servem as documentações. Existem várias formas de obter a documentação das bibliotecas da linguagem, indiscutivelmente a forma mais rápida é pelo terminal. No Linux temos o comando man - que é abreviação para manual. O man fornece a documentação de comandos, chamadas de sistema, e até mesmo de funções da linguagem C, e muito mais. Basta digitar no terminal man <seção> <nome-do-recurso>. A seção 3 é destinada a funções de biblioteca incluindo as da linguagem C, então basta executar man 3 printf pra obter a documentação completa da função. De cara podemos ver como importar a função, o contrato, e uma explicação detalhada de como a função funciona.

Funções seriam de pouca utilidade se não fosse possível comunicar dados entre elas. No hello world, precisamos comunicar à função printf que desejamos imprimir hello, world, e o fizemos por meio de um parâmetro. Toda função em C pode definir uma lista de parâmetros, entre os parênteses após o nome da função, a função main não declara nenhum, mas a função printf sim.

O argumento "hello, world\n" é uma string de caracteres. O \n no final é utilizado para mover o cursor para a próxima linha, veja o resultado sem o \n. Isso significa que conseguimos executar múltiplas impressões antes de gerar a quebra de linha. Embora \n seja escrito com dois caracteres, internamente é representado com apenas 1, trata-se do Line Feed que discutimos no vídeo anterior. É apenas a forma de escrever caracteres invisíveis em C, outro exemplo é o \t para gerar TABs.

Um erro muito comum que iniciantes cometem é esquecer de recompilar o programa após alterações, não basta alterar o código, é necessário recompilar para gerar um novo arquivo executável.

Só falta explicar um detalhe do nosso hello world, o famigerado ;. Em C é obrigatório terminar declarações e instruções com ele, caso contrário o que você terá é um belo de um erro de compilação. Funções e algumas outras estruturas que veremos adiante não precisam do ;, isso é definido pela gramática da linguagem. Não vou entrar em detalhes agora, mas vai ficar claro conforme as estruturas forem apresentadas.

Variáveis, expressões, laços de iteração, comentários e aprendendo a fazer teste de mesa

Agora vamos falar sobre variáveis e expressões aritméticas, esse programa realiza a conversão de decimal pra binário dos números 0 a 15. Nesse programa temos comentários, variáveis, expressões aritméticas e loops:

  #include <stdio.h>

  int dec2bin(int numero) {
    int binario;
    int base;
    
    binario = 0;
    base = 1;
    while (numero > 0) {
        binario = binario + (numero % 2) * base;
        numero = numero / 2;
        base = base * 10;
    }
    return binario;
  }

  /* print decimal to binary table
     for decimal = 0, 1, ..., 15 */
  int main() {
    int minimo, maximo;
    int numero, binario;
    int base;
    
    minimo = 0;                                 // lower limit
    maximo = 15;                                        // upper limit
    
    numero = minimo;
    while (numero <= maximo) {
        binario = dec2bin(numero);
        printf("%d = %db\n", numero, binario);
        numero = numero + 1;
    }
  }
0 = 0b
1 = 1b
2 = 10b
3 = 11b
4 = 100b
5 = 101b
6 = 110b
7 = 111b
8 = 1000b
9 = 1001b
10 = 1010b
11 = 1011b
12 = 1100b
13 = 1101b
14 = 1110b
15 = 1111b

Acima da declaração da função main temos um comentário, eles são completamente ignorados pelo compilador, servem pra documentar o que o código faz, esse é um comentário multi-linha, mas logo abaixo temos comentários de linha, onde o compilador ignora tudo a partir do //.

A seguir temos uma série de variáveis, antes de qualquer coisa é preciso declará-las especificando o tipo e o nome, nesse programa todas as variáveis são do tipo int. As declarações são separadas em 3 linhas apenas por questões de organização. int representa um valor inteiro, usualmente de 32 bits, mas pode ser menos dependendo da arquitetura do computador. Entre os tipos de dados primitivos temos também short, long, float, double e char.

Após a declaração das variáveis temos as inicializações, embora algumas inicializações pudessem ser feitas junto com a declaração.

Cada linha impressa pelo programa é calculada exatamente da mesma forma, um número decimal é convertido em um número binário e então é impresso na tela. Nesses casos utilizamos loops, que permitem repetir um conjunto de instruções enquanto alguma condição for verdadeira. Neste caso, a condição é numero <= maximo. minimo e maximo representam o intervalo de números que desejamos converter, ou seja, essa condição está dizendo ao computador: repita até que o número seja menor ou igual ao maior número que desejamos realizar a conversão.

Variáveis podem ser inicializadas ou atualizadas com qualquer expressão que retorne o mesmo tipo de dado da variável, pode ser tão simples quanto uma constante ou uma chamada de função, até expressões aritméticas mais complexas. Os operadores aritméticos não necessitam de explicação, exceto pelo símbolo de porcentagem, em C e em muitas outras linguagens, esse é o operador de resto da divisão, então essa expressão pode ser lida da seguinte maneira: a variável binario recebe o seu próprio valor somado do resto da divisão por 2 da variável numero multiplicado pela variável base.

Pra entender esse programa, vamos fazer um teste de mesa, é uma técnica muito útil pra ajudar a entender o que um programa está fazendo. Começamos listando as variáveis do programa, e nos colocamos no lugar do computador, executando passo a passo e atualizando os valores das variáveis conforme o programa as altera. Arbitrariamente começamos com numero=11. A seguir inicializamos as variáveis binario e base, ao chegar no loop, temos que verificar se numero é maior que 0, e é, então entramos no loop. A primeira coisa a se fazer é calcular o novo valor de binario, 11/2 é 5 com resto 1, então temos que o novo valor de binario é 1 * 1 + 0, atualizamos seu valor na tabela, o mesmo para numero e base. Agora o programa volta pra condição do loop, numero ainda é maior que 0, então repetimos o processo, 5/2 é 2 com resto 1, binario recebe 1*10 + 1. No passo seguinte, 2/2 é 1 com resto 0, binario recebe 0*10 + 11, depois 1/2 é 0 com resto 1, binario recebe 1*1000 + 11. No próximo passo a condição do loop já não é mais verdadeira, aqui o código pula para a instrução return binario;, e basta olharmos o último valor de binario para obter o resultado de toda a computação realizada.

numero binario base
11 0 1
5 1 10
2 11 100
1 11 1000
0 1011 10000

Aqui estamos utilizando alguns recursos extras do printf, o f no nome dessa função indica format, justamente o nome do primeiro parâmetro, ou seja, não se trata de um texto fixo como hello world, e sim de uma string de formatação. A especificação dessa string permite codificar valores para serem substituídos pelos argumentos restantes da função com o símbolo de porcentagem. A seguir podemos informar o tipo do valor a ser inserido, neste caso d para valores decimais. Assim conseguimos imprimir o valor das variáveis numero e binario formatados pra indicar a conversão do número em decimal para binário.

while não é o único laço de iteração disponível, podemos reescrever o programa para utilizar o for. Nesse caso, a estrutura do laço já fornece os locais adequados pra todas as etapas que podem ser necessárias em um laço: inicialização de variáveis, condição de parada, atualização e o conjunto de instruções:

  for (init-expr; test-expr; update-expr) {
    body-statements
  }

A nossa função de conversão pode ser reescrita de forma que o corpo do laço contenha apenas uma linha, e perceba que as chaves foram removidas, isso é possível justamente pelo fato do laço ter apenas uma linha, qualquer linha extra será executada apenas após o término do for:

  #include <stdio.h>

  int dec2bin(int numero) {
    int binario, base;
    
    for (binario = 0, base = 1; numero > 0; numero = numero / 2, base = base * 10)
        binario = binario + (numero % 2) * base;
    return binario;
  }

  int main() {
    printf("%d\n", dec2bin(7));
  }
111

Apenas uma linha não é muito preciso, o correto mesmo é apenas uma instrução, pois poderíamos colocar uma instrução extra na mesma linha e ela seria executada apenas após o for:

  #include <stdio.h>

  int dec2bin(int numero) {
    int binario, base;
    
    for (binario = 0, base = 1; numero > 0; numero = numero / 2, base = base * 10)
        binario = binario + (numero % 2) * base; printf("binario: %d\n", binario);
    return binario;
  }

  int main() {
    printf("%d\n", dec2bin(7));
  }
binario: 111
111

Entrada e Saída

Precisamos aprender o mínimo sobre entrada e saída pra conseguir ler e escrever dados. A biblioteca padrão do C, conhecida como libc, modela dados de entrada e saída como streams de caracteres divididos em linhas. Várias funções pra lidar com IO são fornecidas, mas com apenas duas delas já conseguimos resolver muitos problemas: getchar e putchar. getchar lê o próximo caractere da entrada, putchar(c) imprime o caractere c passado como parâmetro. Com essas duas funções já é possível escrever um programa para copiar a entrada para a saída:

  #include <stdio.h>

  main() {
    int c;

    c = getchar();
    while (c != EOF) {
        putchar(c);
        c = getchar();
    }
  }

Esse programa lê os dados de entrada até que a função getchar retorne EOF, que é um valor inteiro para representar o final do arquivo. Mas peraí, getchar retorna um inteiro? Não deveria retornar um char? Acontece que a função deve ser capaz de retornar qualquer caractere representável mais algum valor para indicar que os dados de entrada foram lidos completamente. Pra resolver esse problema o retorno de getchar é int, e com isso conseguimos comparar o retorno da função com EOF para saber quando encerrar a leitura.

O programa acima faz o trabalho, mas é bom irmos nos acostumando com o jeito de fazer as coisas em C para que você não tenha dificuldade em ler códigos em livros ou em projetos. Atribuições em C retornam um valor, então a expressão c = getchar() pode ser testada diretamente:

  #include <stdio.h>

  main() {
    int c;

    while ((c = getchar()) != EOF)
        putchar(c);
  }

Mas pra que raios colocamos a atribuição entre parênteses? Por causa da precedência de operadores, isso não é algo exclusivo do C, todo compilador de linguagem precisa definir uma gramática e nela embutir a precedência de operadores para que o compilador saiba como resolver expressões. Os parênteses dão flexibilidade ao programador permitindo modificar a precedência da linguagem quando esta não é exatamente o que se quer. O operador lógico de diferença (!=) tem uma precedência maior que o de atribuição (=), sem colocar parênteses o compilador avalia primeiro getchar() != EOF, e por fim atribui o valor dessa expressão na variável c. Como os parênteses têm o maior nível de precedência entre todos os operadores, podemos utilizá-los para indicar que queremos primeiro armazenar o resultado de getchar na variável c e só então comparar o retorno dessa expressão com EOF.

Outro programa que conseguimos implementar com apenas essas duas funções é um para contar o número de linhas na entrada de dados:

  #include <stdio.h>

  main() {
    int c;
    long total = 0;

    while ((c = getchar()) != EOF)
        if (c == '\n')
          ++total;
    printf("%ld\n", total);
  }

A lógica aqui é muito simples, realizamos a leitura dos dados da entrada, caractere a caractere, toda vez que uma nova linha é detectada, incrementamos a variável total. A comparação de quebra de linha usa aspas simples porque como já vimos \n trata-se de um único caractere. Perceba que assim como anteriormente no for, aqui não precisamos de nenhuma chave no while e no if, pois temos apenas uma instrução em cada caso, o if logo após o while, e o incremento das linhas logo após o if.

Prevendo arquivos muito grandes defini a variável total como long. ints podem representar até 2^31 - 1, enquanto que longs podem representar até 2^63 - 1. %ld no printf indica que o tipo de argumento a ser impresso é do tipo long decimal.

Agora vamos escrever um programa para contar o número de ocorrências de cada letra do alfabeto em um texto, ignorando acentuação. Precisamos armazenar um valor inteiro para cada letra possível do alfabeto. Poderíamos criar 26 variáveis, mas certamente não é uma boa ideia. Ao invés disso vamos fazer nossa primeira introdução ao conceito de arrays. Pense em arrays como listas de valores. Pra resolver esse problema, criamos um array com capacidade para armazenar 26 valores. Na primeira posição armazenamos a quantidade de ocorrências do caractere a, na segunda, a quantidade de ocorrências do b, e assim por diante. Assim como variáveis de tipos simples, precisamos inicializar arrays, para inicializar todos os valores, podemos simplesmente iterar o array da primeira posição até a última.

No C, como na maioria das linguagens de programação, arrays iniciam da posição 0, e o motivo disso como veremos adiante tem relação com a forma com que os arrays são armazenados na memória do computador. Inicializamos com 0, pois até este ponto do programa não lemos nenhum caractere do texto. Essa é a próxima etapa, realizamos a leitura caractere por caractere até que o final do arquivo seja encontrado. Pra cada caractere precisamos resolver dois problemas - ignorar a acentuação e filtrar apenas letras (não estamos preocupados com números ou símbolos especiais). Pra ignorar a acentuação temos que recorrer à tabela ASCII, aliás, se você não sabe do que eu estou falando, dá uma olhada no último vídeo do canal - Por que Computadores só entendem 0s e 1s?.

Se compararmos qualquer letra maiúscula com a sua respectiva minúscula vamos perceber que sempre temos uma diferença de 20 em hexadecimal. Então basta somarmos esta quantidade ao caractere quando for uma letra maiúscula. Para filtrar apenas as letras podemos fazer uma comparação simples entre o intervalo das minúsculas, porque nesse ponto do programa caso o caractere tenha sido uma letra maiúscula já foi convertido. Ao término do while temos nosso array completamente preenchido com todas as quantidades, agora precisamos imprimir esses dados. Listar apenas os valores vai tornar muito difícil saber, por exemplo, quantas vezes a letra k apareceu. Então vamos imprimir duas linhas: na primeira as letras, e na segunda as respectivas quantidades. Pra imprimir as letras, iteramos de 0 a 26, imprimindo 'a' + i.

Já vimos no caso do EOF que misturar char com int não é algo incomum em C. Isso se dá porque um char é de fato representado internamente como um número inteiro, um inteiro menor que um int, mas ainda assim um inteiro. Se olhar na tabela ASCII, o valor inteiro para o caractere 'a' é 97, ou seja, 'a' + 2 é a mesma coisa que 97 + 2. De fato, poderíamos ter escrito o laço com i indo de 97 até 122, e imprimindo diretamente o valor de i. Mas isso tornaria o código mais obscuro, 'a' + i transmite de forma clara que estamos imprimindo o caractere 'a' deslocado i vezes. Mas isso tudo não adiantaria em nada sem especificar o formato correto, no fim das contas 'a' + i é avaliado como um int, pra garantir a impressão das letras ao invés da representação numérica, passamos %c como formato para a função printf. O espaço serve para não imprimir todos os caracteres grudados.

Depois do laço inserimos uma quebra de linha pra iniciar a impressão dos valores de cada letra. Imprimimos o valor acessando a posição i do array. Por fim, como queremos imprimir apenas um caractere podemos utilizar a função putchar no lugar de printf. Isso é importante pra demonstrar que podemos utilizar várias funções da biblioteca de IO conforme a necessidade, internamente ambas estão escrevendo dados no dispositivo de saída:

  #include <stdio.h>

  int main() {
    int c;
    int count[26];
    for (int i=0; i<26; i++)
        count[i] = 0;

    while ((c = getchar()) != EOF) {
        if (c >= 'A' && c <= 'Z')
          c += 0x20; // convert to lower-case
        if (c >= 'a' && c<= 'z')
          count[c-'a']++;
    }

    for (int i=0; i<26; i++)
        printf("%c ", 'a'+i);
    printf("\n");
    
    for (int i=0; i<26; i++)
        printf("%d ", count[i]);
    putchar('\n');
  }

O programa está pronto, basta executar, inserir alguns caracteres e avaliar o resultado. Parece correto, mas é um teste ridículo, vamos fazer um mais realístico. Gerei um arquivo com um trecho razoável de algum livro aleatório que tinha em PDF aqui. Agora surge a questão: como enviar esse conteúdo para o programa. A abordagem mais direta é copiar e colar o conteúdo. Mas seria muito melhor poder informar o nome do arquivo para que o programa lesse por conta própria. E o mais legal é que não precisamos alterar uma linha sequer do programa, o sistema operacional resolve tudo aqui. No Linux a entrada de dados padrão - conhecida como stdin - é o teclado, mas podemos alterar, basta adicionar ao comando de execução do programa o símbolo < seguido do nome do arquivo. Isso irá redirecionar o stdin para o arquivo.

E como acontece quase sempre: teste com dados reais e encontre bugs. Como o arquivo contém uma quantidade razoável de texto, as quantidades das letras mais comuns são grandes e acabam bagunçando toda a visualização. A maior quantidade é 1719 para a letra a, então na impressão das letras, precisamos imprimir 4 espaços antes de cada uma. Poderíamos simplesmente informar os espaços antes do %c, mas o printf aceita um número antes do identificador do tipo, em inglês é chamado de left padding, ou seja, preenchimento à esquerda. A impressão garantirá um comprimento de 4 caracteres, se o caractere for menor, a função preenche com espaços em branco. Isso é especialmente útil para o segundo for. Não conseguiríamos resolver com espaços em branco fixos, quando o número é 10, precisamos de 2, mas quando é 1719 não precisamos de nenhum, o left padding garante isso, o preenchimento é feito apenas quando a impressão não atingir a quantidade de caracteres especificada:

  #include <stdio.h>

  int main() {
    int c;
    int count[26];
    for (int i=0; i<26; i++)
        count[i] = 0;

    while ((c = getchar()) != EOF) {
        if (c >= 'A' && c <= 'Z')
          c += 0x20; // convert to lower-case
        if (c >= 'a' && c<= 'z')
          count[c-'a']++;
    }

    for (int i=0; i<26; i++)
        printf("%4c ", 'a'+i);
    printf("\n");
    
    for (int i=0; i<26; i++)
        printf("%4d ", count[i]);
    putchar('\n');
  }

Outro conceito que podemos introduzir a partir desse programa é o de constantes simbólicas, em programação chamamos de números mágicos aqueles valores espalhados pelo programa sem um nome específico e que não sejam auto-explicativos, aqui temos um caso claro disso na conversão de letras maiúsculas em minúsculas, somamos 0x20 e adicionamos um comentário explicando o motivo. Ao invés disso podemos remover o comentário e introduzir uma constante, agora lendo o código fica evidente o que está sendo feito:

  #include <stdio.h>
  #define ASCII_CASE_OFFSET 0x20

  int main() {
    int c;
    int count[26];
    for (int i=0; i<26; i++)
        count[i] = 0;

    while ((c = getchar()) != EOF) {
        if (c >= 'A' && c <= 'Z')
          c += ASCII_CASE_OFFSET;
        if (c >= 'a' && c<= 'z')
          count[c-'a']++;
    }

    for (int i=0; i<26; i++)
        printf("%4c ", 'a'+i);
    printf("\n");
    
    for (int i=0; i<26; i++)
        printf("%4d ", count[i]);
    putchar('\n');
  }

Funções

Já usamos várias funções, printf, getchar, putchar, e até mesmo criamos novas como no programa de conversão de decimal pra binário, mas falta entender como uma função é definida, o que é e o que não é permitido. Em C, a definição de função especifica o tipo do retorno, o nome, uma lista opcional de parâmetros, abertura e fechamento de chaves pra delimitar o corpo da função, e entre as chaves um conjunto de instruções:

  return-type function-name(parameter-declarations*) {
    declarations
    statements
  }

No exemplo anterior colocamos a função de conversão antes do main, caso contrário teríamos um erro de compilação, isso significa que temos de criar as funções antes de poder utilizá-las, mas em programas maiores isso é bem limitante. Pra resolver esse problema podemos separar a declaração da implementação. Considere uma função maximo, que recebe dois valores e retorna o maior. Podemos começar o programa apenas declarando o protótipo da função:

  int maximo(int x, int y);

É totalmente opcional informar os nomes dos parâmetros, a declaração pode conter apenas os tipos, embora seja prática comum já especificar os nomes:

  int maximo(int, int);

Agora podemos escrever a função main e já utilizar maximo mesmo sem ter fornecido a implementação:

  int main() {
    int a = 25, b = 20;
    printf("maximo(%d, %d) = %d\n", a, b, maximo(a, b));
  }

Pra compilar sem erros, obviamente precisamos fornecer a implementação da função, mas agora isso pode ser feito em qualquer parte do programa, pois quando o compilador encontrar a chamada da função maximo na função main, já vai conhecer a sua declaração:

  #include <stdio.h>

  int maximo(int x, int y);

  int main() {
    int a = 25, b = 20;
    printf("maximo(%d, %d) = %d\n", a, b, maximo(a, b));
  }
  
  int maximo(int x, int y) {
    return x >= y ? x : y;
  }

De fato, podemos colocar as declarações em arquivos separados e apenas importar com a diretiva #include.

Qualquer tipo de retorno diferente de void requer uma declaração de retorno na função, com uma única exceção. Até agora definimos a função main retornando int, mas em nenhum momento adicionamos a instrução para retornar algum valor. O compilador automaticamente adiciona a instrução return 0 se a instrução foi omitida, mas lembre-se, apenas para a função main. O retorno dessa função não é para ser utilizado por outras funções como nos demais casos, o retorno aqui é para ser enviado ao sistema operacional. Pra indicar que o programa executou sem erros retornamos 0, e qualquer valor diferente de 0 indica algum tipo de erro. Isso pode ser visualizado no próprio terminal, após executar o programa podemos verificar o código de retorno rodando echo $?, echo imprime um valor, $ indica ao shell que queremos referenciar uma variável, e ? é a variável que armazena o código de retorno do programa. E de fato, o shell pode usar essa variável pra indicar visualmente se o comando gerou erro, no meu terminal quando o programa executou sem erros o prompt de comando fica verde, caso contrário fica vermelho:

  int main() {
    return 0;
  }

Passagem de parâmetros

Até aqui tenho usado os termos parâmetro e argumento pra me referir aos dados passados para funções, o motivo disso é poder diferenciar quando estamos falando da declaração da função e da chamada da função com valores específicos. Parâmetro é usado pra se referir ao que está na declaração da função, por exemplo, a função maximo especifica dois parâmetros, x e y, ambos do tipo int. Enquanto que argumento é usado pra se referir a uma chamada específica da função, exemplo, a chamada maximo(70, 20) passa os valores 70 e 20 como argumentos da função maximo.

Em C, todos argumentos de funções são passados por valor, e não por referência. Isso significa que modificar o valor de um parâmetro não irá refletir fora da função. Por exemplo, essa função soma altera o parâmetro x ao invés de criar uma nova variável para a soma, mas como os argumentos são passados como cópia, o que está sendo alterado é uma cópia da variável x que apenas a função soma tem acesso, o valor da variável na função main permanece inalterado:

  #include <stdio.h>

  int soma(int x, int y);

  int main() {
    int x = 10, y = 7;

    int result = soma(x, y);
    printf("result = %d; x = %d; y = %d\n", result, x, y);
    return 0;
  }

  int soma(int x, int y) {
    x += y;
    return x;
  }

A coisa muda de figura com arrays, o que é passado é o endereço em memória para o início do array, um pointer. Dessa forma qualquer alteração feita pela função irá refletir nos dados da função original, pois estaremos modificando os dados referenciados diretamente na memória, e não mais uma cópia. Vamos entender isso com um tipo de array muito utilizado em C, o array de caracteres. Em C não temos um tipo de dado String como temos em muitas outras linguagens, pra representar texto utilizamos arrays de caracteres, por exemplo, podemos inicializar um array com o texto "Hello". Internamente é inicializado com 6 caracteres, não apenas 5 como esperado pra armazenar a palavra Hello, o \0 ao final é chamado de caractere nulo, serve para indicar o término da String, dessa forma, funções como a printf sabem até onde imprimir. Pra verificar isso podemos inicializar outra String, mas desta vez manualmente, posição por posição sem informar o caractere nulo ao final, com esse array a função printf segue imprimindo caracteres da memória até encontrar o caractere nulo, isso só acontece após a impressão da String Hello que foi corretamente inicializada e armazenada na memória antes da String World:

  #include <stdio.h>

  int main() {
    char t1[] = "Hello";
    printf("%s\n", t1);
    
    char t2[5];
    t2[0] = 'W';
    t2[1] = 'o';
    t2[2] = 'r';
    t2[3] = 'l';
    t2[4] = 'd';
    printf("%s\n", t2);

    t2[5] = '\0';
    printf("%s\n", t2);

    return 0;
  }
Hello
WorldHello
World

Isso pode parecer confuso à primeira vista já que estamos passando como argumento apenas o array t2 para a função printf, e o resultado é a impressão de t2 seguido por t1 antes da quebra de linha. Isso acontece porque arrays em C são nada mais que apenas uma região contígua de memória, como vimos, a passagem de um array por parâmetro significa passar o endereço de memória do início do array, dessa forma as funções precisam de alguma forma saber até onde é válido ler dados da memória referente àquele array, poderíamos passar um argumento informando o tamanho, mas no caso de arrays de caracteres podemos embutir essa informação na própria estrutura com o caractere nulo. Pra comprovar isso podemos passar t2 pra uma função qualquer e alterar seus valores, perceba que diferentemente de tipos de dados simples, a alteração refletiu fora da função:

  #include <stdio.h>

  void change(char arr[]);

  int main() {
    char t1[] = "Hello";
    printf("%s\n", t1);
    
    char t2[5];
    t2[0] = 'W';
    t2[1] = 'o';
    t2[2] = 'r';
    t2[3] = 'l';
    t2[4] = 'd';
    printf("%s\n", t2);

    t2[5] = '\0';
    printf("%s\n", t2);

    change(t2);
    printf("%s\n", t2);
    
    return 0;
  }

  void change(char arr[]) {
    arr[0] = 'M';
  }

Agora já conseguimos criar funções para trabalhar com Strings, por exemplo, considere a função equals que recebe duas Strings e retorna 1 quando forem iguais, e 0 quando forem diferentes. Pra isso basta iterarmos ambos os arrays, comparando caractere por caractere, a condição de parada é o caractere nulo. Se a função ainda não retornou ao término do laço, significa que até este ponto as duas Strings são idênticas, mas ainda precisamos checar se as duas Strings foram lidas até o fim, isso pra levar em conta casos como por exemplo "mar" e "marinheiro":

  #include <stdio.h>

  int equals(char a[], char b[]);

  int main() {
    printf("%d\n", equals("hello", "world"));
    printf("%d\n", equals("hello", "hello"));
    return 0;
  }

  int equals(char a[], char b[]) {
    int i;
    for (i=0; a[i] != '\0' && b[i] != '\0'; i++)
        if (a[i] != b[i])
          return 0;
    return a[i] == '\0' && b[i] == '\0';
  }

Escopos

Antes de concluir precisamos falar sobre escopos de variáveis. Variáveis vivem apenas no escopo em que foram definidas. Por exemplo, uma variável declarada no início da função é dita como uma variável local, pode ser referenciada em qualquer ponto daquela função, mas uma vez que a função termina, a variável não pode mais ser referenciada. Isso também significa que variáveis de mesmo nome em funções diferentes não possuem qualquer relação. Variáveis podem ser declaradas em escopos menores, por exemplo dentro de um for, nesse caso a variável só pode ser referenciada naquele for ou em qualquer estrutura aninhada dentro dele. Quando é necessário referenciar a variável após o término do for, a declaração tem que ser feita antes. Mas podemos também declarar variáveis globais que podem ser acessadas em qualquer parte do programa (acho que eu não devia estar ensinando isso).

Se o programa consiste de apenas um arquivo, podemos declarar a variável e acessar diretamente, isso pode ser encarado como outro mecanismo de passagem de dados entre funções. Mas quando se quer acessar variáveis globais declaradas em outros arquivos precisamos declarar a variável com a palavra-chave extern. Por exemplo, suponha que a variável int x tenha sido declarada no arquivo a.c, para acessar essa variável em alguma função do arquivo b.c, basta adicionar a declaração extern int x na função desejada.

Conclusão

Pra esse vídeo eu segui a abordagem de Brian Kernighan e Dennis Ritchie no livro The C Programming Language, em que fazem uma exposição da linguagem no primeiro capítulo e se aprofundam nos conceitos no restante do livro. Eu gostei bastante desta abordagem porque permite explicar cada conceito sem se preocupar em explicar um detalhezinho de sintaxe que ainda não tenha sido introduzido. Essa foi a minha introdução à linguagem C, nos próximos vídeos vou explicar em detalhes cada conceito da linguagem: tipos, operadores, expressões, estruturas de controle, funções, ponteiros, arrays e structs. Se gostou do vídeo, deixa seu like e seu hype, se inscreve no canal pra não perder os próximos vídeos, ativa o sino das notificações, e se tiver sugestões de assuntos, deixa aí nos comentários. Valeeu!

Obrigado pela leitura.Ver mais artigos