elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Guía actualizada para evitar que un ransomware ataque tu empresa


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Clases de almacenamiento
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Clases de almacenamiento  (Leído 1,031 veces)
85

Desconectado Desconectado

Mensajes: 206



Ver Perfil WWW
Clases de almacenamiento
« en: 26 Marzo 2013, 22:38 pm »

Hola me decidí a crear un proyecto simple que trate de aplicar todas las keywords del lenguaje con respecto a las clases o directivas de almacenamiento. No creo haber utilizado todos los casos posibles, pero me parece que el resultado es un código que explica muy bien al menos como usar los  casos más generales.
Las keywords en cuestión son estas:

extern
static
auto
register
inline
mutable
volatile


No me pregunten sobre 'mutable' y 'volatile' porque no las he usado nunca XD.

El programa trata de mostrar información por pantalla para dejar en claro el lugar de almacenamiento de las variables utilizadas, y su valor de inicialización.
También se deja en claro el uso de estas directivas en funciones.

Otra cosa que quiero aclarar que 'extern' es por defecto, pero yo lo especifiqué explícitamente para esta demostración.

Y también muestro una forma de usar una función que normalmente no se puede usar de un archivo fuente a otro, pero mediante su dirección se puede.

Dejo el código.

main.cpp
Código
  1. //
  2. // By 85
  3. // elhacker.net
  4. // etalking.com.ar
  5. // boyscout_etk@hotmail.com
  6. // 2013
  7. //
  8.  
  9. ////////////////////////////////////////////////////////////////////////////////////////////////
  10.  
  11. #include<windows.h>
  12. #include<stdio.h>
  13.  
  14. #include "inclusiones.h"
  15.  
  16. ////////////////////////////////////////////////////////////////////////////////////////////////
  17.  
  18. ////////////////////////////////////////////////////////////////////////////////////////////////
  19.  
  20. char* palabra[] = { "Hola", "Mi", "Nombre", "Es", "David", "Y", "El", "Tuyo?" };
  21.  
  22. char* msgList[] = {
  23.  
  24.    "HAHAHA",
  25.    "HOHOHO",
  26.    "HUHUHU",
  27.    0
  28. };
  29.  
  30. char* cadenaCortada = "Hola\nMe\nDices\nTu\nNombre\n?\0";
  31.  
  32. ////////////////////////////////////////////////////////////////////////////////////////////////
  33.  
  34. extern int variable1;
  35. extern int variable2 = 0;
  36. int variable3        = 0;// Es extern por defecto!, aunque no se especifique
  37.  
  38. extern char cadena1[] = "AAAAAAAAAAAAAAA";
  39. extern char cadena2[] = "AAAAAAAAAAAAAAA";
  40. char cadena3[] =        "BBBBBBBBBBBBBBB";
  41.  
  42. static int x;
  43. static int y = 0;
  44.  
  45. ////////////////////////////////////////////////////////////////////////////////////////////////
  46. // MAL! (Revisar los conceptos de cada clase de almacenamiento)
  47.  
  48. //auto int varmal1;
  49. //auto int varmal2=0;
  50.  
  51. //register int varmal3;
  52. //register int varmal4=0;
  53.  
  54. ////////////////////////////////////////////////////////////////////////////////////////////////
  55.  
  56. //Mutable sólo puede ser aplicada a miembros de clases
  57. //Sirve para que determinados miembros de un objeto de una estructura o
  58. //clase declarado como constante, puedan ser modificados.
  59.  
  60. ////////////////////////////////////////////////////////////////////////////////////////////////
  61.  
  62. //Volatile se usa con objetos que pueden ser modificados desde el exterior del programa,
  63. //mediante procesos externos.
  64. //Es frecuente encontrar juntos los modificadores volatile y const:
  65. //si la variable se modifica por un proceso externo, no tiene mucho sentido que el
  66. //programa la modifique.
  67.  
  68. volatile int varilo1;
  69. volatile int varilo2 = 0;
  70.  
  71. volatile int  ilvolo1 = 10;
  72. //int*          p_ilvolo1 = &ilvolo1;// MAL!
  73. volatile int* p_ilvolo1 = &ilvolo1;
  74.  
  75. ////////////////////////////////////////////////////////////////////////////////////////////////
  76. // HACK
  77.  
  78. // El hack consiste en guardar las direcciones de las funciones 'static' y usar
  79. // punteros a función en las otras unidades de compilación.
  80. // De esa forma, el compilador no lo restringe.
  81.  
  82. DWORD add_Func1_StringCompare = (DWORD)&Func1_StringCompare;
  83. DWORD add_Func2_StringLength = (DWORD)&Func2_StringLength;
  84. DWORD add_Func3_StripReturn = (DWORD)&Func3_StripReturn;
  85.  
  86. ////////////////////////////////////////////////////////////////////////////////////////////////
  87.  
  88. static int Func1_StringCompare(char* q, char* a)
  89. {
  90.     do
  91.     {
  92.        if( *q!=*a )
  93.             return -1;
  94. if( !*q )
  95.     break;
  96. q++;
  97.         a++;
  98.     } while( *q );
  99.     return 0;
  100. }
  101.  
  102. ////////////////////////////////////////////////////////////////////////////////////////////////
  103.  
  104. static unsigned int Func2_StringLength(const char* f){
  105.  
  106. INT i=0;
  107.        while(*f++) i++;
  108.        return i;
  109. }
  110.  
  111. ////////////////////////////////////////////////////////////////////////////////////////////////
  112.  
  113. static void Func3_StripReturn(char* str)
  114. {
  115. for(register unsigned int i=0;i<strlen(str);i++)
  116. if (str[i]==10 || str[i]==13) {
  117. str[i]=' ';
  118. }
  119. }
  120.  
  121. ////////////////////////////////////////////////////////////////////////////////////////////////
  122. ////////////////////////////////////////////////////////////////////////////////////////////////
  123. ////////////////////////////////////////////////////////////////////////////////////////////////
  124.  
  125. void inline Func4_MostrarCadenas1(){// Inline es sólo para funciones
  126.  
  127. for(int i=0; i<(sizeof(palabra)/sizeof(palabra[0])); ++i)
  128. {
  129. printf("%d = %s\n", i, palabra[i]);
  130. }
  131. }
  132.  
  133. ////////////////////////////////////////////////////////////////////////////////////////////////
  134.  
  135. inline void Func5_MostrarMensajes1(){// Inline es sólo para funciones
  136.  
  137. for(char** i = msgList; *i; i++)
  138. {
  139. MessageBox(0, *i, *i, 0);
  140. }
  141. }
  142.  
  143. ////////////////////////////////////////////////////////////////////////////////////////////////
  144.  
  145. extern void Func6_getRAM(char* buf){
  146.  
  147. MEMORYSTATUS Status;
  148.        ZeroMemory(&Status, sizeof(Status));
  149.        Status.dwLength = sizeof(Status);
  150.        GlobalMemoryStatus(&Status);
  151.        DWORD dwRAM = (DWORD)(Status.dwTotalPhys/(1024*1024));
  152.        wsprintf(buf, "%d MB", dwRAM);
  153. }
  154.  
  155. ////////////////////////////////////////////////////////////////////////////////////////////////
  156.  
  157. void Func7_Variables1(){
  158.  
  159. // Valores de inicio y lugar de almacenamiento de las variables
  160. //
  161.  
  162. putchar(10);
  163.  
  164. int var1;
  165. int var2 = 0;
  166. static int var3;
  167. static int var4 = 0;
  168. volatile int var5;
  169. volatile int var6=0;
  170.  
  171. printf("variable local sin inicializar:        %d\n", var1);
  172. printf("variable local inicializada:           %d\n", var2);
  173. printf("variable local static sin asignar:     %d\n", var3);
  174. printf("variable local static asignada:        %d\n", var4);
  175. printf("variable local volatile sin asignar:   %d\n", var5);
  176. printf("variable local volatile asignada:      %d\n", var6);
  177. // printf("variable global sin asignar:           %d\n", variable1);
  178. printf("variable global asignada.              %d\n", variable2);
  179. printf("variable global asignada:              %d\n", variable3);
  180. printf("variable global static sin asignar:    %d\n", x);
  181. printf("variable global static asignada:       %d\n", y);
  182. printf("variable global volatile sin asignar:  %d\n", varilo1);
  183. printf("variable global volatile asignada:     %d\n", varilo2);
  184.  
  185.  
  186. printf("add variable local sin inicializar:        0x%X\n", &var1);
  187. printf("add variable local inicializada:           0x%X\n", &var2);
  188. printf("add variable local static sin asignar:     0x%X\n", &var3);
  189. printf("add variable local static asignada:        0x%X\n", &var4);
  190. printf("add variable local volatile sin asignar:   0x%X\n", &var5);
  191. printf("add variable local volatile asignada:      0x%X\n", &var6);
  192. // printf("add variable global sin asignar:           0x%X\n", &variable1);
  193. printf("add variable global asignada.              0x%X\n", &variable2);
  194. printf("add variable global asignada:              0x%X\n", &variable3);
  195. printf("add variable global static sin asignar:    0x%X\n", &x);
  196. printf("add variable global static asignada:       0x%X\n", &y);
  197. printf("add variable global volatile sin asignar:  0x%X\n", &varilo1);
  198. printf("add variable global volatile asignada:     0x%X\n", &varilo2);
  199.  
  200.  
  201. // El problema con la variable1 es que al haber usado 'extern' y no haberle
  202. // hecho una asignación de valor. el compilador entiende que se hace referencia
  203. // a una variable que está declarada en otra unidad de compilación.
  204. }
  205.  
  206. ////////////////////////////////////////////////////////////////////////////////////////////////
  207.  
  208. void Func8_Variables2(){
  209.  
  210. // Valores de inicio y lugar de almacenamiento de las variables
  211. //
  212.  
  213. putchar(10);
  214.  
  215. // Se crean y destruyen automáticamente (no se necesita especificar)
  216. auto int varbien1;
  217. auto int varbien2=0;
  218.  
  219. // Si es posible, se van a almacenar en algún registro del CPU para tener
  220. // un acceso más rápido a ellas. (Tamaño adecuado para entrar en un registro!)
  221. register int varbien3;
  222. register int varbien4=0;
  223.  
  224. printf("variable local auto sin asignar:      %d\n", varbien1);
  225. printf("variable local auto asignada:         %d\n", varbien2);
  226. printf("variable local register sin asignar:  %d\n", varbien3);
  227. printf("variable local register asignada:     %d\n", varbien4);
  228.  
  229. auto int var1 = 85;
  230. auto int var2 = var1;
  231. printf("var1: %d   add: 0x%X\n", var1, &var1);
  232. printf("var2: %d   add: 0x%X\n", var2, &var2);
  233.  
  234. register int var3 = 85;
  235. // Si estubiera en un registro no se obtendría una dirección de memoria!
  236. printf("var3: %d   add: 0x%X\n", var3, &var3);
  237.  
  238. register int i;
  239. // register int i=0;
  240. for(i=1; i<=10; i++){
  241. if(i==1) printf("add i: 0x%X\n",&i);
  242. printf("%d",i);
  243. }
  244. putchar(10);
  245. }
  246.  
  247. ////////////////////////////////////////////////////////////////////////////////////////////////
  248.  
  249. static void Func9_dummy1(register int* x){
  250.  
  251. printf("x: %d   add: 0x%X\n", *x, &x);
  252. }
  253.  
  254. ////////////////////////////////////////////////////////////////////////////////////////////////
  255.  
  256. static void Func10_dummy2(register int y){
  257.  
  258. printf("y: %d   add: 0x%X\n", y, &y);
  259. }
  260.  
  261. ////////////////////////////////////////////////////////////////////////////////////////////////
  262.  
  263. static void Func11_dummy3(volatile int z){
  264.  
  265. printf("z: %d   add: 0x%X\n", z, &z);
  266. }
  267.  
  268. ////////////////////////////////////////////////////////////////////////////////////////////////
  269. // Retorna un INT volatile, sólo se aplica al tipo de retorno.
  270.  
  271. volatile int Func12_dummy4(int arg){
  272.  
  273. int res = arg;
  274. return res;
  275. }
  276.  
  277. ////////////////////////////////////////////////////////////////////////////////////////////////
  278.  
  279. void Func13_Argumentos(){
  280.  
  281. putchar(10);
  282.  
  283. int a = 500;
  284. Func9_dummy1(&a);
  285.  
  286. int b = 1000;
  287. Func10_dummy2(b);
  288.  
  289. int c = 5000;
  290. Func10_dummy2(c);
  291.  
  292. int d = 100000;
  293. Func11_dummy3(d);
  294.  
  295. int e = Func12_dummy4(15);
  296. printf("%d\n", e);
  297. }
  298.  
  299. ////////////////////////////////////////////////////////////////////////////////////////////////
  300.  
  301. int main(){
  302.  
  303. Func4_MostrarCadenas1();
  304. Func5_MostrarMensajes1();
  305.  
  306. // Cualquiera de las 2 formas (con o sin extern, es lo mismo)
  307. extern void Test1_UnidadDeCompilacion1();
  308. extern void Test2_UnidadDeCompilacion1();
  309. extern void Test3_UnidadDeCompilacion1();
  310. extern void Test1_UnidadDeCompilacion2();
  311. extern void Test2_UnidadDeCompilacion2();
  312. void Test3_UnidadDeCompilacion2();
  313.  
  314. Test1_UnidadDeCompilacion1();
  315. Test2_UnidadDeCompilacion1();
  316. Test3_UnidadDeCompilacion1();
  317. Test1_UnidadDeCompilacion2();
  318. Test2_UnidadDeCompilacion2();
  319. Test3_UnidadDeCompilacion2();
  320.  
  321. Func8_Variables2();
  322.  
  323. Func3_StripReturn(cadenaCortada);
  324. printf("%s\n",cadenaCortada);
  325. system("pause");
  326. return (0);
  327. }
  328.  

