Ponteiros

[JayCesar]

Ponteiros

Um bit é o menor espaço que podemos armazendar num computador, e pode ser 0 0 1; Agora quando eu tneho 8 bites juntos, eu tenho 1 byte. Obs: Pode depender da arquitetrua do computador, pois me alguns, um bit = 16 byte.

E isso é um byte (8bits):

Quando eu escrever ``int x;``` eu digo para o computador pegar o espaço de 8 bits (1byte) do computador para armazenar esse inteiro X:

int x;

Agora quando eu digitar x = 10 eu digo que esse 10 ocupa esse espaço reservado:

x = 10
\\ Um inteiro em C vale 4bits

Existe uma diferença entre o valor que está contido no meu computador e o endereço de memória do meu computador.

• Pre exemplo o 'endereço' de memória da variável x é 12:

[JayCesar]

Início de ponteiros:

#include <stdio.h>

int main(void){

    int x;
    // Reservei no meu computador um espaço para armazenar um valor inteiro;
    x = 10;
    // Nesse espaço de memória eu 'joguei' o 10;

    printf("%i\n", x);
    // Ok, mas como acessar o endereço?
    // Basta eu adicionar o '&' na frente da variávels que eu terei acesso
    // ao endereço da memória que contém esse 10;
    printf("%i\n", &x);

    // AGORA vou criar um ponteiro;
    // Eu preciso dizer que tipo de dado meu ponteiro irá apontar:
    int *ponteiro; // Acabei de criar um ponteiro que tá apontando para um valor inteiro; (famoso X9);
    /* printf("%i\n", ponteiro); (Aqui ele nã está apontando pra nenhum lugar) */

    ponteiro = &x;
    // Agora essa variável do tipo ponteiro está apontando para o endereço espaço de memória
    // da variável x;
    printf("%i", *ponteiro);
    // OU SEJA quando eu adiciono o '*' na frente, eu acesso o valor do endereço de memória
    // Mas quando eu NÃO adiciono '*' eu na frente, eu acesso apenas o endereço de memória.
    // O mesmo se aplica para o '&'; (IMPORTANTE);

    int a = 10;
    int b = a;

    a = 20;

    printf("\n%i %i", a, b);

    // Agora com ponteiros:
    int *ponteiro01; 
    ponteiro01 = &x; // x vale 10 aqui

    int y = 20;
    *ponteiro = y; // O valor do meu ponteiro será o valor de y, que é 20;
    printf("\n%i", *ponteiro);

    // getchat();
    return  0;
}   

// #include <stdio.h>

// int main(void){

//     getchat();
//     return  0;
// }   

[JayCesar]

Ponteiros "char, int, double"

#include <stdio.h>

int main(void){

    int x = 10;
    double y = 20.50;
    char z = 'a';

    int *pX; // Criei um ponteiro;
    pX = &x; // Eu acesso apenas o endereço (O endereço desse ponteiro está apontando para o endereço de X);
    // Ou seja, não tem o '*';
    // O ENDEREÇO QUE ESSE PONTEIRO ESTÁ APONTANDO;

    // int *pX = &x;
    // O valor do meu ponteiro é igual ao endereço de memória de X;
    // O VALOR QUE ESTE PONTEIRO ESTÁ APONTANDO;
    // Eu teria que fazer assim: *pX = x;

    double *pY = &y;
    char *pZ = &z;
    printf("%i", pY);

    double soma = *pX + *pY; 

    printf("\nO Endereco X = %i - Valor X = %i", pX, *pX);
    printf("\nO Endereco y = %i - Valor Y = %f", pY, *pY);
    printf("\nO Endereco Z = %i - Valor Z = %c", pZ, *pZ);
    printf("\nValor da soma %f: ", soma);

    int *resultado;
    resultado = (int *)6422272; // Preciso fazer um casting de inteiro para ponteiro;
    // Esse numero '6422272' é o endereço da variável 10;
    printf("\nValor da X %i: ", *resultado);
    // Ou seja, o endereço é acessado sem o '*';
    // CONCLUSÃO: Para acessar o valor do meu ponteiro, eu preciso utilziar o *; 

    return  0;
}   

[JayCesar]

Pointeiros para Estruturas

#include <stdio.h>

int main(void){

    struct horario{
        int hora;
        int minuto;
        int segundo;
    };

    struct horario agora, *depois;
    // O *depois é um ponteiro para uma estrutura do tipo horário;

    depois = &agora;

    (*depois).hora = 20;
    // Na linguagme C também existe ma precedenca de sinais, logo o ponto '.' vem
    // antes do asterisco (*);
    // Seria algo assim: *(depois.hora) = 20 - o que ainda está incorreto;
    // e por isso temos que dizer que queremos que seja feito primeir a parte do (*depois)
    // Pois eu quero que seja assim: (*depois).hora = 20;

    // Só que isso dá muito trabalho, por isso existe o atalho: ->

    depois->hora = 30;
    depois->minuto = 40;
    depois->segundo = 30;

    printf("\n%i %i %i", agora.hora, agora.minuto, agora.segundo);

    // Eu quero alterar esses valores utilizando o ponteiro:

    return 0;
}   

[JayCesar]

Pointeiros para Estruturas ( ->)

#include <stdio.h>

int main(void){

    struct horario{
        int hora;
        int minuto;
        int segundo;
    };

    struct horario agora, *depois;
    depois = &agora;

    depois->hora = 20;
    depois->minuto = 40;
    depois->segundo = 30;

    int somatorio = 100;

    struct horario antes;

    antes.hora = somatorio + depois->segundo;
    antes.minuto = agora.hora + depois->minuto;
    antes.segundo = depois->minuto + depois->segundo;

    printf("\n%i %i %i", antes.hora, antes.minuto, antes.segundo);

    return 0;
}   

[JayCesar]

Estruturas que contêm Ponteiros

// Estrutura que posuem ponteiros
#include <stdio.h>

int main(void){

    struct horario{
        int *pHora;
        int *pMinuto;
        int *pSegundo;
    };

    struct horario hoje;

    int hora = 200;
    int minuto = 300;
    int segundo = 400;

    hoje.pHora= &hora;
    hoje.pMinuto= &minuto;
    hoje.pSegundo= &segundo;

    printf("Hora - %i\n", *(hoje.pHora));
    printf("Minuto - %i\n", *hoje.pMinuto);
    printf("Segundo - %i\n", *hoje.pSegundo);

    *hoje.pSegundo = 1000;
    printf("Segundo - %i\n", *hoje.pSegundo);

    // struct horario agora, *depois;
    // depois = &agora;

    // depois->hora = 20;
    // depois->minuto = 40;
    // depois->segundo = 30;

    // int somatorio = 100;

    // struct horario antes;

    // antes.hora = somatorio + depois->segundo;
    // antes.minuto = agora.hora + depois->minuto;
    // antes.segundo = depois->minuto + depois->segundo;

    // printf("\n%i %i %i", antes.hora, antes.minuto, antes.segundo);

    return 0;
}   

[JayCesar]

Ponteiros como argumento de funções:

#include <stdio.h>

void testeVariavel(int x){ // É apenas uma cópia, ou seja, é outro endereço de memória;
    ++x; // Adiciona um;
    printf("%i\n", x);
}

void testePonteiro(int *pX){
    ++*pX; // Adiciona um ao valor da função;
    // Aqui eu vou direto na fonte
}

int main(void){

    // void testeVariavel(int x);
    // void testePonteiro(int *pX);
    int teste = 1;
    int *pTeste = &teste;

    testeVariavel(teste);
    testePonteiro(pTeste);
    // O parâmetro espera um argumento do tipo ponteiro;

    printf("%i\n", teste);

    // Quando nós passamos uma função que recebe como argumento uma variável, 
    // uma cópia é feita e é passada como argumento (e não o valor em sí);

    // 

    return 0;
}