Importação inicial para rodar o código:

'#import <stdio.h>
void main() {

}'

INPUT:
'import <stdio.h>
void main(){
char nome[10];
printf("Seu nome: ");
scanf("%s", &nome);
printf("olá, %s, blz?", nome);
}'

\n newline
\t tab
\b backspace
\r return (para o começo da linha)
\\ "\"
\" ' " ' (aspas)
\? "?"
\a sinal de aviso do OS
%% "%"

UTF8:
'#include <stdio.h>
#include <locale.h>
void main(){
setlocale(LC_ALL {{ou apenas o número 0}}, "Portuguese);
printf("olá");
}

TIPOS PRIMITIVOS
char
int
short int (2 bytes)
int (4 bytes)
longint (8 bytes)
signed ... (número positivo e negativo)
unsigned ... (número positivo apenas)
float
float (4 bytes)
double (float de 8 bytes)
void (None)

FORMATAÇÂO PRINTF:
%d int (em base decimal)
%f float
%c char (1 caractere)
%s string
%e notação neperiana
%hd short int
%ld long int
%hu unsigned short
%u unsigned
%lu unsigned long
void main(){
setlocale(0, "portuguese");
float peso;
printf("Digite seu peso, seu obeso: ");
scanf("%f", &peso);
printf("Seu gordo, você tem %.2f quilos", peso);
printf("o seu sexo é %c", 'M'); **Notar que em Char são aspas simples, em
String é dupla
}

CONSTANTES

#define CONSTANTE 21; (no topo do arquivo)

const int CONSTANTE = 21; (no main())

#define:
diretiva de pré-processamento (não ocupa memória)
o valor é substituído antes da compilação
não é possível indicar o tipo primitivo

const:
palavra reservada
constante ocupa espaço da memória
deve indicar o tipo primitivo

ENTRADA DE DADOS
'int numero;
float media;
scanf("%d", &numero);
scanf("%f", &media);'
OBS: No codeblocks, um float scanf deve ser com vírgula, e não ponto!!!
char letra;
scanf("%c", &letra);
OBS: Caso leia duas variáveis char, irá bugar. Precisa dar um clear na
entrada 'stdin'
com o comando 'fflush(stdin);' antes de cada scanf de char
'void main(){
setlocale(0, "portuguese");
int numero;
float media;
char letra;
printf("numero: ");
fflush(stdin);
scanf("%d", &numero);
printf("media: ");
fflush(stdin);
scanf("%f", &media);
printf("letra: ");
fflush(stdin);
scanf("%c", &letra);
printf("O numero é %d, a média é %1.6f e a letra é %c", numero, media, letra);
}'

Existe também a possibilidade de ler um caractere com a função interna 'getchar();'

'char letra1, letra2;

fflush(stdin);
letra1 = getchar();
fflush(stdin);
letra2 = getchar();
printf("letra 1 é %c, letra 2 é %c", letra1, letra2);'

Para ler strings, o scanf não precisa utilizar o '&var', apenas 'var'
O scanf não permite espaços
Para ler strings, é recomendado usar a função interna 'gets();'

***OBS: a função gets() recebe como argumento a string (gets(palavra)),

DIFERENTEMENTE da getchar(), que não tem argumento (letra = getchar())

Rand
incluir a biblioteca '<stdlib.h>' e '<time.h>'
ativar o rand com o comando 'srand(time(NULL));'
gerar um número é declarar uma variável 'int var = rand() % 10;' (gera de 0 a 9 (0
a n-1))

Operadores Aritméticos
+ Pode ser usado para adição, ou então para indicar o sinal da variável
ex: a=3, b=2, r=a+b =>r=5; b=2, r= -b => r=-2;
Também pode somar (e subtrair) char (1 caractere) de acordo com o código
ASC_II da letra. Somar o valor %d do char soma o número, e somar o valor %c
muda a letra em si

- Pode ser usado para subtração, ou para inverter o sinal de uma variável
ex: a=3, b=2, r=a-b =>r=1; a=3, r=-a =>r=-3;

* Multiplicação

