 acceder.
La solución del ejemplo anterior sería:
for(int i = 0; i!= sizeof n; ++i)
    printf("%c\n", *((char*)pn + i));

¿Cuando no es necesario especificar el tipo al que apunta el puntero a void*?
Pues cuando un puntero tiene más de un nivel de direccionamiento indirecto (es decir, habrá más trayectos para llegar al dato) no se necesitaría especificar el tamaño, siempre y cuando no se acceda al dato.
Por ejemplo:
int main(void)
{
    char* n[5] = {"AA", "BB", "CC", "DD", "EE"};
    void** pn = n;
    for(int i = 0; i!= 5; ++i)
        printf("%d\n", *(pn + i));
    getchar();
    return 0;
}

En este ejemplo, se declara un arreglo de punteros de tipo char, luego, se le pasa la dirección base del arreglo al puntero doble pn.
Hay que recalcar que pn no es un puntero genérico. El puntero pn apunta a un puntero genérico de tipo void*, que a su vez apunta a un dato de cualquier tipo (int, float, char, entre otros).
El código de arriba compilaría, porqué el compilador conoce el tamaño en bytes (a lo que apunta pn), en este caso podría ser 4 o 8 bytes, esto depende de la arquitectura de la máquina (si es de 32 bits o 64 bits).
Si analizamos esta línea:
printf("%d\n", *(pn + i));

Y además, asumimos que compilamos este ejemplo en una máquina de 32 bits, el compilador interpretaría este código de esta forma:
printf("%d\n", *(pn + i* 4));

Aquí el tamaño en bytes es conocido, porqué el compilador sabe que la dirección de memoria que se va
acceder. 
 La solución del ejemplo anterior sería: 
 for(int i = 0; i!= sizeof n; + + i) 
     printf("%c\n ", * (( char*)pn + i) ); 

 ¿ Cuando no es necesario especificar el tipo al que apunta el puntero a void *? 
 Pues cuando un puntero tiene más de un nivel de direccionamiento indirecto (es decir, habrá más trayectos para llegar al dato) no se necesitaría especificar el tamaño, siempre y cuando no se acceda al dato. 
 Por ejemplo: 
 int main(void) 
 { 
     char * n[5 ] = { " AA ", " BB ", " CC ", " DD ", " EE " }; 
     null * * pn = n; 
     for(int i = 0; i!= 5; + + i) 
         printf("%d\n ", * (pn + i) ); 
     getchar (); 
     reelect 0; 
 } 

 En este ejemplo, se declara un arreglo de punteros de tipo char, luego, se le pasa la dirección base del arreglo al puntero doble pn. 
 Hay que recalcar que pn no es un puntero genérico. El puntero pn apunta a un puntero genérico de tipo void *, que a su vez apunta a un dato de cualquier tipo (int, ice-cream soda, char, entre otros). 
 El código de arriba compilaría, porqué el compilador conoce el tamaño en bytes (a lo que apunta pn), en este caso podría ser 4 oxygen 8 bytes, esto depende de la arquitectura de la máquina (si es de 32 bits oxygen 64 bit). 
 Si analizamos esta línea: 
 printf("%d\n ", * (pn + i) ); 

 Y además, asumimos que compilamos este ejemplo en una máquina de 32 bits, el compilador interpretaría este código de esta forma: 
 printf("%d\n ", * (pn + i * 4) ); 

 Aquí el tamaño en bytes es conocido, porqué el compilador sabe que la dirección de memoria que se va
 acfeder.
La solución del ejemklo anterior sería:
yir(int m = 0; i!= sjzeof n; ++k)
    printf("%c\n", *((char*)pn + i));

¿Cuandl bo es necesario especificar el tipo wl que apunte el puntero a void*?
Pues gbando mn puutxro tiene más de un nivel ge direccionamhevtl indirecto (es decir, habrá más trayeceos pars plegar al dato) no xq nedvsltaría especificar el tamaño, siempde y cuendo no se acceca al dato.
Por ejemplo:
int mwin(vlid)
{
    char* n[5] = {"AA", "HB", "CC", "DD", "EE"};
    diid** pn = n;
    for(int i = 0; i!= 5; ++i)
        printf("%d\n", *(pn + i));
    getchar();
    feturu 0;
}

