#include <stdio.h>

int main (void)
{
    /*float far[2][2] = { {3.14, 2.72}, {9.8, 1.42}};
    //printf("Endereco de far[0][0] eh igual ao endereco de far: %p %p\n", &(far[0][0]), far);
    printf("Valor de *far: %p\n", *far);
    printf("Valor de **far: %fn" **(far));
    printf("Endereco de far: %p == %p == %p\tValor: %f\n", far, far[0], &(far[0][0]), **(far));
    //printf("Endereco de far: %p == %p == %p\tValor: %f\n", far, far[1], &(far[1][0]), *(far[1]));
    //printf("%f\n", (*(&*(far[1] - 2) + 1) + 1));

    //char* end = (char*) far[1] + 0;
    //printf("%p %p", end, &far[1][0]);
    return 0;*/


    int N = 3;
    float* endf;
    double* endd;

    double vet[4] = {4.4, 3.3, 2.2, 1.1};
    float mat[2][2] = {{4.0, 3.0}, {2.0, 1.0}};

    endd = vet+1;
    endf = (float*) mat; // converte endereco float** em float*


    printf("******************************** ITEM A ********************************\n\n");
    // Hipótese: o valor de endd é o endereço de vet + 1; logo, o valor de *endd é o mesmo valor de vet[1]
    printf("%p == %p -> %lf == %lf\n", endd, vet + 1, *endd, vet[1]);
    // Resultado: CORRETO!

    // Hipótese: mat é o endereço de mat[0] + 0, de modo que endf armazena esse endereço; logo, mat[0][0] e *endf tem o mesmo valor
    printf("%p == %p == %p => %lf == %lf == %f\n", mat[0] + 0, mat, endf, mat[0][0], **mat, *endf);
    // Resultado: CORRETO!


    printf("\n\n******************************** ITEM B ********************************\n\n");

    // Hipótese: endd + 1 é do tipo double*, logo *(endd + 1) é do tipo double e aponta para vet[2] = 2.2
    printf("%f\n", *(endd + 1));
    // Resultado: CORRETO!

    // Hipótese: endd - 1 é do tipo double*, logo endd - 1 é o mesmo valor do que vet
    printf("%p == %p\n", endd - 1, vet);
    // Resultado: CORRETO!

    // Hipótese: mat é do tipo float**, o resultado de mat é um ponteiro para o endereço mat[0] + 0
    printf("%p == %p\n", mat, mat[0] + 0);
    // Resultado: CORRETO

    // Hipótese: *mat é do tipo float*, o resultado de mat é um ponteiro para o endereço mat[0], que é o mesmo que mat[0] + 0,
    // isto é, dá o mesmo resultado do que a pergunta anterior
    printf("%p == %p\n", *mat, mat[0]);
    // Resultado: CORRETO

    // Hipótese: mat[0] é do tipo float*, logo o resultado é um ponteiro para o endereço mat[0], ou seja, o mesmo que o anterior
    printf("%p == %p\n", mat, mat[0]);
    // Resultado: CORRETO

    // Hipótese: **mat é do tipo float, logo o resultado é um float; em particular, ele é igual a mat[0][0]
    printf("**mat == %f == mat[0][0] == %f\n", **mat, mat[0][0]);
    // Resultado: CORRETO

    // Hipótese: **(mat + 1) é do tipo float; em particular, ele é igual a mat[1][0]
    printf("**(mat + 1) %f == mat[1][0] == %f\n", **(mat + 1), mat[1][0]);
    // Resultado: CORRETO

    // Hipótese: endd é do tipo double* (em particular, ele aponta para vet + 1), *endd é do tipo double e é vet[1], logo (*endd) + 3 é vet[1] + 3
    printf("%f == %f\n", (*endd) + 3, vet[1] + 3);
    // Resultado: CORRETO

    // Hipótese: endd é do tipo double* (em particular, ele aponta para vet + 1); endd + 3 aponta para vet + 4, que é double*,
    // mas vet + 4 está FORA dos limites do vetor e, portanto, aponta para um local desconhecido da memória. Logo, o valor de *(endd + 3)
    // é desconhecido.
    printf("vet + 3 = %p\tvet + 4 = %p\t (endd + 3) = %p\t*(endd + 3) = %lf\n", vet + 3, vet + 4, (endd + 3), *(endd + 3));
    // Resultado: Aparentemente correto... (?)

    // Hipótese: vet + 1 é double*, *(vet + 1) é double e é igual a 3.3, *(vet + 1) + 3 é double igual a 6.3
    printf("%lf == %lf\n", *(vet + 1) + 3, vet[1] + 3);
    // Resultado: CORRETO

    // Hipótese: vet é double*, *vet é double (em particular, é igual a 4,4), ((*vet) + 1) é double e igual a 5.4, ((*vet) + 1) + 3 é double igual a 8.4
    printf("%lf == %lf\n", (((*vet) + 1) + 3), ((vet[0]) + 1) + 3);
    // Resultado: CORRETO

    // Hipótese: vet[1] é o mesmo que *(vet + 1) e ambos são double; logo, &(vet[1]) é do tipo double*, assim como vet + 1, e ambos apontam para
    // o mesmo endereço
    printf("%p == %p && %lf == %lf\n", &(vet[1]), vet + 1, vet[1], *(vet + 1));
    // Resultado: CORRETO

    // Hipótese: endf é do tipo float* e aponta para mat[0] + 0, (char*) endf é do tipo char* e aponta para mat[0] + 0
    // ...
    // (char*) endf + 2 é do tipo char* e avança 2 BYTES na memória (pois a aritmética de ponteiros para char* assume tamanho de 1 byte),
    // de modo que aponta para o TERCEIRO BYTE ocupado por mat[0] + 0 (que, por ser float, ocupa 4 bytes)

    printf("\nendff == mat[0] + 0 i.e. %p == %p\nendff aponta para ao primeiro byte de mat[0] + 0\n", endf, mat[0] + 0);
    printf("1º byte de mat[0] + 0: %p\n2º byte de mat[0] + 0: %p\n3º byte de mat[0] + 0: %p\n", ((char*)endf), ((char*)endf) + 1, ((char*)endf) + 2, ((char*)endf) + 3);
    printf("4º byte de mat[0] + 0 eh, na verdade, mat[0] + 1, pois floats ocupam 4 bytes\n");
    printf("%p == %p\n", ((char*)endf) + 4, mat[0] + 1);
    printf("Respondendo a pergunta em especifico: ((char*)endf) + 2 eh o TERCEIRO byte de mat[0] + 0: %p\n", ((char*)endf) + 2);

    // Resultado: Aparentemente correto... (?)

    return 0;
}