Ponteiros em C

ponteiros.c

#include <stdio.h>
int main(void) {
  int a = 7;
  int* aPtr;

  aPtr = &a;  // aPtr guarda o endereço de a

  printf(
      "O endereço de a é %p"
      "\nO valor de aPtr é %p",
      &a, aPtr);
  printf(
      "\n\nO valor de a é %d"
      "\nO valor de *aPtr é %d",
      a, *aPtr);
  printf(
      "\n\nMostrando que * e & são "
      "complementos um do outro\n&*aPtr = %p"
      "\n*&aPtr = %p",
      &*aPtr, *&aPtr);

  // Parte 2 do teste

  int** a2Ptr = &aPtr;  // a2Ptr guarda o endereço de aPtr
  printf(
      "\n\nComo aPtr também é uma variável, seu valor está\n"
      "em algum lugar na memória &aPtr = %p",
      &aPtr);
  printf("\n\na2Ptr é um ponteiro para aPtr, a2Ptr = %p", a2Ptr);

  // Parte 3 do teste

  int* ptr;  // Cria um ponteiro que não aponta pra nenhuma variável
             // específica, ou seja, é inicializado com lixo de memória

  *ptr = 20;  // Fala que essa posição aleatória vai armazenar um
              // valor 20. Fazer isso pode interromper o programa,
              // por estar acessando um local de memória não permitido,
              // ou escrevendo '20' em uma posição de memória do meu
              // programa, corrompendo silenciosamente algum valor

  printf("%d", *ptr);  // Imprime o valor nessa posição aleatória da
                       // memória, que será 20 caso o programa possua
                       // permissão para acessar a posição, ou interrompe
                       // o programa caso ele não possua permissão de
                       // acesso ao local da memória
}

soma_ponteiros.c

#include <stdio.h>

/**
 * @brief Soma dois números
 * 
 * @param x primeiro valor
 * @param y segundo valor
 * @return int a soma
 */
int soma(int x, int y)
{
    // soma os valores
    int z = x + y;

    // altera valor de x e y
    x = 0;
    y = 0;

    // retorna a soma original
    return z;
}

/**
 * @brief soma dois números através de seus ponteiros
 * 
 * @param x ponteiro para um inteiro
 * @param y ponteiro para outro inteiro
 * @return int a soma dos valores nas duas posições de memória
 */
int soma_ponteiros(int *x, int *y)
{
    // acessa os valores dentro das posições de memória e realiza a soma deles
    int z = *x + *y;

    // altera os valores dentro das posições de memória
    *x = 0;
    *y = 0;

    // retorna a soma original
    return z;
}

int main(void)
{
    // cria dois inteiros
    int a = 2, b = 3;

    // realiza a soma e imprime a, b e o resultado
    int s1 = soma(a, b);
    printf("%d %d %d\n", a, b, s1);

    // realiza a soma através dos ponteiros e imprime a, b e o resultado
    int s2 = soma_ponteiros(&a, &b);
    printf("%d %d %d\n", a, b, s2);
}

soma_satanica.c

#include <stdio.h>

#define T 100

int main(void) {
  int x[T];
  for (int i = 0; i < T; i++)
    x[i] = i;

  int soma1 = 0, soma2 = 0;
  for (int i = 0; i < T; i++) {
    soma1 += x[i];
    soma2 += *(x + i);
  }

  printf("%d %d\n", soma1, soma2);

  return 0;
}