Todo programa em C começa com uma estrutura parecida com essa:
#include <stdio.h>
#include <stdlib.h>
int main() {
}
Os #include são diretivas que incluem arquivos de cabeçalho (bibliotecas) antes da compilação do programa, cada biblioteca é usada para uma função específica, nos casos mais comuns, o stdio.h é um padrão para entrada e saída de dados (como para escrever algo na tela ou pegar algo digitado pelo usuário), e o stdlib.h envolve a alocação de memória e controle de processos.
O main é a principal função do programa, geralmente declarado com o tipo de retorno int. Num dos próximos exemplos, usaremos void (vazio), que não retorna nada.
Mas ao usar o int no método, precisaremos usar o return 0 para indicar o fim do programa. Com int podemos controlar melhor o retorno por causa desse parâmetro, útil pra uso com outras aplicações.
Para compilar programas e ele pausar antes de fechar, você pode colocar system("pause") (em Windows) ou getchar(), no final do programa, antes do retorno (lembrando que comandos system necessitam da biblioteca stdlib.h).
Nesse exemplo, vamos criar um Olá Mundo, um com int e outro com void. Para isso usamos o printf, dessa forma:
#include <stdio.h> // Entrada e saída, necessário para printf() e getchar()
#include <stdlib.h> // Controle de memória e processos
int main() {
printf("Olá Mundo!"); // Elemento do stdio.h
getchar(); // Usada para o programa não fechar após a execução.
return 0; // Retorna 0, pois int retorna um valor inteiro.
}
Exemplo com void:
#include <stdio.h>
#include <stdlib.h>
void main() {
printf("Olá Mundo!");
}
Os comentários de uma linha se colocam ao lado de //, e de várias linhas entre /* */, por exemplo:
// Comentário de uma linha
/*
Comentário
de
várias
linhas
*/
No próximo exemplo, vamos declarar e usar algumas variáveis para fazermos uma soma:
int main(void) {
int num1, num2, soma;
printf("Digite o primeiro número: ");
scanf("%d", &num1);
printf("Digite o segundo número: ");
scanf("%d", &num2);
soma = num1 + num2;
printf("Soma: %d", soma);
return 0;
}
No exemplo acima, o scanf é usado para capturar entradas de teclados, com máscaras de formatação (%) e com & ao lado da variável que será capturada.
Também pode ser usado puts no lugar do printf, mas ele não permitirá usar máscaras de formatação, por isso caiu em desuso.
PS: Caso você tenha configurado corretamente o path do Mingw no seu Windows, você pode criar diretamente arquivos com extensão c e compilar ele usando os comandos gcc main.c -o nomedoprograma (no Linux é o mesmo processo, apenas omitindo a extensão ou usando alguma extensão genérica, pode ser necessário usar o parâmetro -no-pie para gerar um executável, sendo que o padrão de algumas distribuições são -pie que gera a biblioteca compartilhada). Caso tenha mais de um arquivo do mesmo projeto, execute o comando gcc -c nomedoarquivo.c nos outros arquivos pra compilá-los e depois gcc main.c nomedoarquivo.o -o nomedoprograma no main pra montar. Pode ser necessário colocar o parâmetro -lm para forçar inclusão de bibliotecas, como as de operações matemáticas. Caso esteja num sistema 64 bits e queira compilar para 32 bits, use o parâmetro -m32 (o default é -m64). Pode ser necessário instalar as dependências (instale o gcc-multilib).
Para resolver problemas com acentuações em programas utilizamos o setlocale, dessa forma:
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
int main() {
setlocale(LC_ALL, "portuguese"); // Inclua locale.h
printf("Essa é uma frase com acentuação!\n");
return 0;
}
Dessa forma, resolvemos o problema com caracteres em idiomas latinos. Em algumas IDEs não exigem o locale incluído para isso.
Os dados são as informações a serem processadas por um computador. Podem ser classificados em várias categorias, dependendo de suas características. Veja abaixo:
Tipos Básicos consistem em tipos aritméticos inteiros e de ponto-flutuante. Veja abaixo os tipos primitivos:
| Tipo | Tamanho | Faixa de Valores |
|---|---|---|
| char | 1 byte | -128 a 127 |
| unsigned char | 1 byte | 0 a 255 |
| signed char | 1 byte | -128 a 127 |
| int | 4 bytes | -2147483648 a 2147483647 |
| unsigned int | 4 bytes | 0 a 4294967295 |
| short | 2 bytes | -32,768 a 32,767 |
| unsigned short | 2 bytes | 0 a 65,535 |
| long | 4 bytes | -2147483648 a 2147483647 |
| long long | 8 bytes | -9223372036854775808 a 9223372036854775807 |
| unsigned long | 4 bytes | 0 a 4294967295 |
| float | 4 bytes | 3.4E-38 a 3.4E+38 (até 6 casas decimais) |
| double | 8 bytes | 1.7E-308 a 1.7E+308 (até 15 casas decimais) |
| long double | 16 bytes | 3.4E-4932 a 1.1E+4932 (até 19 casas decimais) |
| bool | 1 byte | true/false |
| char[] | 1 byte por caractere | Textos em Geral |
PS: Letras únicas em char se coloca entre aspas simples, cadeias de caracteres se coloca entre aspas duplas.
Para descobrirmos o tamanho de um tipo de variável no C, usamos o operador sizeof. Veja um exemplo:
int main(void) {
printf("Tamanho de Armazenamento do Int: %d bytes.\n", sizeof(int));
printf("Tamanho de Armazenamento do Short: %d bytes.\n", sizeof(short));
printf("Tamanho de Armazenamento do Long: %d bytes.\n", sizeof(long));
return 0;
}
Não há um tipo lógico definido na linguagem C original, portém a partir do padrão ISO C99 é possível usar o tipo (mais precisamente, macro) bool.
No geral, em C, o valor inteiro 1 é considerado como true e o inteiro 0 como false. Qualquer outro número é considerado verdadeiro (true).
Para usarmos o tipo lógico bool, precisamos incluir a biblioteca stdbool.h no código do programa.
PS: Caso esteja usando uma versão mais antiga do C que não suporte tipos booleanos, podemos "criar" um tipo lógico com o seguinte código:
typedef enum {false = 0, true = 1} logico;
Já os tipos literais são tratados em C como valores numéricos, e não como literais. Cada caractere possui um correspondente numérico, obedecendo geralmente a tabela ASCII de caracteres.
Em C temos o tipo char para representar um caractere literal. Seu tamanho é de 1 byte, possuindo então valores entre 0 e 255.
Caso precisemos armazenar uma cadeia de caracteres (string), usamos arrays do tipo char. Um caractere nulo, representado por \0, sempre indicará o final da cadeia (e ele conta no tamanho da cadeia). Podemos também usar char* (vetor de char com ponteiro) para strings.
Para converter tipos em C, podemos fazer assim:
float real = 4.8;
int num = (int)real;
PS: Isso de colocar o tipo entre parênteses, é chamado de typecast, pode ser feito com qualquer tipo pra forçar uma conversão, mas só funciona quando é de tipos semelhantes (como forçar conversão de float para int, por exemplo).
No caso de strings, podemos usar a função atoi pra isso (importe stdlib.h):
char* frase = "90";
int novo = atoi(frase);
Também podemos usar o strtol para converter string em int (em qualquer base numérica), dessa forma, sem necessitar de importação:
char* frase = "90";
int novo = strtol(frase, NULL, 10); // O primeiro é a variável a ser convertida, o último número é a base numérica (no caso, a decimal)
Para converter int em string, usamos o sprintf assim:
int numero = 50;
char texto[10];
sprintf(texto, "%i", numero); // Sempre na ordem: Variável string a receber o valor, tipo de número convertido e o número.
printf("%s\n", texto);
PS: O sprintf também pode ser usado para concatenar variáveis de diferentes tipos numa variável só, por exemplo:
int hora = 10;
int minuto = 25;
char relogio[100];
sprintf(relogio, "A hora passada foi %.2d:%.2d.", hora, minuto);
printf("%s\n", relogio);
Uma variável é uma localização na memória do computador que é utilizada para armazenar temporariamente os dados que são utilizados durante o programa.
As variáveis possuem algumas características, como identificação, endereço, tipo, tamanho e valor (conteúdo). Elas só podem ter letras, números e underlines, deve iniciar com letra e não deve ser nenhuma palavra reservada.
Para que uma variável possa ser usada em um programa, ela deve primeiro ser declarada, para que seja reservado espaço na memória para armazenamento dos seus dados. Elas devem ser declaradas no início do programa, mas dependendo do caso pode ser declarada em outras partes do código.
Veja abaixo umas declarações de variáveis:
int a, b, c;
char letra;
float valor, aumento;
double patrimonio;
int x = 0;
typedef enum {false = 0, true = 1} bool;
bool ferias = false;
float salario, juros = 0.08;
PS: O char só permite um caracter, e deve se usar aspas simples, mas array ou ponteiro de char para strings, devem usar aspas duplas.
Além da atribuição comum, você pode ter atribuições múltiplas, como essa:
y = x = 10;
PS: Esse tipo de atribuição também funciona em qualquer linguagem descendente do C, como o Java, o PHP e mesmo o Python.
Veja alguns exemplos de atribuições de variáveis:
int main(void) {
int idade;
float salario, valor;
idade = 25;
valor = 4500.50;
salario = valor;
printf("Idade: %d\n", idade);
printf("E o salário: %f\n", salario);
return 0;
}
A função printf mostra dados formatados na tela do computador. Esses dados podem ou não estarem armazenados em variáveis. Veja um exemplo de sintaxe:
printf("Exemplo com máscara %d", variavel_ou_dado);
O que está entre aspas descreve o formato da saída, e os argumentos com as variáveis ou dados (opcionais) correspondem a cada sequência na mesma (com uso de máscaras na primeira parte, que referencia a variável).
A função printf pode, entre outras coisas:
Veja algumas máscaras de formatação, no C chamadas de especificadores de conversão:
| Máscara | Tipo de Dado | Descrição |
|---|---|---|
| %d | int | Número Inteiro Decimal com Sinal |
| %c | char | Caractere Único |
| %f | float ou double | Número Decimal (Real ou de Ponto Flutuante) |
| %i | int | Número Inteiro Decimal (Diferentes na Entrada e Saída de Dados) |
| %ld | long int | Número Inteiro Longo |
| %e | float ou double | Número Real Exponencial (Científico). Letras minúsculas. |
| %E | float ou double | Número Real Exponencial (Científico). Letras maiúsculas. |
| %o | int | Número Inteiro em Formato Octal sem Sinal |
| %x | int | Número Inteiro em Formato Hexadecimal sem Sinal. Caracteres de a a f |
| %X | int | Número Inteiro em Formato Hexadecimal sem Sinal. Caracteres de A a F |
| %u | int | Número Inteiro Decimal sem Sinal |
| %h ou %l | --- | Colocado Antes de um Especificador Inteiro para Indicar Valor Short ou Long |
| %L | --- | Colocado Antes de um Especificador de Ponto Flutuante para indicar valor Long Double |
| %s | char | Cadeia de Caracteres (String ou Ponto pra char) |
| %p | pointer | Ponteiros |
PS: A maioria delas também funcionam em algumas linguagens baseadas em C, como C++, PHP e Java, ao usar print formatado. E valores booleanos utilizam a máscara de inteiro, já que ele é reconhecido como 1 pra true e 0 pra false (apesar de no Java a máscara %b funciona pra booleanos, mas não funciona em outras linguagens). Caso precise exibir um símbolo de porcentagem, use %% para exibir um símbolo desse.
Veja uma aplicação prática de algumas delas:
int main(void) {
printf("d: %d\n", 603);
printf("d: %d\n", -603);
printf("i: %i\n", 603);
printf("o: %o\n", 603);
printf("u: %u\n", -603);
printf("u: %u\n", 603);
printf("x: %x\n", 603);
printf("X: %X\n", 603);
printf("f: %f\n", 6032101.75);
printf("e: %e\n", 6032101.75);
printf("e: %e\n", -6032101.75);
printf("E: %E\n", 6032101.75);
printf("s: %s\n", "String de Exercício");
printf("c: %c\n", 'T');
return 0;
}
PS: Os caracteres (char) únicos são representadas por aspas simples, as máscaras permanecem usando duplas. Os textos em array usam aspas duplas. No padrão da linguagem C, o último caractere de um vetor de char é o \0, que é adicionado automaticamente pelo compilador.
Veja outro exemplo de formatação, mais simples, no qual usamos mais de uma máscara de formatação no mesmo printf:
int main(void) {
int a, b;
a = 12;
b = 30;
printf("O valor de a é %d e o de b vale %d", a, b);
return 0;
}