/ Divisão: Caso a divisão seja entre 2 int, a divisão é a divisão inteira (//);
Caso a divisão seja entre dois floats (ou apenas um ser), a divisão é a real
(/);

% Módulo: só pode ser feito o módulo entre 2 ints (não pode ser float)

ORDEM DE PRECEDÊNCIA
()
+- (sinal, não soma e subtração)
*/% (na ordem que aparecerem)
+- (na ordem que aparecerem)

Coerção de tipo (typecast)

Se fizer a divisão de int A por int B, o resultado será sempre truncado, mesmo que
foloque explicitamente 'float resultado = A / B', o resultado será 'X,00000'
Se alguma das variáveis for float, o resultado será um float
O typecast envolve declarar, após o sinal de atribuição, o tipo desejado entre
parênteses antes da variável a ser afetada. ex: int a, int b -> float r = (float)
a/b => r = float' (mesmo teoricamente o resultado sendo um int, ele é convertido
para um float. A é considerado float, mas B continua sendo considerado int)

Operadores relacionais
<
>
<=
>=
!=
==
Os testes lógicos geram sempre resultados booleanos, mas em C o true é 1 e false é
0
'
int a = 8;
int b = 6;
inc c = (a<b+3);
printf("o resultado é %d", c);
=> 1 (true)'

Operadores ternários
? a interrogação é um operador ternário
'c = (x>0) ? 4:8' => C recebe o valor 4 se x for maior que 0; se for menor que 0, C
recebe 8
'situacao = (med>=7)?"aprovado":"reprovado"'

Operação com String

É impossível atribuir uma variável a uma string de maneira convencional. Para isso,
é preciso importar uma biblioteca <string.h>, e utilizar o método 'strcpy(var,
"str");', para atribuir então o valor de str à variável var.
É possível utilizar operador ternário com strings com o strcpy:
'strcpy(situacao, (media>=7)?"aprovado":"reprovado);'
strcpy(var, "str") define uma variável como sendo uma string
strlen(var) retorna o len da string
strcmp(var1, var2) retorna 1 se a primeira for menor que a segunda, 0 se forem
idênticas
(tamanho e caracteres), e -1 se a primeira for maior que a
segunda
strcat(var1, var2) concatena as duas strings
strupr(var), strlwr(var) MUDA O VALOR REAL da string para upper ou lower

Operadores Lógicos
&& conjunção (and)
|| disjunção (or)
! negação (not)
ordem de precedência:
! primeiro negação
&& segundo and
|| terceiro or
Operadores de atribuição
+=
-=
*=
/=
%=
Operadores de incremento e decremento
x++ +=1 após a linha de comando acabar (pós incremento)
++x +=1 antes da linha de comando acabar (pré incremento)
x-- -=1 após a linha de comando acabar (pós decremento)
--x -=1 antes da linha de comando acabar (pré decremento)
ex: int x = 5;
int y = 3 + x++;
x=>6 y=>8

int x = 5;
int y = 3 + ++x;
x=>6 y=>9
 Operadores bitwise
& conjunção (AND)
^ disjunção exclusiva (só é true se um for true (dois true/false dão false))
| disjunção (OR)

ex: int x = 25 & 12; int x = 25 ^ 12; int x = 25|12;

printf("%d", x); => 8 printf("%d", x); => 21 printf("%d", x);
=>29

(25)2 = 11001
(12)2 = 1100
11001 11001 11001
& 1100 ^ 1100 | 1100
------- -------
-------
01000 10101 11101

Operadores bitwise de deslocamento

>> right shift

- 10011 (19 em decimal): 19>>2 vai resultar em 100 (4 em decimal)

<< left shift

- 1100 (12 em decimal): 12<<2 vai resultar em 110000 (48 em decimal)

Estruturas de controle
São divididas em duas categorias: condições e repetições.
- Condições simples
Se determinada condição for alcançada, printa algo, por exemplo. Se não for
alcançada, não faz nada.

Capturando data e hora do sistema

'#include <time.h>
time_t t;
time(&t);
struct tm*data;
data = localtime(&t);
int d = data->tm_mday;
'
a variável data pode ter os valores:
tm_mday (dia)
tm_mon (mês)
tm_year (ano)

- Biblioteca time
tm_mday dia do mês [1-31]
tm_mon mês [0-11] (SEMPRE SOME +1)
tm_year ano [a partir de 1900] (SEMPRE SOME +1900 PARA ANO ATUAL)
tm_wday dia da semana [0-6] (0 é domingo e 6 é sexta-feira)
tm_yday dia do ano [0-365]
tm_hour hora [0-23]
tm_min minutos [0-59]
tm_sex segundos [0-59]