Intercambiando Punteros entre Visual Basic 6 y Borland C++

Otro tutorial de los viejitos, de casi veinte años atrás, así que sirve como documento histórico :D

Ya que hemos podido pasar un parámetro desde una aplicación en Visual Basic a una Dll compilada con Borland C++ y devolver a Visual Basic el resultado calculado desde la Dll, lo que hace falta ahora es hacer lo mismo con arrays. 
No se puede enviar todo un vector desde Visual Basic a una Dll, lo que se puede hacer al operar con arrays es llamar a la función en la Dll dentro de un bucle que recorra el array en el programa de Visual Basic, pero si se desea que nuestra aplicación sea más rápida es mejor dejarle el manejo de los bucles a C++. En este caso se le enviaría a la Dll la dirección de memoria donde está el array (es decir: la dirección de su primer elemento). 

Un excelente tutorial sobre los punteros en C++ está akí: 

https://cplusplus.com/doc/tutorial/pointers/ en inglés

En contra de lo que muchos creen, Visual Basic sí maneja punteros. Más información se encuentra en esta web: http://www.thevbzone.com/secrets.htm 
Pero para este caso no se necesitan estas funciones, basta pasarle a la Dll el primer elemento del array tal y como lo explican en esta otra web: https://recursosvisualbasic.com.ar/rvb/htm/tutoriales/interaccion-visual-basic-c++.htm

Hay que tener cuidado con un par de detalles que no mencionan estas páginas y que explicaré más adelante.
En resumen, lo que se quiere es que la Dll programada en C++ reciba y devuelva un puntero. 
Para una Dll que simplemente recibe un puntero y devuelve un dato el código es:

#include <windows.h> #include "puntero.h" BOOL WINAPI DllEntryPoint(HINSTANCE, DWORD, LPVOID) {   return TRUE; } extern "C" long __declspec (dllexport) WINAPI sumatotal (long *puntero, int valor) {   long sumatoria;   sumatoria = 0;   for (int i = 0; i < valor; i++)     sumatoria= sumatoria+ puntero[i];   return sumatoria; }

Y el archivo .h es:

#ifndef _PUNTERO_H #define _PUNTERO_H #ifdef BUILD_DLL // en la construcción de la librería #define EXPORT __declspec(dllexport) #else // en la construcción del ejecutable #define EXPORT __declspec(dllimport) #endif #ifdef __cplusplus /* if in a C++ program */ extern "C" #endif long __declspec (dllexport) WINAPI sumatotal (long *puntero, int valor); #endif

Para probarlos se compilan y se copia la Dll (llamada "puntero.dll") en la carpeta System32. Luego se abre en el Visual Basic un proyecto exe estándar y se ingresa el siguiente código:

Private Sub Form_Load()   Dim c As Long, i As Integer   Dim mat() As Long   ReDim mat(0 To 5)   For i = 0 To UBound(mat)      mat(i) = 2 * i   Next   c = sumatotal(mat(0), UBound(mat) + 1)   Form1.Caption = c End Sub

Y en un módulo .bas se coloca:

Public Declare Function sumatotal Lib "puntero.dll" (ByRef puntero As Long, ByVal valor As Integer) As Long

"Byref" le dice a Visual Basic que lo que va a enviar es un puntero, no una variable.
En este ejemplo se nota la diferencia en el manejo de los índices entre Visual Basic y C++. Los índices del array "mat" son 0, 1, 2, 3, 4, 5. Si se hubiera creado en C++, para que tuviera seis elementos, se habría definido como mat[6] siendo sus índices también 0, 1, 2, 3, 4, y 5 ya que en C++ el número entre corchetes define la cantidad de elementos del array. Debido a la costumbre programé el bucle para tratar al array como si hubiera sido creado en C++, cuando en realidad es un array de Visual Basic en el cual el 5 representa el índice mayor mas no el número de elementos, por ello se le suma uno al segundo parámetro al enviarlo a la función programada en C++.
Y este es el resultado:

 
Ahora, para crear una Dll que reciba y devuelva punteros es necesario hacer unos pequeños cambios:
El archivo se llama "puntero2.cpp" y su código fuente es:

#include <windows.h> #include "puntero2.h" BOOL WINAPI DllEntryPoint(HINSTANCE, DWORD, LPVOID) {      return TRUE; } extern "C" long* __declspec (dllexport) WINAPI punt (long *puntero, int valor) {     for (int j=1; j<=valor+1; j++)         puntero[j]=puntero[j]*2-15;     return(puntero); }

"valor" es el tamaño del array cuya dirección está recibiendo la función "punt" la cual, después de ejecutar el bucle, devuelve un puntero. 
Para hacer la Dll también se necesita el archivo "puntero2.h" cuyo código es:

#ifndef _PUNTERO2_H #define _PUNTERO2_H #ifdef BUILD_DLL // en la construcción de la librería #define EXPORT __declspec(dllexport) #else // en la construcción del ejecutable #define EXPORT __declspec(dllimport) #endif #ifdef __cplusplus /* if in a C++ program */ extern "C" #endif long* __declspec (dllexport) WINAPI punt (long *puntero, int valor); #endif

Nótese que la función se declara con el asterisco junto al tipo de datos al que apunta el puntero, C++ permite en teoría poner el asterisco al comienzo del nombre de la función, pero al hacer esto el compilador me botaba error, así que es mejor hacerlo de este modo.
"Long" es el tipo de datos para enteros largos (de 64 bits) y lo manejan tanto C++ como Visual Basic. Lo malo es que cuando quise enviar punteros que apuntaban a datos de punto flotante el compilador del Visual Basic me botaba el error 16 en tiempo de ejecución: "Expresión demasiado compleja". Así llegué a descubrir que Visual Basic y Borland C++ sólo pueden intercambiar punteros que apunten a enteros, ya sean Long o Byte. Al trabajar con arrays no recomiendo datos del tipo Integer, al operar me salían resultados erróneos.
Después de compilar y copiar la Dll "puntero2.dll" a la carpeta system32 la probé el Visual Basic con el siguiente código, en un proyecto exe estándar:

Option Explicit Private Sub Form_Load()     Dim mat(-1 To 8) As Long     Dim i As Integer     For i = 0 To UBound(mat)         mat(i) = i     Next     mat(-1) = punt(mat(-1), UBound(mat))     For i = 0 To UBound(mat)         Debug.Print mat(i)     Next End Sub

Y colocando en el módulo .bas el siguiente código:

Declare Function punt Lib "puntero2.dll" (ByRef puntero As Long, ByVal valor As Integer) As Long

Esta vez quise ver los valores de "mat" en la ventana del inmediato (ya he fastidiado bastante el Caption del Form) y éste es el resultado:

Ya funciona :)
Ahora la gran pregunta: ¿por qué definí el array "mat" desde -1 y no desde 0? Visual Basic tiene la ventaja de poder definir arrays con índices negativos, cosa que no se puede en C++. El índice -1 terminará conteniendo la dirección de memoria del array, un valor que no interesa a la hora de operar y con el que es mejor no trabajar. El índice -1 en Visual Basic pasará a ser el índice 0 en C++, así el índice 0 para Visual Basic será el índice 1 en C++, etc. Para Visual Basic los índices van de -1 a 8 en este ejemplo, para C++ van de 0 a 9 (la cantidad de elementos del array es 10 en total), donde el valor en el índice 0 no interesa, y no se debe operar con él pues al devolver el puntero al Visual Basic éste "chanca" el primer elemento del array con su dirección de memoria.
Al modificar el bucle del programita en Visual Basic que escribe en la ventana inmediato para que vaya desde -1 se podrá ver el valor de mat(-1):

He aquí a los diez elementos del array
 
Una manera de poder operar con valores de punto flotante es convirtiendo estos valores enteros multiplicándolos por 10^n, donde "n" es la cantidad de decimales con la que vamos a trabajar.
Por ejemplo, queremos una Dll que calcule las raíces cuadradas de algunos números dentro de un vector:
La nueva Dll será "puntero3.dll" y el código fuente de puntero3.h es:

#ifndef _PUNTERO3_H #define _PUNTERO3_H #ifdef BUILD_DLL // en la construcción de la librería #define EXPORT __declspec(dllexport) #else // en la construcción del ejecutable #define EXPORT __declspec(dllimport) #endif #ifdef __cplusplus /* if in a C++ program */ extern "C" #endif long* __declspec (dllexport) WINAPI cuadrado (long *puntero, int valor, long d); #endif

Y el de "puntero3.cpp":

#include <windows.h> #include <math.h> #include "puntero3.h" BOOL WINAPI DllEntryPoint(HINSTANCE, DWORD, LPVOID) {     return TRUE; } extern "C" long* __declspec (dllexport) WINAPI cuadrado (long *puntero, int valor, long d) {     double *c;     c= new double[valor+1];     for (int j=1; j<=valor+1; j++){         c[j-1]= double(puntero[j])/d;         c[j-1]=pow(c[j-1], 0.5);         puntero[j]= long(c[j-1]*d);     }     return(puntero); }

La variable "d" es el 10^n con el que se trabajará. Aquí hay que tener cuidado de "castear" los arrays de Double a Long y viceversa o sólo nos resultarán ceros.
Y ahora el código fuente del programa en Visual Basic, primero el módulo .bas (todo es una sola línea):

Declare Function cuadrado Lib "puntero3.dll" (ByRef puntero As Long, ByVal valor As Integer, ByVal d As Long) As Long

Y lo que va en el formulario:

Private Sub Form_Load()     Dim mat() As Double     Dim matl() As Long     Dim divisor As Long     ReDim mat(-1 To 4)     ReDim matl(-1 To 4)     divisor = 100000000     For i = 0 To UBound(mat)         mat(i) = (i + 1) / 25         mat(i) = mat(i) * divisor         matl(i) = CLng(mat(i))         Debug.Print mat(i) / divisor     Next     matl(-1) = cuadrado(matl(-1), UBound(matl), divisor)     For i = 0 To UBound(mat)         mat(i) = matl(i) / divisor         Debug.Print mat(i)     Next End Sub

Y el resultado es éste:

Los cinco primeros números son los datos originales, y los otros cinco sus raíces cuadradas hasta ocho decimales de aproximación.
Éste es un mal ejemplo sobre cómo usar una Dll para hacer cálculos numéricos ya que sería mejor sacar las raíces cuadradas directamente con el Visual Basic y usando solamente el array "mat" declarado como Double, pero deja entender cómo se debe manejar los datos para poder operar con números de punto flotante a partir de enteros. Si se trata de números muy grandes y con muchos decimales se pueden poner la parte entera y la decimal en variables separadas, dividir luego en la Dll la parte decimal entre 10^n y sumar ambas variables. Una Dll es útil cuando se requieren cálculos complejos o comandos que el programa principal realizaría más lentamente, con arrays mucho más largos (se declaran los punteros como "far" tanto en el archivo .cpp y el .h) y todas esas cosillas para las que el Visual Basic se vuelve lentecillo (considerando el hardware de inicios de los 2000s)

Tutorial MUY viejito: Usando el Puerto Serial Con Visual Basic 6 y Visual C Sharp 2005

Motivo de poner algo tan viejo acá:: lo tenía tirado en mi disco duro, es todo un documento histórico. 

Antes de empezar con este tutorial recomiendo leer: http://www.lammertbies.nl/comm/info/RS-232_null_modem.html porque puede pasar que no se sepa de qué estoy hablando (que es lo más seguro, este tutorial ya tiene veinte años).

Manejo del Puerto Serie: Visual Basic 6

Manejar el puerto serie en VB6 es bastante sencillo con el control MSCOMM. 
Es posible controlar por separado las líneas RTS y DTR por si se las desea manipular independientemente al envío y recepción de datos. Para ello la propiedad de Handshaking debe estar en "none".
En este link: https://www.frro.utn.edu.ar/repositorio/catedras/electrica/2_anio/fundamentos_informatica/apuntes/visual_basic/Manejo%20Puertos.pdf (warning: tecnología antigua) da toda la teoría necesaria para tener un control total del puerto serie con VB6, especialmente el manejo de eventos. Los eventos le dicen al MSCOMM si ha habido algún cambio en el puerto; el tipo de evento es recibido por la propiedad CommEvent y según su valor se puede saber qué ha ocurrido (qué pin ha cambiado su estado). Para esto, la evaluación de CommEvent se hace dentro de OnComm del control MSCOMM (en realidad es el único evento que tiene este control).

Para leer caracteres correctamente en una aplicación tipo chat, es mejor dejar la propiedad RThreshold en 1. Así el evento de lectura se disparará cada vez que se reciba un caracter.

Y aquí http://uttinfor.tripod.com/index/id4.html explican las propiedades del MSCOMM.

Aquí se puede descargar mi programa y el código fuente de ejemplo que envía y recibe datos de texto, activa y desactiva las señales RTS y DTR (manipulando las propiedades RTSEnable y DTREnable respectivamente), y evalúa el estado de las líneas CD, DSR y CTS, así como si el puerto puede o no abrirse (en el caso que ya esté abierto por otro programa).

 

Manejo del Puerto Serie: C Sharp 2005

Acá las cosas son un poco más complicadas. Puede optarse por usar el ocx de Visual Basic MSCOMM eligiendo el respectivo componente .com al hacer click sobre el cuadro de herramientas->Elegir Elementos. Pero entonces no tendría sentido hacerlo desde C Sharp en lugar del mismo Visual Basic 6. En este ejemplo he querido usar la plataforma .Net para controlar el puerto serial.

Primero se debe añadir la línea:
using System.IO.Ports; 

Luego, desde en el cuadro de herramientas buscar "serialPort" y jalar este componente a nuestra aplicación (que será del tipo WindowsApplication).

El problema con C Sharp es que la recepción de datos no puede hacerse de manera tan directa como con Visual Basic 6. El evento que detecta que se ha recibido data no puede tratarse igual. 
Debe hacerse tal y como lo muestran en la página 176 de este documento: http://www.slideshare.net/Metaconta/pic-rs232-puerto-serie-con-pic16f84a-presentation 

Yo lo hice exactamente como se indica ahí y me salió :) 

