# data[].attributes.body
C usa a função printf para imprimir na tela e a função scanf para ler dados do usuário.

# data[].attributes.body
Laços, também chamados de loops, são estruturas de controle em programação que permitem que um conjunto de instruções seja repetido várias vezes até que uma condição específica seja satisfeita. Eles são usados para automatizar tarefas que precisam ser realizadas várias vezes ou para processar grandes quantidades de dados.

# data[].attributes.body
C permite a criação de estruturas de dados personalizadas chamadas structs. Por exemplo, você pode criar uma struct chamada "pessoa" com campos como nome, idade e endereço.

# data[].attributes.body
Existem três tipos de laços em linguagem de programação: while, do-while e for. Eles são usados ​​para executar um conjunto de instruções várias vezes com base em uma condição que pode ser testada no início ou no final do laço.

# data[].attributes.body
C oferece estruturas de controle como if, else, for, while e do-while para controlar o fluxo do programa.

# data[].attributes.body
C permite a criação de funções para reutilizar código.

# data[].attributes.body
É a descrição sequencial dos passos que devem ser executados de forma lógica e clara com a finalidade de resolver um problema.

# data[].attributes.body
É o resultado de uma lógica de programação.

# data[].attributes.body
É o conjunto de passos que foram colocados em uma sequência coerente.

# data[].attributes.body
Maneira coerente de pensar em um grupo de ações que gera uma sequência estruturada e regular com a finalidade de obter uma solução prática e eficaz para um problema.

# data[].attributes.body
Toda lógica tem início, meio e fim.

# data[].attributes.body
Exemplo:

acordar em certo horário;

tomar banho com certa duração;

colocar a roupa;

tomar café em tanto tempo;

sair de casa no horário;

tempo de percurso;

chegar ao trabalho.

# data[].attributes.body
relacionado a um verbo

# data[].attributes.body
sair do carro, abrir porta mala, fazer um bolo

# data[].attributes.body
relacionado a uma pergunta

# data[].attributes.body
tem aula? Está com fome?

# data[].attributes.body
repetição

# data[].attributes.body
comer enquanto tem fome

# data[].attributes.body
É a representação gráfica de um algoritmo, utilizando simbologias que formam blocos funcionais

# data[].attributes.body
A lógica de programação é a base da programação de computadores. É uma abordagem sistemática para resolver problemas através da codificação de soluções lógicas.

# data[].attributes.body
1. Compreenda os conceitos básicos

2. Pratique resolução de problemas: Treine sua capacidade de pensar lógicamente resolvendo problemas simples e, gradualmente, vá aumentando a dificuldade.

3. Aprenda a pensar em sequência: Compreenda como realizar tarefas em sequência para solucionar um problema.

4. Compreenda a programação estruturada: Aprenda como estruturar o código de maneira clara e organizada, usando estruturas de controle como if/else, loop e funções.

5. Aprenda a usar estruturas de dados: Compreenda como usar estruturas de dados, como listas, arrays, matrizes e árvores, para armazenar e processar informações de maneira eficiente.

6. Pratique: Pratique escrevendo códigos e solucionando problemas em diferentes linguagens de programação.

# data[].attributes.body
É importante lembrar que a condição deve ser avaliada como um valor lógico, ou seja, true ou false. Qualquer valor diferente de zero é considerado verdadeiro, e somente zero é considerado falso.

# data[].attributes.body
C permite a declaração de variáveis antes do uso. Por exemplo: "int idade;".

# data[].attributes.body
C é uma linguagem de programação de alto nível, de propósito geral, desenvolvida por Dennis Ritchie na Bell Labs em 1972. É amplamente utilizada para desenvolvimento de sistemas operacionais, drivers, aplicativos embarcados, jogos e outros.

# data[].attributes.body
#include <stdio.h>

int main() {
printf("Hello, World!");
return 0;
}

# data[].attributes.body
#include <stdio.h>

int main() {
int num = 5;
if (num > 0) {
printf("num é positivo\n");
} else if (num < 0) {
printf("num é negativo\n");
} else {
printf("num é zero\n");
}
return 0;
}

# data[].attributes.body
#include <stdio.h>

int main() {
for (int i = 0; i < 5; i++) {
printf("%d ", i);
}
printf("\n");
return 0;
}

# data[].attributes.body
#include <stdio.h>

struct Pessoa {
char nome[20];
int idade;
float salario;
};

int main() {
struct Pessoa p1 = {"Joao", 25, 2000.0};
printf("Nome: %s\nIdade: %d\nSalario: %f\n", p1.nome, p1.idade, p1.salario);
return 0;
}