unidad_comp1.cpp
Código
  1. //
  2. // By 85
  3. // elhacker.net
  4. // etalking.com.ar
  5. // boyscout_etk@hotmail.com
  6. // 2013
  7. //
  8.  
  9. ////////////////////////////////////////////////////////////////////////////////////////////////
  10.  
  11. #include<windows.h>
  12. #include<stdio.h>
  13.  
  14. #include "inclusiones.h"
  15.  
  16. ////////////////////////////////////////////////////////////////////////////////////////////////
  17.  
  18. int (*Ptr_Func1_StringCompare)(char*, char*);
  19.  
  20. ////////////////////////////////////////////////////////////////////////////////////////////////
  21.  
  22. extern void Test1_UnidadDeCompilacion1(){
  23.  
  24. // Los externs en este caso son locales a esta función.
  25. extern void Func6_getRAM(char* buf);
  26.  
  27. char TotalRAM[256] = "";
  28.        Func6_getRAM(TotalRAM);
  29. putchar(10);
  30.        printf("Test1_UnidadDeCompilacion1: Total RAM: %s\n", TotalRAM);
  31. }
  32.  
  33. ////////////////////////////////////////////////////////////////////////////////////////////////
  34.  
  35. extern void Test2_UnidadDeCompilacion1(){
  36.  
  37. // Los externs en este caso son locales a esta función.
  38. extern DWORD add_Func1_StringCompare;
  39. extern char cadena1[];
  40. extern char cadena2[];
  41. extern char cadena3[];
  42.  
  43. putchar(10);
  44.  
  45. Ptr_Func1_StringCompare = (int(*)(char*, char*))add_Func1_StringCompare;
  46.  
  47. //if(Func1_StringCompare(cadena1, cadena2) == 0)// No se puede!
  48. if(Ptr_Func1_StringCompare(cadena1, cadena2) == 0)
  49. {
  50. printf("Test2_UnidadDeCompilacion1: IGUALES\n");
  51. }
  52.  
  53. // No se puede! porque getRam no es un extern "global" en esta unidad de compilación.
  54. //char TotalRAM[256] = "";
  55.        //Func6_getRAM(TotalRAM);
  56.        //printf("Total RAM: %s\n", TotalRAM);
  57. }
  58.  
  59. ////////////////////////////////////////////////////////////////////////////////////////////////
  60.  
  61. extern void Test3_UnidadDeCompilacion1(){
  62.  
  63. // Cualquiera de las 2 formas
  64. extern void Func7_Variables1();
  65. void Func7_Variables1();
  66.  
  67. Func7_Variables1();
  68. }
  69.  

