//
// By 85
// elhacker.net
// etalking.com.ar
// boyscout_etk@hotmail.com
// 2013
//
////////////////////////////////////////////////////////////////////////////////////////////////
#include<windows.h>
#include<stdio.h>
#include "inclusiones.h"
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
char* palabra[] = { "Hola", "Mi", "Nombre", "Es", "David", "Y", "El", "Tuyo?" };
char* msgList[] = {
"HAHAHA",
"HOHOHO",
"HUHUHU",
0
};
char* cadenaCortada = "Hola\nMe\nDices\nTu\nNombre\n?\0";
////////////////////////////////////////////////////////////////////////////////////////////////
extern int variable1;
extern int variable2 = 0;
int variable3 = 0;// Es extern por defecto!, aunque no se especifique
extern char cadena1[] = "AAAAAAAAAAAAAAA";
extern char cadena2[] = "AAAAAAAAAAAAAAA";
char cadena3[] = "BBBBBBBBBBBBBBB";
static int x;
static int y = 0;
////////////////////////////////////////////////////////////////////////////////////////////////
// MAL! (Revisar los conceptos de cada clase de almacenamiento)
//auto int varmal1;
//auto int varmal2=0;
//register int varmal3;
//register int varmal4=0;
////////////////////////////////////////////////////////////////////////////////////////////////
//Mutable sólo puede ser aplicada a miembros de clases
//Sirve para que determinados miembros de un objeto de una estructura o
//clase declarado como constante, puedan ser modificados.
////////////////////////////////////////////////////////////////////////////////////////////////
//Volatile se usa con objetos que pueden ser modificados desde el exterior del programa,
//mediante procesos externos.
//Es frecuente encontrar juntos los modificadores volatile y const:
//si la variable se modifica por un proceso externo, no tiene mucho sentido que el
//programa la modifique.
volatile int varilo1;
volatile int varilo2 = 0;
volatile int ilvolo1 = 10;
//int* p_ilvolo1 = &ilvolo1;// MAL!
volatile int* p_ilvolo1 = &ilvolo1;
////////////////////////////////////////////////////////////////////////////////////////////////
// HACK
// El hack consiste en guardar las direcciones de las funciones 'static' y usar
// punteros a función en las otras unidades de compilación.
// De esa forma, el compilador no lo restringe.
DWORD add_Func1_StringCompare = (DWORD)&Func1_StringCompare;
DWORD add_Func2_StringLength = (DWORD)&Func2_StringLength;
DWORD add_Func3_StripReturn = (DWORD)&Func3_StripReturn;
////////////////////////////////////////////////////////////////////////////////////////////////
static int Func1_StringCompare(char* q, char* a)
{
do
{
if( *q!=*a )
return -1;
if( !*q )
break;
q++;
a++;
} while( *q );
return 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////
static unsigned int Func2_StringLength(const char* f){
INT i=0;
while(*f++) i++;
return i;
}
////////////////////////////////////////////////////////////////////////////////////////////////
static void Func3_StripReturn(char* str)
{
for(register unsigned int i=0;i<strlen(str);i++)
if (str[i]==10 || str[i]==13) {
str[i]=' ';
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////////////
void inline Func4_MostrarCadenas1(){// Inline es sólo para funciones
for(int i=0; i<(sizeof(palabra)/sizeof(palabra[0])); ++i)
{
printf("%d = %s\n", i, palabra[i]);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
inline void Func5_MostrarMensajes1(){// Inline es sólo para funciones
for(char** i = msgList; *i; i++)
{
MessageBox(0, *i, *i, 0);
}
}
////////////////////////////////////////////////////////////////////////////////////////////////
extern void Func6_getRAM(char* buf){
MEMORYSTATUS Status;
ZeroMemory(&Status, sizeof(Status));
Status.dwLength = sizeof(Status);
GlobalMemoryStatus(&Status);
DWORD dwRAM = (DWORD)(Status.dwTotalPhys/(1024*1024));
wsprintf(buf, "%d MB", dwRAM);
}
////////////////////////////////////////////////////////////////////////////////////////////////
void Func7_Variables1(){
// Valores de inicio y lugar de almacenamiento de las variables
//
putchar(10);
int var1;
int var2 = 0;
static int var3;
static int var4 = 0;
volatile int var5;
volatile int var6=0;
printf("variable local sin inicializar: %d\n", var1);
printf("variable local inicializada: %d\n", var2);
printf("variable local static sin asignar: %d\n", var3);
printf("variable local static asignada: %d\n", var4);
printf("variable local volatile sin asignar: %d\n", var5);
printf("variable local volatile asignada: %d\n", var6);
// printf("variable global sin asignar: %d\n", variable1);
printf("variable global asignada. %d\n", variable2);
printf("variable global asignada: %d\n", variable3);
printf("variable global static sin asignar: %d\n", x);
printf("variable global static asignada: %d\n", y);
printf("variable global volatile sin asignar: %d\n", varilo1);
printf("variable global volatile asignada: %d\n", varilo2);
printf("add variable local sin inicializar: 0x%X\n", &var1);
printf("add variable local inicializada: 0x%X\n", &var2);
printf("add variable local static sin asignar: 0x%X\n", &var3);
printf("add variable local static asignada: 0x%X\n", &var4);
printf("add variable local volatile sin asignar: 0x%X\n", &var5);
printf("add variable local volatile asignada: 0x%X\n", &var6);
// printf("add variable global sin asignar: 0x%X\n", &variable1);
printf("add variable global asignada. 0x%X\n", &variable2);
printf("add variable global asignada: 0x%X\n", &variable3);
printf("add variable global static sin asignar: 0x%X\n", &x);
printf("add variable global static asignada: 0x%X\n", &y);
printf("add variable global volatile sin asignar: 0x%X\n", &varilo1);
printf("add variable global volatile asignada: 0x%X\n", &varilo2);
// El problema con la variable1 es que al haber usado 'extern' y no haberle
// hecho una asignación de valor. el compilador entiende que se hace referencia
// a una variable que está declarada en otra unidad de compilación.
}
////////////////////////////////////////////////////////////////////////////////////////////////
void Func8_Variables2(){
// Valores de inicio y lugar de almacenamiento de las variables
//
putchar(10);
// Se crean y destruyen automáticamente (no se necesita especificar)
auto int varbien1;
auto int varbien2=0;
// Si es posible, se van a almacenar en algún registro del CPU para tener
// un acceso más rápido a ellas. (Tamaño adecuado para entrar en un registro!)
register int varbien3;
register int varbien4=0;
printf("variable local auto sin asignar: %d\n", varbien1);
printf("variable local auto asignada: %d\n", varbien2);
printf("variable local register sin asignar: %d\n", varbien3);
printf("variable local register asignada: %d\n", varbien4);
auto int var1 = 85;
auto int var2 = var1;
printf("var1: %d add: 0x%X\n", var1, &var1);
printf("var2: %d add: 0x%X\n", var2, &var2);
register int var3 = 85;
// Si estubiera en un registro no se obtendría una dirección de memoria!
printf("var3: %d add: 0x%X\n", var3, &var3);
register int i;
// register int i=0;
for(i=1; i<=10; i++){
if(i==1) printf("add i: 0x%X\n",&i);
printf("%d",i);
}
putchar(10);
}
////////////////////////////////////////////////////////////////////////////////////////////////
static void Func9_dummy1(register int* x){
printf("x: %d add: 0x%X\n", *x, &x);
}
////////////////////////////////////////////////////////////////////////////////////////////////
static void Func10_dummy2(register int y){
printf("y: %d add: 0x%X\n", y, &y);
}
////////////////////////////////////////////////////////////////////////////////////////////////
static void Func11_dummy3(volatile int z){
printf("z: %d add: 0x%X\n", z, &z);
}
////////////////////////////////////////////////////////////////////////////////////////////////
// Retorna un INT volatile, sólo se aplica al tipo de retorno.
volatile int Func12_dummy4(int arg){
int res = arg;
return res;
}
////////////////////////////////////////////////////////////////////////////////////////////////
void Func13_Argumentos(){
putchar(10);
int a = 500;
Func9_dummy1(&a);
int b = 1000;
Func10_dummy2(b);
int c = 5000;
Func10_dummy2(c);
int d = 100000;
Func11_dummy3(d);
int e = Func12_dummy4(15);
printf("%d\n", e);
}
////////////////////////////////////////////////////////////////////////////////////////////////
int main(){
Func4_MostrarCadenas1();
Func5_MostrarMensajes1();
// Cualquiera de las 2 formas (con o sin extern, es lo mismo)
extern void Test1_UnidadDeCompilacion1();
extern void Test2_UnidadDeCompilacion1();
extern void Test3_UnidadDeCompilacion1();
extern void Test1_UnidadDeCompilacion2();
extern void Test2_UnidadDeCompilacion2();
void Test3_UnidadDeCompilacion2();
Test1_UnidadDeCompilacion1();
Test2_UnidadDeCompilacion1();
Test3_UnidadDeCompilacion1();
Test1_UnidadDeCompilacion2();
Test2_UnidadDeCompilacion2();
Test3_UnidadDeCompilacion2();
Func8_Variables2();
Func3_StripReturn(cadenaCortada);
printf("%s\n",cadenaCortada);
system("pause");
return (0);
}