# data[].attributes.body
1. Escreva um programa que imprima todos os números de 1 a 100.

2. Escreva um programa que solicite dois números ao usuário e imprima a soma desses números.

3. Escreva um programa que solicite três números ao usuário e imprima o maior deles.

4. Escreva um programa que solicite um número ao usuário e verifique se ele é par ou ímpar.

5. Escreva um programa que solicite dois números ao usuário e imprima todos os números entre eles (inclusive).

6. Escreva um programa que solicite uma letra ao usuário e verifique se ela é uma vogal ou consoante.

7. Escreva um programa que solicite um número ao usuário e imprima a tabuada desse número.

8. Escreva um programa que solicite um número ao usuário e verifique se ele é primo ou não.

9. Escreva um programa que solicite dois números ao usuário e imprima a divisão inteira e o resto da divisão.

10. Escreva um programa que solicite uma string ao usuário e imprima o número de caracteres dessa string.

# data[].attributes.body
Em C, os headers são arquivos de cabeçalho que contêm declarações de funções e constantes que podem ser usadas em vários programas. Esses arquivos geralmente possuem a extensão ".h" e são incluídos no início de um programa usando a diretiva #include.

# data[].attributes.body
Os headers são úteis porque permitem que você reutilize código em vários programas sem precisar copiá-lo e colá-lo em cada um deles. Em vez disso, você pode simplesmente incluir o cabeçalho correspondente no início do programa e usar as funções e constantes que ele define.

# data[].attributes.body
Os headers também ajudam a manter o código organizado, já que você pode colocar as declarações de funções relacionadas em um único arquivo e incluí-lo onde for necessário. Isso também facilita a manutenção do código, pois você só precisa modificar o arquivo de cabeçalho uma vez se precisar fazer alterações em uma função que é usada em vários programas.

# data[].attributes.body
Alguns headers já vem com o compilador, como por exemplo <stdio.h>, <stdlib.h>, <string.h> entre outros. E você também pode criar seus próprios headers para organizar o seu código de acordo com suas necessidades.

# data[].attributes.body
#include <stdio.h>

int main() {
int num1, num2, sum;

printf("Digite dois números inteiros separados por um espaço: ");
scanf("%d %d", &num1, &num2);

sum = num1 + num2;

printf("A soma de %d e %d é %d\n", num1, num2, sum);

return 0;
}

# data[].attributes.body
Neste exemplo, o programa pede ao usuário para inserir dois números inteiros separados por um espaço, e então utiliza a função scanf() para ler os valores digitados e armazená-los nas variáveis num1 e num2. Em seguida, o programa calcula a soma dos dois números e armazena o resultado na variável sum. Por fim, utiliza a função printf() para exibir a mensagem "A soma de X e Y é Z", onde X, Y e Z são os valores inseridos e a soma calculada.

# data[].attributes.body
#include <stdio.h>

int main() {
FILE* arquivo;
arquivo = fopen("dados.txt", "w"); // abre o arquivo "dados.txt" para escrita

if (arquivo == NULL) {
printf("Erro ao abrir o arquivo!");
return 1;
}

// escreve algumas linhas no arquivo
fprintf(arquivo, "Linha 1\n");
fprintf(arquivo, "Linha 2\n");
fprintf(arquivo, "Linha 3\n");

fclose(arquivo); // fecha o arquivo
printf("Dados escritos com sucesso!");

return 0;
}

# data[].attributes.body
Neste exemplo, a primeira coisa a ser feita é abrir o arquivo "dados.txt" para escrita usando a função fopen(). O segundo argumento "w" indica que o arquivo será aberto para escrita. Se o arquivo não existir, ele será criado.

Em seguida, verifica-se se o arquivo foi aberto corretamente. Se houver algum erro, uma mensagem de erro é exibida e o programa é encerrado.

Em seguida, usa-se a função fprintf() para escrever algumas linhas de texto no arquivo. A primeira argumento é o ponteiro do arquivo, e o segundo é o texto que será escrito.

Finalmente, o arquivo é fechado usando a função fclose() e uma mensagem de sucesso é exibida.

Note que o arquivo escrito será salvo no diretório onde o programa está sendo executado, caso você queira escrever em outro lugar é preciso passar o caminho completo.

# data[].attributes.body
#include <stdio.h>

int main() {
FILE* arquivo;
char caminho[] = "C:\\Users\\UserName\\Desktop\\dados.txt";
arquivo = fopen(caminho, "w"); // abre o arquivo "dados.txt" para escrita

if (arquivo == NULL) {
printf("Erro ao abrir o arquivo!");
return 1;
}

// escreve algumas linhas no arquivo
fprintf(arquivo, "Linha 1\n");
fprintf(arquivo, "Linha 2\n");
fprintf(arquivo, "Linha 3\n");

fclose(arquivo); // fecha o arquivo
printf("Dados escritos com sucesso!");

return 0;
}

# data[].attributes.body
Neste exemplo, a primeira coisa a ser feita é declarar uma variável caminho que armazena o caminho completo para o arquivo "dados.txt" que está no desktop do usuário "UserName" . Em seguida, o arquivo é aberto para escrita usando a função fopen() e o caminho completo como primeiro argumento.

Em seguida, verifica-se se o arquivo foi aberto corretamente. Se houver algum erro, uma mensagem de erro é exibida e o programa é encerrado.

Em seguida, usa-se a função fprintf() para escrever algumas linhas de texto no arquivo. A primeira argumento é o ponteiro do arquivo, e o segundo é o texto que será escrito.

Finalmente, o arquivo é fechado usando a função fclose() e uma mensagem de sucesso é exibida.

Note que é necessário usar duas barras invertidas "\" no caminho do arquivo, pois uma barra invertida é usada como caractere de escape em C.

# data[].attributes.body
#include <stdio.h>

int main() {
FILE* arquivo;
char caminho[] = "C:\\Users\\UserName\\Desktop\\dados.txt";
int num1, num2;
char texto[100];

arquivo = fopen(caminho, "r"); // abre o arquivo "dados.txt" para leitura

if (arquivo == NULL) {
printf("Erro ao abrir o arquivo!");
return 1;
}

// lê os dados do arquivo
fscanf(arquivo, "%d %d %s", &num1, &num2, texto);

fclose(arquivo); // fecha o arquivo

printf("Valor inteiro 1: %d\n", num1);
printf("Valor inteiro 2: %d\n", num2);
printf("Texto: %s\n", texto);

return 0;
}

# data[].attributes.body
Neste exemplo, a primeira coisa a ser feita é declarar uma variável caminho que armazena o caminho completo para o arquivo "dados.txt" que está no desktop do usuário "UserName" . Em seguida, o arquivo é aberto para leitura usando a função fopen() e o caminho completo como primeiro argumento.

Em seguida, verifica-se se o arquivo foi aberto corretamente. Se houver algum erro, uma mensagem de erro é exibida e o programa é encerrado.

Em seguida, usa-se a função fscanf() para ler dados do arquivo. O primeiro argumento é o ponteiro do arquivo, e os demais argumentos são as variáveis ​​que armazenarão os dados lidos. No exemplo acima, três valores são lidos: dois inteiros e uma string.

Finalmente, o arquivo é fechado usando a função fclose() e os dados lidos são exibidos na tela.

Note que é necessário usar duas barras invertidas "\" no caminho do arquivo, pois uma barra invertida é usada como caractere de escape em C.

# data[].attributes.body
As diretivas de pré-processador são instruções especiais que são processadas pelo compilador antes de começar a compilação do código-fonte. Elas geralmente começam com o caractere "#" e são usadas para incluir arquivos de cabeçalho, definir constantes e macros, entre outras coisas.

# data[].attributes.body
1. Algoritmo de ordenação: Um algoritmo de ordenação é usado para colocar uma lista de números ou elementos em ordem crescente ou decrescente. Um exemplo é o algoritmo de ordenação bubble sort, onde os elementos são comparados dois a dois e trocados de lugar se estiverem fora de ordem.

2. Algoritmo de busca: Um algoritmo de busca é usado para encontrar um item específico em uma lista ou base de dados. Um exemplo é o algoritmo de busca binária, onde a lista é dividida ao meio e o item é procurado em uma das metades, dependendo de onde o item provavelmente estaria.

3. Algoritmo de roteamento: Um algoritmo de roteamento é usado para encontrar a melhor rota entre dois pontos em um mapa. Um exemplo é o algoritmo de Dijkstra, que usa a distância para encontrar a rota mais curta.

4. Algoritmo de compressão de dados: Um algoritmo de compressão de dados é usado para reduzir o tamanho de um arquivo de dados sem perder informações importantes. Um exemplo é o algoritmo de compressão DEFLATE, usado no formato ZIP.

5. Algoritmo de encriptação: Um algoritmo de encriptação é usado para codificar informações confidenciais de forma que somente pessoas autorizadas possam lê-las. Um exemplo é o algoritmo AES (Advanced Encryption Standard) utilizado para proteção de dados sensíveis.

# data[].attributes.body
1. Escolha o tipo de jogo que deseja criar. Isso pode ser algo simples, como um jogo de adivinhação ou jogo da velha, ou algo mais complexo como um jogo de plataforma ou RPG.