unidad_comp2.cpp
Código
  1. //
  2. // By 85
  3. // elhacker.net
  4. // etalking.com.ar
  5. // boyscout_etk@hotmail.com
  6. // 2013
  7. //
  8.  
  9. ////////////////////////////////////////////////////////////////////////////////////////////////
  10.  
  11. #include<windows.h>
  12. #include<stdio.h>
  13.  
  14. #include "inclusiones.h"
  15.  
  16. ////////////////////////////////////////////////////////////////////////////////////////////////
  17. // Los externs pueden ser globales para que sirvan en toda esta unidad de compilación
  18.  
  19. unsigned int (*Ptr_Func2_StringLength)(const char*);
  20.  
  21. extern DWORD add_Func2_StringLength;
  22. extern char cadena1[];
  23. extern char cadena2[];
  24. extern char cadena3[];
  25.  
  26. // Cualquiera de las 2 formas
  27. extern void Func13_Argumentos();
  28. void Func13_Argumentos();
  29.  
  30. ////////////////////////////////////////////////////////////////////////////////////////////////
  31.  
  32. extern void Test1_UnidadDeCompilacion2(){
  33.  
  34.  
  35. putchar(10);
  36.  
  37. //int len1 = Func2_StringLength(cadena1);// No se puede!
  38.  
  39. Ptr_Func2_StringLength = (unsigned int(*)(const char*))add_Func2_StringLength;
  40.  
  41. int len1 = Ptr_Func2_StringLength(cadena1);
  42.  
  43. printf("Test1_UnidadDeCompilacion2: len1: %d\n", len1);
  44. }
  45.  
  46.  
  47. ////////////////////////////////////////////////////////////////////////////////////////////////
  48.  
  49. extern void Test2_UnidadDeCompilacion2(){
  50.  
  51. // No se puede! Son 'inline' en otra unidad de compilación
  52. //Func4_MostrarCadenas1();
  53. //Func5_MostrarMensajes1();
  54. }
  55.  
  56. ////////////////////////////////////////////////////////////////////////////////////////////////
  57.  
  58. extern void Test3_UnidadDeCompilacion2(){
  59.  
  60. Func13_Argumentos();
  61. }
  62.  

