/* DIM() no se puede hacer con plantillas... */

#define DIM(V) ( sizeof(V) / sizeof(*V) ) // *V == *(V+0) == V[0]

dst[i] ==> * (dst + i)

long V[10]; // sizeof( V ) == 10 * sizeof( long ) == 10 * 4 == 40

V[i] <==> * ( V + i )

& V[2] ==> & * ( V + 2 ) == ( V + 2 )

char * pC; // puntero a un char

pC = V;  // Error de tipos: pC es (char*) y V es (long*)

pC = (char *) V;

if ( (& V[2]) == (pC + 2*sizeof(long)) ) {
   // siempre "true";
}

{   // DECLARACIONES de hileras
    char M[5] = { 'p', 'i','t','o',\0 }; // "pito"
    char N[5] = "pito";
    char O[6] = "pito"; // ERROR: falta una letra...
    char P[]  = "pito"; // el compilador calcula el largo de P[]
    char *Q   = "pito"; // el compilador calcula el largo de P[]
    char S[]  = "banana";
    char T[]; // equivalente a char *T;

    M = S; // Asignación de punteros
           // ERROR: "M" es un constante, no se puede cambiar

    strcpy(M, S); // Compila... pero es erróneo pues strlen
                  // strlen(M) < strlen("banana")
    strcpy(S, M); // OK, pues sizeof(S) > 1+strlen("pito")
}

{   dst[i] = src[i]; // *(dst+i) = *(src+i);

    p = & dst[0];
    p = & ( *(dst + 0) );
    p = & ( *dst ) ;
    p = & * dst;
    p = dst;
}

V[i] <==> * ( V + i )

& V[2] ==> & * ( V + 2 ) == ( V + 2 )


     V                               V+2
     │                                │
    \│/                              \│/
     v   V[0]            V[1]         v  V[2]
    /─────────────\ /─────────────\ /─────────────\
   ┌┴──┬───┬───┬──┴┬┴──┬───┬───┬──┴┬┴──┬───┬───┬──┴┐
   │   :   :   :   │   :   :   :   │   :   :   :   │
   └───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┴───┘
     ^   1   2   3   4   ^           ^
    /│\                 /│\         /│\
     │                   │           │
   ┌─┼─┬───┬───┬───┐     │           │
   │ * : * : * : * │   pC+5        pC+2 * sizeof(long)
   └───┴───┴───┴───┘
    pC
{
    char * pC; // puntero a un char
    long V[3]; // vector con 3 enteros
    pC = (char *) V; // "typecast" == transferencia de tipos

    if ( (& V[2]) == (pC + 2*sizeof(long)) ) {
        // siempre "true";
    }
}