2. Defina as regras e objetivos do jogo. Escreva um fluxo de jogo básico, incluindo as ações do jogador e a lógica de jogo.

3. Escreva o código. Comece com as funções básicas do jogo, como a exibição do menu, a entrada do jogador e a lógica do jogo. Use estruturas de controle como if-else e loops para controlar o fluxo do jogo.

4. Adicione gráficos e som. Você pode usar bibliotecas como SDL ou SFML para adicionar gráficos e som ao seu jogo.

5. Teste e depure o jogo. Teste o jogo várias vezes para garantir que ele esteja funcionando corretamente e conserte quaisquer erros ou bugs encontrados.

6. Faça o deploy do jogo. Embale o jogo em um formato executável e distribua-o para os jogadores.

# data[].attributes.body
1. Jogo da adivinhação: O jogador precisa adivinhar um número gerado aleatoriamente pelo computador. O jogador tem algumas tentativas e é informado se o número é maior ou menor que a sua tentativa.

2. Jogo da velha: Um jogo de tabuleiro onde dois jogadores marcam X ou O em uma grade 3x3, tentando fazer uma linha de três.

3. Jogo de forca: O jogador precisa adivinhar uma palavra secreta letra por letra antes que a figura da forca seja completada.

4. Jogo de palavras cruzadas: O jogador precisa preencher uma grade com palavras dadas.

5. Jogo de memória: O jogador precisa encontrar todos os pares de cartas com imagens iguais em um tabuleiro.

6. Jogo de labirinto: O jogador precisa encontrar a saída de um labirinto enquanto evita obstáculos e coleta itens.

# data[].attributes.body
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
int numero_secreto, numero_jogador, tentativas = 0;
srand(time(NULL));
numero_secreto = rand() % 100 + 1;

printf("Adivinhe o numero entre 1 e 100\n");
while (1) {
printf("Qual é o seu palpite? ");
scanf("%d", &numero_jogador);
tentativas++;

if (numero_jogador == numero_secreto) {
printf("Parabéns, você adivinhou o número em %d tentativas!\n", tentativas);
break;
} else if (numero_jogador < numero_secreto) {
printf("Seu palpite é muito baixo. Tente novamente.\n");
} else {
printf("Seu palpite é muito alto. Tente novamente.\n");
}
}
return 0;
}

# data[].attributes.body
Este código faz o seguinte:

1. Inclui as bibliotecas stdio.h, stdlib.h e time.h para usar funções de entrada e saída, gerar números aleatórios e inicializar a semente do gerador de números aleatórios.

2. Gera um número aleatório entre 1 e 100 e armazena-o na variável numero_secreto.

3. Pede ao jogador para adivinhar o número e armazena a entrada do jogador na variável numero_jogador.

4. Compara o número do jogador com o número secreto e informa ao jogador se o número é muito alto, muito baixo ou correto.

5. Se o jogador adivinhar o número, o loop é interrompido e o jogo termina. Se não, o jogador é convidado a tentar novamente.

6. O número de tentativas é incrementado a cada tentativa.

Este é um exemplo simples de como você pode escrever um jogo de adivinhação em C. Você pode adicionar mais funcionalidades, como limites de tentativas, dificuldade aumentando, e assim por diante.

# data[].attributes.body
#include <stdio.h>

char tabuleiro[3][3] = {{'1','2','3'}, {'4','5','6'}, {'7','8','9'}};
char jogador = 'X';

void imprime_tabuleiro() {
printf("\n");
printf(" %c | %c | %c\n", tabuleiro[0][0], tabuleiro[0][1], tabuleiro[0][2]);
printf("---|---|---\n");
printf(" %c | %c | %c\n", tabuleiro[1][0], tabuleiro[1][1], tabuleiro[1][2]);
printf("---|---|---\n");
printf(" %c | %c | %c\n", tabuleiro[2][0], tabuleiro[2][1], tabuleiro[2][2]);
}

void marca_jogada(int linha, int coluna) {
tabuleiro[linha][coluna] = jogador;
}

int verifica_vencedor() {
for (int i = 0; i < 3; i++) {
if (tabuleiro[i][0] == tabuleiro[i][1] && tabuleiro[i][0] == tabuleiro[i][2]) {
return 1;
}
if (tabuleiro[0][i] == tabuleiro[1][i] && tabuleiro[0][i] == tabuleiro[2][i]) {
return 1;
}
}
if (tabuleiro[0][0] == tabuleiro[1][1] && tabuleiro[0][0] == tabuleiro[2][2]) {
return 1;
}
if (tabuleiro[0][2] == tabuleiro[1][1] && tabuleiro[0][2] == tabuleiro[2][0]) {
return 1;
}
return 0;
}