inclusiones.h
Código
  1. //
  2. // By 85
  3. // elhacker.net
  4. // etalking.com.ar
  5. // boyscout_etk@hotmail.com
  6. // 2013
  7. //
  8.  
  9. ////////////////////////////////////////////////////////////////////////////////////////////////
  10.  
  11. #pragma once
  12.  
  13. ////////////////////////////////////////////////////////////////////////////////////////////////
  14. // En el archivo de inclusión no se especifica la clase de almacenamiento.
  15.  
  16. int Func1_StringCompare(char* q, char* a);
  17. unsigned int Func2_StringLength(const char* f);
  18. void Func3_StripReturn(char* str);
  19. void inline Func4_MostrarCadenas1();
  20. inline void Func5_MostrarMensajes1();
  21.  
  22.  


CODE
http://www.mediafire.com/?mzuaz5zxtttazut


« Última modificación: 26 Marzo 2013, 23:48 pm por 85 » En línea

Me cerraron el Windows Live Spaces, entonces me creé un WordPress XD
http://etkboyscout.wordpress.com/
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
clases de almacenamiento
Programación C/C++
ryan parker 3 5,533 Último mensaje 2 Marzo 2011, 09:16 am
por Eternal Idol
Mysql, almacenamiento.. ?
Desarrollo Web
<<<-Basura->>> 3 2,496 Último mensaje 3 Abril 2012, 07:46 am
por <<<-Basura->>>
consumo de almacenamiento
Bases de Datos
jamescua 3 1,883 Último mensaje 1 Febrero 2013, 20:27 pm
por Shell Root
Almacenamiento
Hardware
Villano883 3 1,245 Último mensaje 22 Enero 2022, 15:02 pm
por Tachikomaia
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines