# data[].attributes.body
Adicionar elementos na lista

Para inserirmos um elemento na lista ligada, é necessário alocarmos o espaço na memória;

Atualizar o valor do ponteiro;

Posição do inserção

Final da lista

Primeira posição

No meio da lista;

# data[].attributes.body
struct

variável que armazena valores de tipos diferentes

struct automovel {
char modelo[20];
int ano;
float valor;
};

Lista Ligada
Estrutura de dados linear e dinâmica;
Cada elemento da sequencia é armazenado em uma célula da lista;

Criação ou definição da estrutura de uma lista;

Inicialização da lista

Inserção com base em um endereço como referencia

alocação de um endereço de nó para inserção na lista

remoção do nó com base em um endereço como referencia

deslocamento do no removido da lista

# data[].attributes.body
A função será invocada dentro dela mesma.

Um algoritmo recursivo resolve um problema dividindo-o em subproblemas mais simples, cujo a solução é a aplicação dele mesmo.

Ponto de parada; [Necessário para parar e concluir]
Variáveis na memória de trabalho;
As variáveis são independentes;

# data[].attributes.body
<tipo de retorno><nome> (<parâmetros>)
{
<comandos da função>
<retorno>(não obrigatório)
}

Passagem de valor: a função cria variáveis locais automaticamente para armazenar esses valores e após a execução da função essas variáveis são liberadas.

Passagem por referência:

Ponteiro e endereço de memória;

Não será criada uma cópia dos argumentos passados;

Será passado o endereço da variável e função trabalhará diretamente com os valores armazenados;

# data[].attributes.body
Variável local: são enxergadas somente dentro do corpo da função onde foram definidas;

Variável global: criá-la fora da função, assim ela será visível por todas as funções do programa. Geralmente adota-se declará-las após as bibliotecas.

Exemplo Global:

#include<stdio.h>

int x = 10;

int testar(){
return 2*x;
}

# data[].attributes.body
Alocar memória dinamicamente;
Exemplo: int* memoria = malloc (100);
Retorna dois valores: NULL ou um ponteiro genérico;

# data[].attributes.body
PONTEIRO

Tipo especial de variável, que armazena um endereço de memória;
O acesso à memória é feito usando dois operadores:

Asterisco (*): usado para criação do ponteiro; *a a*
"&": Acessar o endereço da memória;

<tipo> *<nome_do_ponteiro>;
Exemplo: int *idade;

A criação de um ponteiro só faz sentido se for associada a algum endereço de memória.

1.int ano = 2018;
2. int *ponteiro_para_ano=&ano;

# data[].attributes.body
PROCEDIMENTOS E FUNÇÕES
FUNÇÕES

A ideia de criar programas com blocos de funcionalidades vem de uma técnica de projeto de algoritmos chamada dividir para conquistar;

Trecho de código escrito para solucionar um subproblema;

Dividir a complexidade de um problema maior;
Evitar repetição de código;
Modularização; [módulos a serem compartilhados com nossos  códigos]

<tipo de retorno> <nome>(<parâmetros>)
{
<comandos da função> [ resolução feita aqui]
<retorno> (não obrigatório) [se for do tipo void]
}

<nome> - OBRIGATÓRIO > Parâmetro que especifica o nome que identificará a função.
<tipo de retorno> - OBRIGATÓRIO > Esse parâmetro indica qual o tipo de valor a função irá retornar. Pode ser um valor inteiro(int), decimal (float ou double), caractere (char),etc.
<parâmetros> - OPCIONAL.
<retorno> - Quando o tipo de retorno for void esse parâmetro não precisa ser usado, porém, quando não for void é obrigatório.

# data[].attributes.body
Em qualquer variável composta, o índice começa por zero, então, em uma matriz, o primeiro espaço para armazenamento é sempre (0,0), ou seja, índice 0 tanto para linha como para coluna.
Não é obrigatório que todas as posições sejam ocupadas, sendo possível declarar uma matriz com 10 linhas(ou colunas) e usar somente uma.

# data[].attributes.body
VETORES

Tipo especial de variável;
Armazena diversos valores "ao mesmo tempo", usando um mesmo endereço na memoria;
Sintaxe: tipo variavel [n]

int nome [10]

MATRIZES

Arranjos de duas ou mais dimensões. Assim como nos vetores, todos os elementos de uma matriz são do mesmo tipo, armazenando informações semanticamente semelhantes.