int main() {
int linha, coluna;
int jogadas = 0;
int vencedor = 0;
printf("Jogo da Velha!\n");
imprime_tabuleiro();

while (jogadas < 9 && !vencedor) {
printf("Jogador %c, digite a posição da jogada (linha coluna): ", jogador);
scanf("%d %d", &linha, &coluna);
marca_jogada(linha, coluna);
imprime_tabuleiro();
vencedor = verifica_vencedor();
if (vencedor) {
printf("Jogador %c ganhou!\n", jogador);
} else if (jogadas == 8) {
printf("Empate!\n");
}
jogador = (jogador == 'X') ? 'O' : 'X';
jogadas++;
}
return 0;
}

# data[].attributes.body
#include <stdio.h>
#include <string.h>

int main() {
char palavra_secreta[20];
char letra;
int acertos = 0;
int erros = 0;
int tentativas = 6; // número de tentativas antes de perder
int acertou_palavra = 0;

// pega a palavra secreta
printf("Digite a palavra secreta: ");
scanf("%s", palavra_secreta);

// loop principal do jogo
while (erros < tentativas && !acertou_palavra) {
printf("Digite uma letra: ");
scanf(" %c", &letra);

int acertou_letra = 0;
for (int i = 0; i < strlen(palavra_secreta); i++) {
if (palavra_secreta[i] == letra) {
acertou_letra = 1;
acertos++;
printf("Acertou! A letra %c está na palavra secreta.\n", letra);
}
}

if (!acertou_letra) {
erros++;
printf("Errou! A letra %c não está na palavra secreta.\n", letra);
}

if (acertos == strlen(palavra_secreta)) {
acertou_palavra = 1;
printf("Parabéns! Você acertou a palavra secreta: %s\n", palavra_secreta);
}
}

if (!acertou_palavra) {
printf("Você perdeu! A palavra secreta era: %s\n", palavra_secreta);
}

return 0;
}

# data[].attributes.body
#include <stdio.h>
#include <string.h>

int main() {
char palavra_secreta[20];
char letra;
int acertos = 0;
int erros = 0;
int tentativas = 6;
int acertou_palavra = 0;
int jogar_novamente = 1;

while (jogar_novamente) {
// pega a palavra secreta
printf("Digite a palavra secreta: ");
scanf("%s", palavra_secreta);

// loop principal do jogo
while (erros < tentativas && !acertou_palavra) {
printf("Digite uma letra: ");
scanf(" %c", &letra);

int acertou_letra = 0;
for (int i = 0; i < strlen(palavra_secreta); i++) {
if (palavra_secreta[i] == letra) {
acertou_letra = 1;
acertos++;
printf("Acertou! A letra %c está na palavra secreta.\n", letra);
}
}

if (!acertou_letra) {
erros++;
printf("Errou! A letra %c não está na palavra secreta.\n", letra);
}

if (acertos == strlen(palavra_secreta)) {
acertou_palavra = 1;
printf("Parabéns! Você acertou a palavra secreta: %s\n", palavra_secreta);
}
}

if (!acertou_palavra) {
printf("Você perdeu! A palavra secreta era: %s\n", palavra_secreta);
}

// pergunta se o jogador quer jogar novamente
printf("Jogar novamente? (1 = sim, 0 = não): ");
scanf("%d", &jogar_novamente);

// reseta as variáveis para o próximo jogo
acertos = 0;
erros = 0;
acertou_palavra = 0;
}

return 0;
}

# data[].attributes.body
#include <stdio.h>

void desenhaForca(int erros) {
if (erros == 0) {
printf("_________\n");
printf("|        |\n");
printf("|\n");
printf("|\n");
printf("|\n");
printf("|\n");
printf("|\n");
} else if (erros == 1) {
printf("_________\n");
printf("|        |\n");
printf("|        O\n");
printf("|\n");
printf("|\n");
printf("|\n");
printf("|\n");
} else if (erros == 2) {
printf("_________\n");
printf("|        |\n");
printf("|        O\n");
printf("|        |\n");
printf("|\n");
printf("|\n");
printf("|\n");
} /* e assim por diante, adicionando mais partes do corpo da forca */
}

int main() {
int erros = 0;
char letra;

/* aqui você pode colocar o código do jogo da forca */
while (1) {
printf("Digite uma letra: ");
scanf("%c", &letra);

/* aqui você verifica se a letra está correta */
if (letra_está_errada) {
erros++;
}

desenhaForca(erros);

/* aqui você verifica se o jogo acabou */
if (jogo_acabou) {
printf("Você ganhou ou perdeu!\n");
printf("Deseja jogar novamente? (s/n) ");
scanf(" %c", &letra);
if (letra == 's') {
/* reinicia o jogo */
} else {
break;
}
}
}
return 0;
}