Otro problema que tuve fue el no poder cambiar las propiedades de los controles (como Labels o PictureBox) tan libremente como en VB6. El C Sharp dispara una excepción cada vez que se intenta cambiar las propiedades de los controles en tiempo de ejecución como protección en un entorno multitarea. Para desactivar esta excepción puse en Form1_Load (de la documentación de Microsoft):
CheckForIllegalCrossThreadCalls = false;

Así ya se puede cambiar ciertas cositas en los controles que son necesarias, como se verá más adelante.

Para enviar data del tipo texto, basta la instrucción:
serialPort1.Write(txtEnviar.Text);

Donde txtEnviar es un RichTextBox que contiene el texto a enviar por el puerto.

Para recibir la data se llama a la propiedad: serialPort1.ReadExisting(); que lee todo el buffer de lectura del puerto.

Tuve algunos problemas con el salto de línea a la hora de recibir los datos. Para corregirlos, y hacer que después de enviar el texto salte a la siguiente línea de forma automática en el RichText que recibe los datos, tuve que añadir el caracter 13 (el salto) al texto en txtEnviar y recién enviar la data. Luego restablecía el texto original en txtEnviar sin el caracter 13 al final. Para esto usé la variable data_temp.

La diferencia con Visual Basic, es que C Sharp, a la hora de abrir el puerto, manda las señales CD, DSR y CTS a "true" ó 1. Si se desea usar estas líneas para recibir señales y disparar el evento que detecta cambios en ellas se debe trabajar con la lógica invertida. Es decir que el dispositivo que nos envía esas señales debe usar lógica invertida también.

En cambio si se desea enviar las señales de control RTS y DTR, la lógica de trabajo dependerá de cómo las interprete el dispositivo que las recibe (esto es válido también para VB6). Para este caso, también consideré lógica invertida para las señales RTS y DTR. 1 es desactivado, 0 es activado.
Así, en el control serialPort se colocan sus propiedades RtsEnable y DtrEnable como "true" para que tengan estos valores al iniciar la aplicación. Si se desea activar, su estado pasará a "false".

Para controlar los eventos, o los cambios en las líneas de entrada del puerto serial, me basé en esté código:

Imports System.IO.Ports Public Class Form1     Private WithEvents mPort As SerialPort     Private Sub Form1_Load(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles MyBase.Load         mPort = New SerialPort("COM1", 9600)         mPort.Open()     End Sub Private Sub mPort_PinChanged(ByVal sender As Object, ByVal e As System.IO.Ports.SerialPinChangedEventArgs) Handles mPort.PinChanged         If e.EventType = SerialPinChange.CDChanged Then             If mPort.CDHolding Then                 Debug.Print("Carrier detect on")             Else                 Debug.Print("Carrier detect off")             End If         End If     End Sub End Class

Fuente: http://social.msdn.microsoft.com/Forums/en-US/netfxbcl/thread/ffbb63a1-5a04-46c9-a71a-f52b6f7ada81/ (el enlace ya no existe)

Está hecho para Visual Basic 2005 así que tuve que "traducirlo" a C Sharp y adaptarlo para que reconociera los eventos que me interesaban. La lógica es la misma que con VB6: con un "switch" evaluar qué evento ha ocurrido según el valor de la propiedad que los recibe. En C Sharp es e.EventType y se evalúa versus las propiedades de serialPort CDChanged, CtsChanged y DsrChanged. Estas propiedades sólo saben si hubo un cambio en las señales CD, CTS y DSR, no conocen sus estados (para saber los estados se usan otras propiedades que se explican más abajo).

Ambos programas, el de VB6 y C Sharp funcionan igual y hacen lo mismo. La única diferencia es que el de C Sharp emplea lógica invertida. 

El código fuente y el programa en C Sharp se puede bajar aquí.

Si los "leds" que indican el estado de las señales CD, DSR y CTS en VB6 son controles tipo "Shape", en C Sharp usé controles Picturebox. Dibujar un círculo y un cuadrado en C Sharp es muy engorroso, llegué a crear una clase para ello, pero cuando quería dibujar dos círculos, al final el programa me los dibujaba uno encima de otro sin importar lo que hiciera para evitarlo. Creé dos propiedades para pasarle el valor de las coordenadas, pero igual no funcionó. Haciendo puntos de quiebre descubrí que el C Sharp primero asigna los valores a las variables con los valores de las coordenadas y luego dibuja todo lo que se le pide, usando sólo los valores finales de estas variables. Después de mucho tratar decidí no dibujar nada. Para quienes quieran intentar hallarle una solución, les dejo la clase:

using System; using System.Collections.Generic; using System.Text; using System.Drawing; using System.Drawing.Drawing2D; using System.Windows.Forms; namespace WindowsApplication1 {     /* en el programa principal crear un objeto.     Shapes cuad = new Shapes();     Estado.Paint += new PaintEventHandler(cuad.Shapes_Fill);     Estado.Paint += new PaintEventHandler(cuad.Shapes_Paint);      */     class Shapes     {         private Graphics g;         private int _coorX;         private int _coorY;         public Shapes()         {             _coorX = 30;              _coorY = 30; //sólo para inicializarlas         }         public int coorX         {             get { return _coorX; }             set { _coorX = value; }         }         public int coorY         {             get { return _coorY; }             set { _coorY = value; }         }         public void Shapes_Paint(object sender, System.Windows.Forms.PaintEventArgs e)         {              g = e.Graphics;             Pen p = new Pen(Color.Black,2) ;             g.DrawEllipse(p, 30, 30 , 30, 30);          }         public void Shapes_Fill(object sender, System.Windows.Forms.PaintEventArgs e)          {              g = e.Graphics;             Pen p = new Pen(Color.Black, 2);             //g.DrawEllipse(p, _coorX , _coorY, 30, 30);              g.FillEllipse(Brushes.Firebrick, 30, 80, 30, 30);          }     } }

Al final preferí usar tres picturebox para los "leds" de estado de CD, DRS y CTS, así simplemente cambiaba su color según el estado de estas líneas (para poder hacer esto tuve que poner a "false" la propiedad CheckForIllegalCrossThreadCalls mencionada más arriba). Estos estados se obtienen evaluando las propiedades de serialPort CDHolding, DsrHolding y CtsHolding respectivamente (estas propiedades son las mismas que en VB6).

Otra diferencia que hallé es que si se deja la línea CD sin conexión, VB6 no le hace nada, pero C Sharp la manda a cero al enviar data. Como está sin conectar no hay forma de ponerla a uno nuevamente.

Ambos programas los probé con el test de Loop Back puenteando los puntos 7-8-1, 4-6 y 2-3. Cualquiera de los dos ejecutables pueden usarse como programas independientes para probar el puerto serie. En el caso del C Sharp, el ejecutable está en \WindowsApplication1\

Tutorial viejito: Creando una dll en Borland C++ para luego usarla en Visual Basic 6

 Otro tutorial de los viejitos, de hace casi 20 años! Enjoy!

Visual Basic es un lenguaje de programación con claras ventajas: Es fácil y rápido de programar, cuenta con abundante documentación, recursos y herramientas gratuitos botados por toda la Internet, permite redimensionar arrays, jalar datos desde archivos en Office, se lleva bien con las Apis, etc, etc. 

Pero también tiene sus desventajas: sus aplicaciones tienden a ser un tanto más lentas y pesadas que las programadas en otros lenguajes, depende de librerías que no todo el mundo tiene, es un compilador propietario de Microsoft, no maneja sentencias en asm, no permite declarar variables binarias tipo word o byte y manipularlas bit por bit, etc, etc.  

Es decir: todas esas cosas que tiene el lenguaje C++ pero que le faltan al Visual Basic. No digo que uno sea mejor que el otro, sino que uno tiene lo que al otro le falta. Si tuviera que elegir, haría las GUIs de mis programas en Visual, pero la parte del manejo de arrays, bucles, cálculo matemático, lectura/escritura en el puerto paralelo, entre otras cosas más, se lo dejaría al C++. Al Visual Basic le dejaría las Apis y el puerto serial, además de intercambiar datos con archivos de Office o leer imágenes desde el disco duro. 

En realidad, existe una manera de combinar las bondades de ambos lenguajes: hacer las GUIs del programa en Visual Basic y ordenarle que jale las funciones que necesita desde Dlls hechas y compiladas en C++. El uso de Dlls tiene claras ventajas: si todo el código está metido en un exe éste será más pesado y, a la hora de ejecutarlo, se cargará todo en la memoria RAM. Pero si hace llamadas a Dlls, éstas sólo se cargarán en la RAM en el momento de ser usadas, lo cual liberará espacio en memoria y hará que el programa corra más rápido.  

1. Cómo hacer la Dll:

Primero hay que bajar el compilador gratuito que ofrece Borland.  Incluye un ide, pero este tutorial está hecho para la versión original sin ide. La carpeta Borland se debe copiar a la partición C:, por lo que la ruta del ejecutable que realiza la compilación (el bcc32.exe) queda en C:\Borland\BCC55\Bin\.

Luego se debe ir a la carpeta C:\Borland\BCC55\Lib\ y copiar todos los archivos (excepto la carpeta PSDK) a la carpeta Bin, donde está bcc32.exe. Esto es porque a la hora de compilar, el compilador busca los archivos obj de la carpeta Lib, si no los copiamos a la misma carpeta donde está bcc32.exe nos botará error. 

En la misma carpeta Bin, desde el block de notas, se debe crear el archivo que será nuestra Dll, debe tener extensión cpp y el nombre que llevará la dll. Yo la llamaré inicio.cpp. El código es:

// inicio.cpp #include <windows.h> #include "inicio.h" BOOL WINAPI DllEntryPoint(HINSTANCE, DWORD, LPVOID) { return TRUE; } extern "C" int __declspec (dllexport) WINAPI suma (int a, int b) { return a+ b; }

La primera función WINAPI es "el puntero de entrada" que necesita Visual Basic para poder usar la Dll. Borland C++ permite declarar esta función como "BOOL WINAPI dllMain(HINSTANCE, DWORD, LPVOID)", pero en este caso Visual Basic generará error al no hallar el puntero de entrada. (Hay que notar que no existe una función main o winMain en la dll)

De la forma que sea, esta función DllEntryPoint deberá retornar siempre el valor de TRUE o se generará error.  

La siguiente función es la que programé y hace una simple sumatoria de dos enteros. La sintaxis en general es:

extern "C" tipo __declspec (dllexport) WINAPI nombre_funcion (argumentos) { ... }

Hay que observar que antes de "declspec" pueden ir uno o dos guiones largos. 

Se debe notar que el archivo "inicio.cpp" también llama a un archivo "inicio.h", para crear la dll ambos son necesarios. El código de "inicio.h" es:

#ifndef _INICIO_H #define _INICIO_H #ifdef BUILD_DLL // en la construcción de la librería #define EXPORT __declspec(dllexport) #else // en la construcción del ejecutable #define EXPORT __declspec(dllimport) #endif #ifdef __cplusplus /* if in a C++ program */ extern "C" #endif int __declspec(dllexport) WINAPI suma(int a, int b); #endif

Lo importante aquí está en la penúltima línea de código: la declaración de la función que se "exporta" desde la dll y que devolverá los valores al programa principal. 

La Compilación:

Ambos archivos, "inicio.cpp" e "inicio.h" deberán estar en la misma carpeta donde está el ejecutable compilador, la carpeta deberá tener estos archivos:

Luego se va a Inicio->Ejecutar->cmd (para windows 2000 hacia arriba, para windows 98 es Inicio->Ejecutar->Command), nos situamos en la carpeta del compilador y se ingresa el siguiente comando (va todo seguido):

El compilador necesita varios parámetros para hacer lo que queremos, ahora los voy a explicar:

"-einicio": todo lo que va después de "-e" y sin espacios, será el nombre de la dll.

-Q: Es para que nos dé la información de la compilación y si se generó algún error.

-I: este comando, seguido de una ruta o varias rutas separadas por punto y coma sin espacios, le indica al compilador dónde buscar las cabeceras que se están usando. Como "windows.h" está en la carpeta Include, debemos decirle que busque allí o botará error. 

-WD: es el comando para generar una dll y no un exe. 

Después de todo esto, le decimos qué archivo se quiere compilar.

Para más información, recomiendo revisar el archivo de ayuda que viene con el compilador y que está en la carpeta Help.

Si todo sale bien, deberá aparecer:

Después de esto, la dll deberá aparecer en la carpeta donde tenemos los archivos "inicio¡.cpp" e "inicio.h" con el nombre de "inicio.dll". Esta dll ya podemos copiarla a donde la necesitemos para poder usarla (se recomienda ponerla en la carpeta system32).

 

Probando la dll:

Abrimos el visual con un proyecto Exe Estándar. Le añadimos un módulo .bas nuevo y le ponemos este código:

Public Declare Function suma Lib "inicio.dll" (ByVal a As Integer, ByVal b As Integer) As Integer

Dentro de la Dll está la función "suma" (pueden ser varias funciones, entonces tenemos que jalarlas una por una), con los dos argumentos tipo Entero. La función devuelve un entero, por ello se la declara "As Integer". Si la función en C++ fuera del tipo "void" no se pone al final el tipo de dato pues no devuelve ningún valor (incluso en algunas webs vi que las funciones tipo "void" de C++ eran llamadas como "Sub" en lugar de "Function" desde Visual Basic, pero esto no lo he probado).

En el formulario, el único código que puse para probar si devolvía un valor correcto fue:

Private Sub Form_Load()     Dim c As Integer     c = suma(8, 4)     Form1.Caption = c End Sub

Y lo que salió fue:

Ya funciona :)

Y ahora, una web donde explican un poco más esto de las Dlls generadas con el Borland C++:

http://www.zator.com/Cpp/E1_4_4b2a.htm

Entrada antigua: Acerca de la Recursividad

Este es un artículo que escribí en mi vieja web allá por los dosmiles (¿2007?) y me ha traído nostalgia: es de cuando batallaba intentando entender la recursividad.

Se me hace curioso leerme después de tantos años, He recordado cuando, debugueando, intentaba infructuosamente entender línea por línea cómo iba eso de la recursividad, y de cómo sabía el procesador, la máquina virtual o el runtime, cómo volver a llamar a la función para llegar a la respuesta correcta.

He terminado sonriendo, pues éste fue el inicio de lo que luego sería esto: http://programacionamartillazos.blogspot.com/2023/06/cuadrados-recursivos-con-la-tortuga-de.html

o ésto: https://programacionamartillazos.blogspot.com/2016/01/listar-los-archivo-en-una-carpeta-y-sus.html

Aquí el artículo, Enjoy!

 

"Para entender la recursividad, primero hay que entender la recursividad"

 

En mis ratos libres me gusta leer blogs sobre programación. Así me topé con http://www.variablenotfound.com/2007/02/dnde-se-han-ido-los-programadores.html y con http://www.codinghorror.com/blog/archives/000781.html donde dice "If you can successfully write a loop that goes from 1 to 10 in every language on your resume, can do simple arithmetic without a calculator, and can use recursion to solve a real problem, you’re already ahead of the pack!".

Entonces me faltaba la recursión o recursividad. Ya había leído sobre ella antes, incluso bajado tutoriales, pero mi error fue intentar entenderla.
Como es una función que se llama a sí misma, no hay por dónde "cogerla", lógicamente es algo autocontenido y que debería generar un bucle infinito:

El límite, o parada, sucede cuando "i" llega a 10. Si "i" es igual o mayor a 10 (partiendo de un valor inferior), simplemente sale de la función y retorna el resultado de la suma total. No se debe perder tiempo intentando entender la recursión basta saberla usar. Si se intenta entender o hallar la secuencia lógica de la función de arriba no se llegará a ninguna parte. La variable "i" recibe la respuesta de una función donde está la propia variable "i" (y lo peor: en este caso la operación que debe realizar la función sumaR está donde recibe los parámetros).

¿hay alguna manera de escapar de este bucle infernal?
Sí, en el momento en que "i" llega al valor donde se debe retornar cero (ya no se llama a la función sumaR).

Recién llegué a comprender la recursión cuando dejé de intentar comprenderla. Suena raro, pero así fue.

Tutorial viejito: Un Par de Trucos al hacer Guis en Matlab 7

Este tutorial data de mis años de estudiante hace casi dos décadas atrás, enjoy!

Matlab 7 permite poner imágenes en las ventanas hechas con la herramienta Guide, aunque no directamente pues no posee un control Picture o Image como en Visual Basic o C++ Builder. Lo malo es que los archivos de Ayuda de Matlab no explican cómo poner una imagen a una ventana (y si lo hacen yo no pude encontrar dónde), después de una tarde de examinar y diseccionar el Matlab descubrí la manera de hacerlo.

Y aquí viene lo que quiero explicar:

 
CÓMO PONER UNA IMAGEN EN UNA INTERFAZ GRÁFICA

Primero la imagen que queremos colocar en la ventana debe estar en formato BMP y en la misma carpeta donde se guardarán los archivos de la Interfaz Gráfica (el *.fig y el *.m).

Luego se debe crear una ventana en blanco, esto se hace escribiendo "Guide" en la ventana de comandos y presionando enter, entonces se abrirá la siguiente ventana:

Elegimos "Blank GUI" con lo que se abrirá esta ventana:

Después se jala un control Axes (el botón con la curva azul):

Mi ventana la he guardado como "unt1.fig" lo cual genera un archivo "unt1.m", ahora nos vamos para allá. Lo que debemos buscar es la función OpeningFcn que se activa apenas se abre la ventana:

Para el Matlab la ventana tiene por defecto el nombre de "figure1" y el Axes el de "axes1". Estos nombres pueden cambiarse, pero en este caso los vamos a usar así como están.

Lo que debe hacerse es añadir el siguiente código (no hay que hacerle caso a lo que está en verde, son comentarios y pueden borrarse):

Lo que hace este código es cargar la imagen (cuyo nombre es "dsp.bmp") a una matriz con la función "imread", por precaución se cambia a formato entero de 8 bits (aunque una imagen en BMP ya está en este formato).

La tercera línea hace que la imagen dependa de axes1. Las siguientes dos líneas son para configurar axes1: la propiedad "Visible" debe estar en "off" o de otro modo se verán los ejes coordenados a los costados de la imagen.

Lo demás es para que la imagen tenga el mismo tamaño que axes1. Los tres puntos simplemente son para indicarle al Matlab que la función continúa en la siguiente línea.

Al correr nuestra ventana debe verse así:

El ancho y alto de la imagen puede variarse variando el ancho y alto de axes1.

 

CÓMO HACER LA PARTE MÁS OSCURA PARA EL TÍTULO:

Para esto se deben jalar un control tipo "panel" y uno tipo "static text". A ambos se les da click derecho y se escoge "Send to back", lo cual los pondrá detrás de la imagen y no la taparán:

Al hacer doble click sobre cualquiera de ellos aparecerá la ventana de propiedades con las respectivas propiedades que pueden usarse para cada control. Por ejemplo, el panel y el texto estático tienen una propiedad llamada "BackgroundColor", la cual no tiene figure1, pero ésta posee la propiedad "Color". Es importante saber esto, pues no todos los controles tienen las mismas propiedades.

El panel tiene por defecto el nombre de "uipanel1" y el texto estático el de "text1".

Nos volvemos a ir a la función OpeningFcn y añadimos (sí, borré los comentarios del Matlab 7):

El color de la ventana por defecto es el que le da el sistema operativo. Si queremos que la ventana tenga el color que le asigna el windows y no uno fijo, y que el recuadro donde irá el título sea un poco más oscuro, es necesario tener los valores del color asignado (son 3, para rojo, verde y azul). Estos valores se cargan a un vector llamado "cc".

Para oscurecerlo un poco se le resta un número entre 0 y 1 al vector. El valor resultante se asigna a la propiedad "BackgroundColor" de text1 y uipanel1.

El resultado es éste:

Y con otras propiedades de pantalla (en Windows 2000, este es un tutorial MUY viejo):

Se le pueden arreglar algunas propiedades, como el tamaño y color de la letra de text1 y borrar el título de uipanel1 si se desea:

(no podía dejar mi sistema con ese amarillo tan molesto!)

Resolviendo el Problema 108 de ProjectEuler.net

Otra entrada migrada de la vieja web:

Visitando la página de ProjectEuler.Net escogí intentar resolver el problema 108, el cual dice:

Hay que hallar el mínimo valor de n para el que existen al menos 1000 soluciones a la ecuación 1/x + 1/y = 1/n, donde "x", "y", "n" son números naturales.

Parecía que la solución estaba en simplemente meter x e y en dos bucles anidados y evaluar la ecuación para distintos valores de "n" y, junto con un contador, romper los bucles cuando éste exceda mil. Mas el primer problema que hallé es cómo encontrar los límites superiores de los bucles ¿cómo sé que no debo buscar en la infinita totalidad del conjunto de números naturales? En el problema se entiende que la solución existe y es finita.

Después de jugar con la ecuación, despejar variables, quitar denominadores, iguala a cero... y finalmente frustrarme, un foro me dio una pista: la solución de los límites para "x" e "y" está en la ecuación en su forma original.

Entonces me puse a analizarla y a meditarla...

Entonces (si se ignoran todos los dibujitos) salta a la vista que "x" e "y" deben ser mayores que "n" para cumplir la condición que todas las variables son números naturales. El valor de n+1 es el límite inferior de los bucles.

Si hago x = n+1:

Si el valor mínimo de "x" e "y" es n+1, el valor máximo será n^2+n, ya que para cumplir que 1/x + 1/y = 1/n, si "x" tiene un valor máximo, "y" tendrá un valor mínimo. En una fracción, mientras más grande es el denominador, más pequeña será la fracción, y viceversa.

Mi primer intento de resolver el problema 108 tenía dos bucles anidados que evaluaban los valores de "x" e "y", dentro de un bucle while, el cual se rompía cuando un contador superaba el valor de 1000, mientras no lo hiciera incrementaba el valor de "n". Mirando la ecuación también se deduce que "n" debe ser mayor a 32, ya que n^2+n - (n+1) = 31.606, redondeando: 32.

Pero este primer intento era mortalmente lento.

Luego de correr el programita para valores pequeños de "n", noté que las soluciones se repetían cuando "x" e "y" eran iguales a 2*n. Esto se entiende por la propiedad conmutativa de la suma:

El siguiente valor entero es 2n + 1, donde "z" puede ser "x" ó "y", pues los valores se repiten para las dos variables:

Se concluye que se puede decir que "x" va desde n+1 hasta 2n, "y" va desde 2*n+1 hasta n^2+n.

Para que se cumpla la condición de las mil soluciones, "x" debe tener al menos mil valores, es decir: 2n - (n+1) >1000. El valor mínimo para "n" es 999. En el programa empieza desde 1000:

 

Pero esta solución también tardaba siglos.

Entonces, jugando un poco con la ecuación, llegué a esto:

 

Para el problema 108, no interesan los valores de "n", "x" e "y", sólo si la relación xy/(x+y) da mil soluciones enteras. Evalúo los posibles valores de "x" e "y" para el intervalo [n+1, 2n], dentro de dos bucles: 

Queda mucho mejor y da la solución al problema en menos de un minuto, corriendo como código administrado sobre .Net 3.5 :D

Mi programita se veía interesante y bonito... tan bonito que me dije ¿por qué no pasarlo a Linq?

 

 

Dado que el compilador debe hacer varias conversiones si se usa Linq, esta última solución es unas tres veces más lenta.

El código fuente puee descargarse de aquí.