Sintaxe: tipo variável [m] [n]
                    m -> linhas
                    n -> colunas

# data[].attributes.body
for
Repetir uma informação por um número fixo de vezes;

for (inicialização; condição final; incremento)
{
comandos;
}

for ( int x=0; x < 10; x++)
{
printf ("%d", x);
}

# data[].attributes.body
Analisa a condição ao final do laço, ou seja, os comandos são executados antes do teste de condição.

while -> analisa SE acontecerá, podendo nunca passar no comando;
do while -> utilizado quando o comando deve acontecer pelo menos uma vez;

do
{
comandos;
} while ( condição);

do
{
printf ("valor = %d", valor);
valor++;
} while (valor < 10);

# data[].attributes.body
Contador - é utilizado para controlar as repetições;
Incremento e decremento - trabalham o número do contador, seja aumentando ou diminuindo.
Acumulador - irá somar as entradas de dados de cada iteração da repetição, gerando um somatório a ser utilizado quando da saída da repetição.
Condição de parada - utilizada para determinar o momento de parar quando não se tem um valor exato desta repetição. [relacionado com o contator]

# data[].attributes.body
Comandos serão repetidamente executados enquanto uma condição verdadeira for verificada, somente após a sua negativa essa condição será interrompida.

while (condiação)
{
comandos;
}