# data[].attributes.body
Strings: C trata strings como arrays de caracteres. É possível usar funções como strlen, strcpy, entre outras, para manipular strings.

Arrays: C permite a declaração de arrays, que são conjuntos de variáveis do mesmo tipo que podem ser acessadas usando índices.

# data[].attributes.body
Lógica, algoritmos e códigos

Fluxogramas

Elaborar estruturas

Usar ferramentas de edição de código

Desenvolver programas em prompt usando a linguagem C

Desenvolver programas para microcontroladores usando a linguagem C

# data[].attributes.body
É uma sequência lógica de instruções (conjunto de algoritmos) escritos numa linguagem. O programa é aquilo que será gravado e executado dentro do processador ou microcontrolador.

# data[].attributes.body
Montador: Traduz linguagem assembly em linguagem de máquina;

Interpretador: executa a tradução e a execução simultaneamente;

Run-Time: É a geração de código intermediário (pseudo compilado). Interpreta e compila alguns trechos (por exemplo, Asp Net);

Compilador: gera um código objeto independente, totalmente compilado.

# data[].attributes.body
Criada por Dennis Ritchie e Brian W. Kernighan no laboratório Bell em 1972 para criar o SO UNIX

Inicialmente linguagem BCPL

Linguagem B

Linguagem C semelhante com Algol 68

Linguagem C ANSI (padrão)

Linguagem C++ (orientado a objeto)

Linguagem C# e Java

# data[].attributes.body
1. Code::Blocks: É uma IDE gratuita e de código aberto para programação em C.

2. GCC: É um compilador de C gratuito e de código aberto.

3. Visual Studio Code: É um editor de código gratuito e de código aberto que possui suporte para C.

4. Turbo C: É uma antiga IDE gratuita para programação em C.

5. CodeLite: É uma IDE gratuita e de código aberto para programação em C.

# data[].attributes.body
1. int - Inteiros sem sinal ou sinal. Por exemplo, int a = 10;

2. char - Variáveis de caractere. Por exemplo, char c = 'A';

3. float - Números de ponto flutuante com precisão simples. Por exemplo, float f = 3.14;

4. double - Números de ponto flutuante com precisão dupla. Por exemplo, double d = 3.141592653589793238;

5. void - Tipo vazio, geralmente usado como tipo de retorno de funções que não retornam nenhum valor.

6. long - Inteiros longos. Por exemplo, long l = 1234567890;

7. short - Inteiros curtos. Por exemplo, short s = 123;

8. signed - Inteiros com sinal. Por exemplo, signed a = -10;

9. unsigned - Inteiros sem sinal. Por exemplo, unsigned a = 10;

# data[].attributes.body
#include: Usado para incluir arquivos de cabeçalho em seu código-fonte. Por exemplo, #include <stdio.h> inclui a biblioteca padrão de entrada e saída.

#define: Usado para definir constantes e macros. Por exemplo, #define PI 3.14 define uma constante chamada PI com o valor 3.14.

#ifdef e #ifndef: Usado para verificar se uma constante ou macro foi definida. Por exemplo, #ifdef DEBUG verifica se a constante DEBUG foi definida.

#if e #elif: Usado para fazer verificações condicionais. Por exemplo, #if A > B verifica se A é maior que B.

#undef: Usado para remover a definição de uma constante ou macro. Por exemplo, #undef DEBUG remove a definição da constanteDEBUG.

#pragma: Usado para passar instruções específicas para o compilador. Por exemplo, #pragma GCC optimize ("O2") passa a instrução de otimização para o compilador GCC.

Além dessas diretivas, existem outras como #error, #warning, #line, #file, #date, #time, e algumas específicas para alguns compiladores.

Cada diretiva deve estar em sua própria linha.

# data[].attributes.body
#include <stdio.h>

int main() {
int num1 = 5;
float num2 = 3.14;
char letter = 'a';

printf("num1: %d\nnum2: %f\nletter: %c", num1, num2, letter);
return 0;
}

# data[].attributes.body
#include <stdio.h>

int soma(int num1, int num2) {
return num1 + num2;
}

int main() {
int num1 = 5, num2 = 3;
int resultado = soma(num1, num2);
printf("%d + %d = %d\n", num1, num2, resultado);
return 0;
}

# data[].attributes.body
Diretivas de processamento: regras para o compilador (não ocupa memória);

