- Estudos em C
- Syntax
- Bibliotecas
- Funções
// Comentários na linha utilizam "//"
/*
* Comentários em várias linhas
* utilizam no início "/*"
* e no fim o inverso
*/#include <arquivo>
#include "arquivo"
/**
* O pré-processador substitui a linha pelo conteúdo do arquivo
*
* <arquivo> é procurado em diretórios padrão
* "arquivo" é procurado no próprio diretório (Ou no diretório indicado)
*/#define identificador token
// O pré-processador substitui as ocorrências do identificador por tokens
#undef identificador
// A definição é desativada a partir desse ponto#define quad(x) ((x)*(x))
quad(2) // ((2)*(2))
quad(2+2) // ((2+2)*(2+2))
quad(quad(2)) // ((((2)*(2)))*(((2)*(2))))#define min(x,y) (((x<y)) ? (x) : (y))
#define min(a,b,c,d) min(min(a,b), min(c,d))int main()
{
return 0;
}if(condição)
{
// Sentenças
}
else if(condição 2)
{
// Sentenças
}
else
{
// Sentenças
}condição ? verdadeiro : falsowhile(condição)
{
// Sentenças
}do
{
// Sentenças
} while (condição);
// No "do" o teste é feito depois, então executará ao menos 1xfor(inicio; condição; incremento)
{
// Sentenças
}
/* Omitindo argumentos:
* for(;;)
*
* Caso uma variável seja definida dentro do for
* seu escopo será apenas o for
*/
// Equivalencia do for em while
inicio;
while (condição)
{
// Sentenças
incremento;
}switch(expressão_integral)
{
case constante_integral:
// Sentenças
case constante_integral:
// Sentenças
default:
// Sentenças
}Não recomendado por quebrar fluxo de comandos e piorar legibilidade
break; // Termina uma repetição ou switch
continue; // Interrompe apenas uma iteração, voltando pro teste
// Pode ser usado em for, while e do
goto identificador;
// Salta para uma sentença rotulada, por exemplo
identificador : sentença;+ -> Adição
- -> Subtração
* -> Multiplicação
/ -> Divisão
% -> Resto da divisão ("mod")
> -> Maior
< -> Menor
>= -> Maior ou igual
<= -> Menor ou igual
== -> Igual
!= -> Diferente
...
var op= expressão equivale a var = var op expressão
Ex: i /= 2 equivale a i = i/2
&& -> e
|| -> ou
! -> não
Obs: && e || param de executar se o resultado puder ser decidido
++ -> Incremento
-- -> Decremento
Obs: n++ != ++n
n++ incrementa depois de executar, enquanto ++n incrementa antes de executar
Exemplo:
n = 5;
x = n++;
// x = 5 e n = 6
n = 5;
x = ++n;
// x = 6 e n = 6Se aplicam a tipos integrais Aplicam a operação bit a bit
& -> and
| -> or
^ -> xor
~ -> not
<< -> Deslocamento à esquerda
>> -> Deslocamento à direita
Exemplo:
1011 0101
& 1111 0110
---------
1011 0100
1011 0101
| 1111 0110
---------
1111 0111
1011 0101
<< 1
---------
0110 1010
OBS: Deslocar p/ a esquerda é equivalente a multiplicar por 2
1011 0101
>> 1
---------
0101 1010
qualificador* modificador* tipo nome1, nome2, ...;
Variáveis locais a um bloco (a memória é liberada quando sai)
auto tipo nome;Variáveis globais fora de uma função (aloca memória permanente)
extern tipo nome;Variável que vai ser mantida em um registrador da CPU Melhora o desempenho de operações realizadas várias vezes
register tipo nome;Variável local, faz com que a variável não seja recriada a cada chamada da função
static tipo nome;Variável que não pode ser alterada
const tipo nome;Variável que pode ser alterada pelo hardware
extern volatile tipo nome;Variável que pode ser alterada pelo hardware mas não pelo programador
extern const volatile tipo nome;int
float
double
char
char vetor[n]
char matriz[m][n]typedef int inteiro; // Cria o sinônimo "inteiro" para int
typedef unsigned int natural; // Cria o sinônimo "natural" para intRetorna um inteiro indicando quantos bytes tem seu argumento
sizeof(int) // Retorna o n° de bytes para o tipo "int"
sizeof(n) // Retorna o n° de bytes para a variável "n"short -> int
Geralmente o compilador armazena menos espaço
long -> int e double
Geralmente o compilador armazena mais espaço
long long -> int
unsigned -> char e int
Inteiro sem sinal (0+)
signed -> char e int
Inteiro com sinal
int = signed int
short = short int
long = long int
long long = long long int
unsigned = unsigned int
signed = signed int = int
int a = 5;
double b = 2.5;
char c = 'V';
strcpy(nome, "Carlos");int x;
double y;
y = (tipo) x;tipo *ponteiro; // Declara um ponteiro
ponteiro = &x; // APONTA o ponteiro para o endereço de memória (&) da variável "x"
*ponteiro = y; // O VALOR do ponteiro apontando pra a variável "x" vai ser o valor da variável "y"
x = *ponteiro // variável "x" recebe o VALOR APONTADO pelo ponteiro
tipo *ponteiro = &x // Declara o ponteiro e já aponta para o endereço da variável "x"Como ponteiro pra função única
tipo funcao(tipo1 var1, tipo2 var2); // Função
tipo (*funcaoptr)(tipo1, tipo2); // Ponteiro da função
funcaoptr = funcao; // Ponteiro aponta pra função
funcaoptr(argumento); // Coloca argumento na funçãoComo ponteiro para array de funções
int sum(int a, int b); // Função soma
int subtract(int a, int b); // Função subtração
int multiply(int a, int b); // Função multiplicação
int divide(int a, int b); // Função divisão
int(*op[4])(int, int); // Declara array de ponteiros "op" com 4 ponteiros de função
op[0] = sum;
op[1] = subtract;
op[2] = multiply;
op[3] = divide;
// Essas 5 linhas podiam ser substituidas por int(*op[])() = {sum, subtract, multiply, divide};
resultado = op[x](a, b) // Usa a operação "x" em 'a' e 'b' Aponta para qualquer tipo (Lembrar de usar um casting antes)
int x = 33;
float y = 12.4;
char c = 'a';
void *ptr;
ptr = &x;
printf("void ptr aponta para %d\n", *((int *)ptr));
ptr = &y;
printf("void ptr aponta para %f\n", *((float *)ptr));
ptr = &c;
printf("void ptr aponta para %c", *((char *)ptr));Útil para criação de funções que podem receber ou devolver um tipo de dado não especificado
Saída formatada
int printf(const char *fmt, ...)
// Imprime os parâmetros na lista ... em stdout usando a cadeia fmt para determinar como
// Retorna: número de caractéres impressos ou um número negativo se houver erro%[flags][largura][.precisão][tamanho]conversão
0 -> Usa zeros ao invés de espaços para alinhar à direita
- -> Alinha à esquerda
+ -> Sempre acrescente o sinal de + ou -
" " -> Acrescenta um espaço antes de um número positivo
# <b> -> Forma alternativa para g,G,f,F,e,E,o,x,X
Substitui "*" com a quantidade necessária entregue pelos argumentos
printf("%*d", largura, var) // Imprime "var" com * <- largura
// Adicionará espaços em branco se necessário, se não, imprimirá o n° normalmente
printf("%*.*f", largura, precisao, var) // Imprime "var" com largura e precisãoConversões d, i, o, u, x, X: Número mínimo de dígitos que deve ser mostrado
Conversões a, A, e, E, f, F: Número mínimo à direita da vírgula
Conversões g, G: Número máximo de dígitos significativos
Conversões s, S: Número máximo de caracteres impressos
%d/%i -> int
%f -> float
%lf -> double
%c -> char
%s -> cadeia
%p -> endereço
%u -> unsigned int
%hi -> short int
%hu -> short int (unsigned)
%li -> long int
%lu -> long int (unsigned)
%lli -> long long int
%llu -> long long int (unsigned)
%e -> (float) Notação científica (Ex: 3.16e7 = 3.16*10^7)
%le -> (double) Notação científica
%Lf -> long double
%x -> Número hexadecimal
Saída não-formatada
int putc(int c, FILE* stream)
// Imprime o inteiro c convertido para unsigned char
// Retorna c convertido para unsigned char ou EOF se houver erroSaída não-formatada Equivalente a putc(c, stdout)
Saída não-formatada
int puts(const char *s)
// Escreve a cadeia *s no monitor, seguida de um \n
// Retorna um número não-negativo se bem-sucedida ou EOF se houver erroEntrada não-formatada
int getc(FILE *stream)
int fgetc(FILE *stream)
// Lê o próximo caractere da stream
// Retorna como um unsigned int convertido para int
// Retorna EOF no fim-de-arquivo ou em caso de erroEntrada não formatada
// Equivalente a:
getc(stdin)Entrada formatada
int scanf(const char *fmt, ...)
// Usa a cadeia de formato fmt e armazena na lista de endereços ...
// Retorna o n° de variáveis convertidas ou EOF se algo impedir a conversão%d -> Inteiro decimal com sinal
%i -> Dec, Hexa ou Octal com sinal
%u -> Decimal sem sinal
%o -> Octal sem sinal
%x/X -> Hexadecimal sem sinal
%s -> Cadeia sem brancos
%c -> Cadeia de tamanho w
%[""] -> Cadeia com apenas os carac. especificados
%[^""] -> Cadeia sem os carac. especificados
$p -> void
%n -> Nada. Armazena o n° de carac. já lidos
%e/E/f/g -> Número em ponto flutuante com sinal
Obs: d, i, f, s consomem brancos, já c e [ não
* -> O campo deve ser lido mas não armazenado
n° -> Limita o número de dígitos lidos com i/f ou símbolos com s
' -> Com números, especifica que há separadores de milhar
m -> Com cadeias, faz com que a memória suficiente para a cadeia seja alocada
Entrada não-formatada
char gets(array); // Guarda uma string em array
// Discarta \n e não o coloca no bufferEntrada não formatada
fgets(var, lenght, stdin); // textos e digitos até a quebra de linha (c/ espaço)
char* fgets(char *s, int n, FILE* stream)
// Lê no máximo n-1 carac. ou até encontrar \n ou EOF
// Armazena em s
// Se o \n for lido, ele é colocado em s. Adiciona \0
// Retorna s ou NULL se houver um errochar* strcpy(char *dest, char *src);
/**
* Copia a string apontada por "src" até '\0' no ponteiro "dest"
*
* Retorna:
* 1) Cópia do destino
* 2) Zero em caso de sucesso, não-zero em erro
*/char* strcat(char *dest, char *src);
/**
* Concatena a string apontada por "src" até o '\0' no fim do ponteiro "dest"
* src[0] substitui o '\0' no fim de dest
*
* Retorna:
* 1) Cópia do destino
* 2) Zero em caso de sucesso, não-zero em erro
*/size_t strlen(char *str);
/**
* Retorna:
* Comprimento da string (terminada por '\0')
*/int strcmp(char *string1, char *string2);
/**
* Compara string1 com string2 lexicograficamente
* Retorna:
* Negativo se string1 < string2
* Zero se string1 = string2
* Positivo se string1 > string2
*/char* strchr(char *str, int ch);
/**
* Encontra a primeira ocorrência do char 'ch'
*
* Retorna:
* Ponteiro pro caractere encontrado em "str"
* Ponteiro nulo se não encontrar
*/char* strstr(char *str, char*substring);
/**
* Encontra a primeira ocorrencia de "substring" em "str"
*
* Retorna:
* Ponteiro pro primeiro caractere da substring em "str"
* Ponteiro nulo se não encontrar
*/int tolower(int ch);
/**
* Converte o caractere 'ch' para sua versão minúscula
*
* Retorna:
* 1) Versão minúscula do caractere
* 2) Mesmo caractere caso já seja minúsculo ou não tenha essa versão
*/int toupper(int ch);
/**
* Converte o caractere 'ch' para sua versão maiúscula
*
* Retorna:
* 1) Versão maiúscula do caractere
* 2) Mesmo caractere caso já seja maiúscula ou não tenha essa versão
*/void* malloc(size_t n);
/**
* Aloca n bytes consecutivos na memória
*
* Retorna:
* 1) Apontador void para o início da região
* 2) NULL se não for possível alocar
*/void* calloc(size_t n, size_t t);
/**
* Aloca n bytes consecutivos na memória
* Inicializa todos os bits com 0
*
* Retorna:
* 1) Apontador void para o início da região
* 2) NULL se não for possível alocar
*/void* free(void *ptr);
/**
* Libera a região apontada pelo ponteiro ptr (alocada por malloc, calloc ou realloc)
*
* Retorna:
* Nada
*/void* realloc(void *ptr, size_t n);
/**
* Realoca uma região previamente alocada para que fique com "n" bytes
*
* Retorna:
* 1) Apontador void para o início da região
* 2) NULL se não for possível alocar
* Nesse caso a região original permanece inalterada
*/tipo|void nome(args)
{
// Sentenças
return var;
}
// Obs: void é usado quando a função não retornará nada/*
* Usar para limpar entrada antes do fgets
*/
void limpar_entrada()
{
char c;
while ((c = getchar()) != '\n' && c != EOF) {}
}/*
* Usar para ler texto fgets e tirar a quebra de linha causada pelo ENTER
* (não dispensa o limpar entrada)
* Necessita da biblioteca string.h
*/
#include <string.h>
void ler_texto(char *var, int lenght)
{
fgets(var, lenght, stdin);
strtok(var, "\n");
}