while (valor < 10)
{
    pintf ("valor = %d, valor);

    valor ++; (valor = valor+1)   [ controlador]
}

# data[].attributes.body
switch (variável) {
case constante1:
<comandos>
break;
case constante2:
<comandos>
break;
default: <comandos> }

switch ( valor )
{
 case 1 :
printf ("Domingo \n");
break; (Força sair do switch case, quando encontra o caso)

case 2 :
printf ("Segunda \n");
break;

default: (quando não encontrado nenhum caso, retorna um valor padrão)
printf ("Valor invalido! \n");

}

# data[].attributes.body
if (condição)
{
comandos;
}
else
{
comandos;
}

if (num>0)
{
printf ("O numero e positivo");
}
else
{
printf("O numero e negativo");
}

# data[].attributes.body
ESTRUTURAS DE DECISÃO CONDICIONAL

if
Tomar uma decisão e criar um desvio dentro do programa;

if (condição)
{
   comandos;
}

if (num>0)
{ printf ("O numero e positivo");
}

# data[].attributes.body
main() {

int valor;

printf ("Digite um número:");

scanf ("%d",&valor);

printf ("\n o número é %d, valor);
\n é utilizado para dar quebra de linha
}

# data[].attributes.body
As informações dos usuários são transferidas para variável do programa;

scanf ("expressão de controle", lista de argumentos);

scanf ("%d", &valor);

& -> endereço da variável;

# data[].attributes.body
As informações, mensagens e conteúdo de variáveis são enviadas para o usuário visualizá-las;

printf ("expressão de controle", listas de argumentos);

%c -> Permite a escrita de apenas um caractere;
%d -> Permite a escrita de números inteiros decimais;
%e -> Realiza-se a escrita de números em notação científica;
%f -> É feita a escrita de números reais(ponto flutuante);float
%s -> Efetua-se a escrita de uma série de caracteres.

printf ("O valor encontrado foi %d, valor1);
%d Reflete o valor da variável (valor1)

valor1 = 10

# data[].attributes.body
&&    E         - CONJUNÇÃO
||      OU      - DISJUNÇÃO
!        NÃO   - NEGAÇÃO

# data[].attributes.body
>    Maior
<    Menor
>= Maior ou igual
<= Menor ou igual
== Igual
!=  Diferente

# data[].attributes.body
Fornece valor a uma variável;
Pode ser uma expressão;
Símbolo:    =

Exemplos:

a = 2
a = b+c;
a = b*2;

# data[].attributes.body
OPERADORES

+       Adição                y+x;
-       Subtação              nota-extra;
*       Multiplicação         7*8; a*b;n*4;
/       Divisão               n1/n2; media/2;
%       Resto da divisão      15%2

# data[].attributes.body
Tipo                  Declaração em C

Inteiro                int
Real                    float
Caractere          char

Exemplo: #include <stdlib.h>
void main() {
int valor1, valor2, soma;
}

# data[].attributes.body
Início da execução de um programa em C;

main()
{ inicio
} fim

int main() [Retornar um valor para ele, voltando um valor final]

void main() [Usado por convenção, não retorna nada.]

# data[].attributes.body
As primeiras linhas de programação são definidas pelas bibliotecas.

stdio: funções de entrada e saída;

stdlib: transforma string em números;

string: manipulação de string;

math: operações matemáticas;

EXEMPLO:  #include <stdio.h>

# data[].attributes.body
1. Início do programa (bibliotecas)

<MAIN> Cria um bloco para iniciar e compilar o programa!

1. Definições das variáveis

2. Instrução de leitura dos dados

3. Instrução do formato de escrita

4. Demais instruções e funções

<MAIN>

1. Fim do programa

# data[].attributes.body
Identificação única;
Nomes para as variáveis significativos;
Caracteres válidos: números, letras maiúsculas ou minúsculas, underline (_);
Caracteres inválidos: "branco", caracteres especiais (@#$%¨)
O primeiro caractere de uma variável deve ser uma letra;
Não pode usar palavras reservadas.

# data[].attributes.body
Especifica as característica, ou seja, valores e operações possíveis de serem utilizadas com um dado desse tipo.

Tipo                   Descrição
Inteiro -> Representa valores inteiros. Ex: 18,300, -50;
Real     -> Valores reais(decimal). Ex: 5.5, 850.5, 23,50;
Caractere -> Sequência de um um ou mais caracteres; Ex: LEO
Lógico -> Valores lógicos: Verdadeiro, Falso.  (bool)

# data[].attributes.headline
COMPONENTES E ELEMENTOS DE LINGUAGEM DE PROGRAMAÇÃO

# data[].attributes.subject
COMPONENTES E ELEMENTOS DE LINGUAGEM DE PROGRAMAÇÃO

# data[].attributes.body
Variáveis

Um local que armazena um conteúdo específico na memória principal do computador;

Exemplo:

Variável / Conteúdo
Nome / Vanessa       (caracter)
Idade / 18           (valor numérico)
Telefone / 9999-9999 (valor numérico)

# data[].attributes.body
var -> definir variáveis para que se atribua um valor;
inicio -> defini inicio do código

# data[].attributes.body
Assemelha-se a forma em que os programas são escritos;
Português estruturado; (Diferente do português natural)
A intenção é chegar na resolução do problema;

# data[].attributes.body
FLUXOGRAMA

Representação gráfica;
Cada forma geométrica define uma função genérica;
As formas geométricas são ligadas por flechas (->) que indicam o fluxo da execução;

# data[].attributes.body
FLUXOGRAMA

Representação gráfica;
Cada forma geométrica define uma função genérica;
As formas geométricas são ligadas por flechas (->) que indicam o fluxo da execução;

# data[].attributes.body
VANTAGEM:

O Uso da linguagem natural;

DESVANTAGEM:

Imprecisão;
Desvantagem;

# data[].attributes.body
1. Misturar os ingredientes;

2. Untar a forma com manteiga;

3. Despejar a mistura na forma;

4. Se houver coco ralado então despejar sobre a mistura;

5. Levar a forma para o forno;

6. Enquanto não corar, deixar a forma no forno;

7. Retirar a forma do bolo;

8. Deixar esfriar;

Utiliza-se "condição (se)"
Utiliza-se "loop (enquanto)"

# data[].attributes.body
Utiliza a linguagem natural; (linguagem dia a dia)

Receita do bolo:

1. Misturar todos os ingredientes;

2. Untar a forma;

3. Despejar a mistura na forma;

4. Levar a forma para o forno;

5. Deixar o bolo 45 minutos no forno à 180º

6. Retirar a forma do bolo;

7. Desenformar o bolo;

P.S.: Pode haver outras formas para uma receita de bolo!!!

# data[].attributes.body
Formas de representação:

Descrição Narrativa;

Fluxograma;

Pseudocódigo;

# data[].attributes.body
Uma sequência ordenada de passos que deve ser seguida para a realização de uma tarefa;

Entrada -> Processamento -> Saída
Valores  -> Processamento -> Resultado;

Importante:

 Passos finitos; (solucionáveis)

 Sem redundância; (repetições)

 Sem subjetividade; (exata e objetiva)

 Deve ser claro e objetivo;

# data[].attributes.body
CONCEITOS DE ALGORITMOS E PROGRAMAÇÃO.