Declaração de variáveis;

Protótipos de função;

Função principal: Main (), Loop infinito;

Definições das funções.

# data[].attributes.body
C é uma linguagem compilada, o que significa que o código-fonte deve ser compilado em um arquivo executável antes de ser executado. É necessário um compilador, como o GCC, para compilar o código.

# data[].attributes.body
Ponteiros são variáveis especiais que armazenam o endereço de memória de outra variável. Eles permitem que você acesse e manipule diretamente a memória do seu programa, o que pode ser útil em situações como alocação dinâmica de memória ou passagem de argumentos por referência.

# data[].attributes.body
Em C, você pode declarar um ponteiro usando o operador de referência "&", que retorna o endereço de memória de uma variável, e o operador de indireção "*", que permite acessar o conteúdo armazenado no endereço de memória apontado pelo ponteiro.

# data[].attributes.body
Por exemplo, considere o seguinte código que declara um ponteiro "ptr" e inicializa seu valor com o endereço de memória da variável "x":

# data[].attributes.body
int x = 10;
int *ptr = &x;

# data[].attributes.body
Agora, você pode acessar o valor de "x" usando o ponteiro da seguinte maneira:

# data[].attributes.body
printf("O valor de x é %d", *ptr);

# data[].attributes.body
Você também pode modificar o valor de "x" através do ponteiro:

# data[].attributes.body
*ptr = 20;
printf("O novo valor de x é %d", x);

# data[].attributes.body
É importante lembrar que ponteiros requerem cuidado e atenção para evitar erros de segmentação e vazamentos de memória.

# data[].attributes.body
#include <stdio.h>

int main() {
int a = 5, b = 10;
int *ptr1, *ptr2, temp;

ptr1 = &a; // armazena o endereço da variável 'a'
ptr2 = &b; // armazena o endereço da variável 'b'

temp = *ptr1; // armazena o valor apontado por 'ptr1' na variável 'temp'
*ptr1 = *ptr2; // armazena o valor apontado por 'ptr2' na variável apontada por 'ptr1'
*ptr2 = temp; // armazena o valor de 'temp' na variável apontada por 'ptr2'

printf("Valor de a: %d\n", a); // esperado: 10
printf("Valor de b: %d\n", b); // esperado: 5

return 0;
}

# data[].attributes.body
Nesse exemplo, utilizamos ponteiros para manipular os valores de duas variáveis 'a' e 'b', armazenando os seus endereços de memória em dois ponteiros 'ptr1' e 'ptr2', respectivamente. Depois, utilizamos um ponteiro temporário 'temp' para armazenar o valor apontado por 'ptr1', e então trocamos os valores das duas variáveis. No final, imprimimos os valores de 'a' e 'b' para verificar que a troca foi realizada com sucesso.

# data[].attributes.body
Nome dado aos elementos usados no programa: Variáveis, Funções, Matrizes e outros.

Caracteres para identificadores:

1º caractere: _ (underline), de A até Z ou a até Z;

demais caracteres: anteriores e 0 até 9;

case sensitive;

não pode coincidir com palavras reservadas;

até 31 caracteres.

# data[].attributes.body
Nome que indique exatamente o papel que a função ou variável desempenha; Usar verbos para funções: Salvar, Ler, Calcular etc; Quando tiver mais de uma palavra, iniciar cada uma com maiúsculo.

# data[].attributes.body
A variável deve ser declarada antes de ser usada;

O compilador deve saber quanto de memória cada variável irá usar e qual será o modo de interpretar cada valor.

Declaração simples:

tipo identificador

Declaração com inicialização

tipo identificador = ValorInicial;

Múltiplas declarações

tipo identificador_1, identificador_2, …, identificador_n;

Múltiplas declarações com inicialização

tipo identificador_1 = Valor_1, identificador_2 = Valor_2, …, identificador_n = Valor_n;

# data[].attributes.body
int x, y, z;

float Temperatura;

char texto_buffer[10];

unsigned int Distancia;

unsigned int x;

unsigned y = 12;

int a, b, c;

long int MinhaVar = 0x12345678;

long z; //quando não há tipo, pressupõe int;

char Letra_1 = ‘a’, Letra_2, Letra_3 = ‘c’;

float big_number = 6.02e+23

# data[].attributes.body
Em C, o tamanho das variáveis pode variar dependendo da plataforma, compilador e sistema operacional em que o código está sendo executado. No entanto, há alguns tamanhos de variáveis comuns em C:

char: normalmente ocupa 1 byte (8 bits)

short: normalmente ocupa 2 bytes (16 bits)

int: normalmente ocupa 4 bytes (32 bits)