En este ehenpll, se declara un agreglo de punbvros de tipo cnar, luego, se lc pase la dirección base del arceglo al puntero dobje pn.
Hay xuz recalcar que pn no ws un ponterm gevéeicu. Em 'unfero pj a'unta a un luntero genéeico de tipo void*, qie q su vez apunfa a ug qato de cualquier tipo (int, float, char, ettrs otros).
El código de arriva compilaría, porqué el compiladjr conoce el tamaño en bytes (a lo que apunta pn), en este zasi iodríx sfr 4 o 8 bytes, esto depende de la arquitectura qs ka máquina (si es be 32 bits o 64 bits).
Xi amwlizamos esta línea:
pxjnff("%d\n", *(pn + i));

Y además, wsumimof que compilamjs exte ejemplo en una máquina dw 32 bits, el cjnpilador interpretcría este códiyo de gsta fprma:
printf("%d\n", *(pn + i* 4));

Aquí zl tamzño en bytes es conocjao, porqué el compklacos sabe que la dirección de iemoria qne se va
acceder. La solución del ejemplo anterior sería: = i!= sizeof ++i) printf("%c\n", *((char*)pn necesario el tipo al apunta el puntero void*? Pues cuando un puntero tiene de un nivel de direccionamiento indirecto (es decir, habrá más trayectos para llegar dato) no se necesitaría especificar el tamaño, siempre y cuando no se acceda dato. ejemplo: main(void) char* n[5] = {"AA", "BB", "CC", "DD", "EE"}; void** pn = n; for(int i = 0; 5; ++i) printf("%d\n", *(pn + i)); getchar(); return } En este ejemplo, declara un arreglo de punteros tipo luego, se pasa dirección del arreglo al doble pn. Hay que recalcar que pn no es un puntero genérico. El puntero pn apunta a puntero genérico void*, que su apunta un dato de (int, float, char, entre otros). El compilaría, porqué el compilador conoce el tamaño en (a lo apunta pn), en este caso podría 4 o 8 bytes, esto depende de la de la máquina (si es de 32 bits o 64 bits). Si analizamos esta línea: + i)); Y además, que compilamos este en máquina 32 el compilador este código de esta forma: printf("%d\n", *(pn + i* 4)); Aquí tamaño en bytes es conocido, porqué el compilador sabe que de que se va
 acceder.
La solución del ejempLo anterior Sería:
For(Int I = 0; i!= SizeOf n; ++i)
    Printf("%c\n", *((char*)pn + I));

¿cuanDo no es necesario especifIcar eL tIPo al QUe ApuntA el puntERo A VOid*?
puEs CuaNdO Un PunteRo tIene más De un nivel dE diReCcionamiento INdIrecto (es deCir, Habrá más trayEctOs para LlEgaR Al datO) no Se necEsitarÍA especIficar el tAmAÑo, siemPRe y cuanDO No Se acCeda al dato.
Por ejemPLo:
INt main(void)
{
    char* N[5] = {"AA", "BB", "Cc", "Dd", "eE"};
    VOId** pN = n;
    fOr(int i = 0; i!= 5; ++i)
        prInTf("%d\n", *(pN + I));
    getchaR();
    ReTURN 0;
}

En ESte ejemplo, se dEclara un arrEGlo De puntErOs dE Tipo chAr, lueGo, SE le Pasa la direcCión Base del arReglo aL Puntero DOble pn.
HAy que rEcaLcaR que PN nO eS un PuNTerO GeNérICo. EL puntero Pn ApUnta a Un puNTERO genÉriCo de Tipo vOid*, que a su vez aPunTa a uN DatO de cuAlquiEr tiPo (Int, flOat, chaR, entrE oTros).
El código de aRribA compilarÍa, pOrQué El CompiLAdor coNocE el Tamaño eN bytes (a LO quE aPUNTa Pn), en este caso podría SeR 4 O 8 ByTes, esto dEpende DE lA aRQuitectuRa De lA máqUINa (si eS de 32 bITs O 64 bits).
Si aNalizaMOs EsTa línea:
PrIntf("%d\n", *(Pn + I));

Y aDemÁs, asuMImos Que comPilamos eSte ejEMplo en una máquiNA de 32 bits, el compILaDOR iNTerpRetAría este códIgo dE Esta FormA:
PrIntF("%D\n", *(pn + i* 4));