long: normalmente ocupa 4 ou 8 bytes (32 ou 64 bits, dependendo do sistema)

long long: normalmente ocupa 8 bytes (64 bits)

float: normalmente ocupa 4 bytes (32 bits)

double: normalmente ocupa 8 bytes (64 bits)

É importante lembrar que esses são tamanhos comuns, mas não são garantidos. Para saber exatamente quantos bits cada tipo de variável ocupa em uma plataforma específica, é possível utilizar a função sizeof() em um programa em C.

# data[].attributes.body
#include <stdio.h>

int main() {
printf("char: %d byte(s)\n", sizeof(char));
printf("short: %d byte(s)\n", sizeof(short));
printf("int: %d byte(s)\n", sizeof(int));
printf("long: %d byte(s)\n", sizeof(long));
printf("long long: %d byte(s)\n", sizeof(long long));
printf("float: %d byte(s)\n", sizeof(float));
printf("double: %d byte(s)\n", sizeof(double));

return 0;
}

# data[].attributes.body
São declaradas dentro de uma função específica e só ocupam memória e podem ser usadas enquanto esta função está sendo executada;

Podem ser acessadas por outras funções, desde que sejam internos a função onde a variável foi declarada;

Podem ser inicializadas no momento da declaração ou após a declaração;

Toda vez que a função for executada, a variável será inicializada com o valor dado;

Se uma variável não for inicializada, então seu valor é indeterminado.

# data[].attributes.body
void func1 ()

{

int x = 10; //variável local declarada na função 1

}

void func2 ()

{

int x = 123; //variável local declarada na função 2

}

//a variável x da função 1 NÃO é a mesma da função 2

# data[].attributes.body
São as variáveis declaradas fora de qualquer função do programa, podem ser acessadas por qualquer função e estão o tempo todo ocupando espaço na memória do programa;

Evitar o uso de variáveis globais;

# data[].attributes.body
São utilizados para documentar a funcionalidade do programa e explicar o que um bloco ou linha do código faz.

comentário de bloco: /* Isto é um comentário de bloco */

comentário de linha: // Isto é um comentário de linha

# data[].attributes.body
Um identificador ou um nome de macro a uma string. Não há ponto-e-vírgula no final do comando.

# data[].attributes.body
#define BUFFER 1024

#define MSG “Mensagem qualquer” //MSG é o identificador e “Mensagem qualquer” a string.

UART1_Write (MSG); //Não preciso entrar com a mensagem no meu código. Mais fácil para alterar.

# data[].attributes.body
O nome da macro de um #define pode conter argumentos, de modo que você pode criar uma macro que funcione como uma função.

# data[].attributes.body
#define AOQUADRADO(x) (x)*(x)

int A;

A = AOQUADRADO(10); // A variável A irá receber o resultado 100.

# data[].attributes.body
Inclui um outro arquivo de código fonte (.c), de cabeçalho (.h), de definição (.inc) ou inicialização.

# data[].attributes.body
#include arquivo_ou_caminho

#include <file.h> //procura no diretório e subdiretório do compilador. Para arquivos do compilador

#include “file.h” //procura no diretório em que o projeto está salvo. Para arquivos do programador

#include “c:\MyProject\file.h” //procura num diretório específico

Pode ser usado para, por exemplo, separar o arquivo com a declaração das variáveis.

Primeiro arquivo

main.h

unsigned int a;

unsigned int b;

unsigned int c;

Segundo arquivo

main.c

#include main.h // será substituído pelo conteúdo do main.h

int main (void)

{

a = 5;

b = 2;

c = a + b;

}

# data[].attributes.body
Expressão aritmética contém um mais operando e operadores aritméticos

Operando podem ser variáveis, constantes ou valores retornados de funções

Há 9 operadores aritméticos, podendo ser binários (relacionam 2 operandos) ou unários (aplicados a apenas um operando)

Operadores binários

+ soma;

- subtração;

* multiplicação;

/ divisão;

% módulo.

Operadores unários

+ positivo;

- negativo.

++ incremento;

– decremento.

# data[].attributes.body
Operadores relacionais são símbolos usados em linguagens de programação para comparar dois valores e verificar se uma determinada relação é verdadeira ou falsa. Em C, existem seis operadores relacionais:

< Menor que

<= Menor ou igual a

> Maior que

>= Maior ou igual a

== Igual a

!= Diferente de

Esses operadores são comumente usados em estruturas de controle condicionais, como o if-else, para verificar se uma condição é verdadeira ou falsa.

Qualquer valor diferente de 0 é tido como verdadeiro.

Apenas 0 é dado como falso.