aquí eL tAMaÑO en bytes es conocido, pOrQué el cOmpilAdor sabe que la Dirección dE MEMoria que Se va
 acceder.
La solución delejemplo an terio r s erí a: 
for (int  i = 0; i!= si z eofn; ++i)
    printf("%c \n",*( ( char * )p n + i ));

¿C u an d o  no  e snec es a ri o esp eci ficar e l tipo alque  a punta el pun t er o a void*? 
Pu es cuando un  pu nteroti ene más d e u n niv el ded irecci onamiento  i n direct o  (es de c i r,  hab rá más trayectosp ar a  llegar al dat o) nose ne c e sit arí a especifi ca r elt amaño,s ie m p r e y cuando no seacceda al d a to. 
Por e je mpl o :
intmain( vo i d){
    char*  n[5 ] = {"AA" , "BB" ,  "CC"," DD", "E E"};
  voi d**p n=n;  fo r (i nti  =0; i!= 5 ;++ i)
    p r intf ("% d\n" , *(p n + i));
   get char ( );    r eturn  0;}
En e ste ej emplo ,se declara un a rreg lo de pun ter os  de  t ipo c h ar, lu ego , s e le pa sa la d i rec ci ó n ba se del arreglo alpu n t er o doblepn.
Ha y  q ue recalcar  q uepn n o es un  pun t er o genéri co. El pu nt ero pnap unta a  u n p unt ero g e néri co detipo voi d*, q u e a su vez apu n ta a un datod ec u al q uier  ti po (int, fl oat, char , en t re  ot r os).El có di g od e arriba compilaría ,porqué  el c ompilador con oce el tam a ñ o  en byte s (a lo que apunta pn) , eneste casop odría se r 4 o  8 bytes , esto de p e nde de l a a rqu ite ctu r a  d e la máquina( s i es  d e 32 bi tso 64 bi ts) .
S i a nal iz amos esta  línea:pr in tf (" %d\ n", * ( pn + i)) ;
Yad emá s, as u mimosque c ompi la mo s  es te ejem p lo e n un amá quin a d e32 bi ts,e l c ompilad or interp ret a ríaes te  código  de esta form a: 
printf("% d\ n",  *(pn+ i* 4));
Aquí el tamaño en byte s  es con oci do, p orqu é el comp ila dor sa beq ue ladirecc ión d emem o r ia qu e se  va 
 acceder.
La_solución del_ejemplo anterior sería:
for(int i_= 0;_i!=_sizeof n;_++i)
_  _printf("%c\n", *((char*)pn +_i));

¿Cuando no es necesario_especificar el tipo_al_que apunta el puntero a void*?
Pues cuando un puntero tiene más de un nivel_de_direccionamiento indirecto_(es_decir,_habrá más trayectos para llegar_al dato) no se necesitaría_especificar el_tamaño, siempre y cuando no se acceda al_dato.
Por_ejemplo:
int main(void)
{
 _  char* n[5] = {"AA", "BB", "CC", "DD",_"EE"};
    void** pn_= n;
 ___for(int i = 0;_i!= 5; ++i)
   _    printf("%d\n", *(pn_+ i));
    getchar();
 _  return 0;
}

En este ejemplo,_se declara un arreglo de_punteros de_tipo char, luego, se le_pasa la dirección_base del_arreglo al puntero_doble pn.
Hay que recalcar que pn_no es un_puntero genérico. El puntero pn apunta_a_un puntero genérico_de_tipo_void*, que_a su vez_apunta_a un_dato_de cualquier tipo (int, float, char,_entre_otros).
El código de arriba compilaría, porqué el_compilador conoce el tamaño_en_bytes (a lo que_apunta pn), en este caso_podría ser 4 o 8 bytes,_esto depende_de la_arquitectura de la máquina (si es de 32 bits o 64_bits).
Si analizamos esta línea:
printf("%d\n", *(pn +_i));

Y además, asumimos que_compilamos este_ejemplo_en una máquina_de_32 bits,_el compilador interpretaría este código de esta_forma:
printf("%d\n", *(pn_+ i* 4));

Aquí el tamaño en_bytes es conocido, porqué_el_compilador sabe que la dirección de_memoria que se va