LuAuF » C

¿Cómo conectarse a MySQL desde un programa en C?

Luciano — Sat, 09 Jul 2011 18:01:54 +0000

La respuesta al título de esta publicación es muy sencilla, conectarse a MySQL desde C se realiza mediante una API provista por el mismo proveedor de base de datos.

La API de C es ditribuida con MySQL, no es más que una librería (libmysqlclient) que interfacea entre el programa y la base de datos.

La documentación provista por MySQL es muy completa (MySQL C API), no obstante, fiel a nuestra costumbre iremos a un ejemplo sencillo y concreto.

¿Qué necesitamos?

Un servidor de base de datos MySQL, al cual conectarnos
Un programa cliente
La librería mysqlclient
mysql-devel, headers con la firma de la librería
gcc

Con cualquier variante de UNIX más la instalación manual de la distribución binaria (tar.gz) tendremos todo lo que necesitamos. Caso contrario habrá que instalar los paquetes necesarios que incluya los requisitos mencionados, por ejemplo mysql-devel.

Primero, sin ir al detalle en concreto de cada línea (no cuesta nada interpretar el código, pues está bien comentado) veamos el siguiente fuente:

/* mi_cliente */
#include
#include

main() {
MYSQL *conn;
MYSQL_RES *res;
MYSQL_ROW row;

char *server = "localhost";
char *user = "root";
char *password = "PASSWORD"; /* set me first */
char *database = "mysql";

conn = mysql_init(NULL);

/* Connect to database */
if (!mysql_real_connect(conn, server,
user, password, database, 0, NULL, 0)) {
fprintf(stderr, "%s\n", mysql_error(conn));
exit(1);
}

/* send SQL query */
if (mysql_query(conn, "show tables")) {
fprintf(stderr, "%s\n", mysql_error(conn));
exit(1);
}

res = mysql_use_result(conn);

/* output table name */
printf("MySQL Tables in mysql database:\n");
while ((row = mysql_fetch_row(res)) != NULL)
printf("%s \n", row[0]);

/* close connection */
mysql_free_result(res);
mysql_close(conn);
}

Ahora si veamos la parte más interesa saber ¿cómo compilar?

Entre los argumentos a pasarle al gcc tenemos los directorios con las librerías, las librerías propiamente dichas, los directorios de encabezados (.h), y otras opciones más del compilador. Esto no representa ningún problema, menos aún con mysql_config es un pequeño utilitario de MySQL que provee información para el compilador.

De esta forma:

mysql_config --libs: devuelve los path de las librerías y las librerías propiamente dichas a linkear.
mysql_config --cflags: devuelve, entre otros argumentos, los path de los headers.

Finalmente, podemos compilar de esta manera tan sencilla:

$ gcc -o mi_cliente $(mysql_config --cflags) mi_cliente.c $(mysql_config --libs)

Y luego ejecutar:

$ ./mi_cliente

Realmente, muy sencillo ¿no?

Vía: nixCraft

Alocando y realoncando memoria en C/C++

Luciano — Mon, 01 Feb 2010 11:00:25 +0000

Algo muy poco atractivo para muchos programadores que llegan a C/C++ luego de hacer experiencia en otros lenguajes es la asignación de memoria dinámica (punteros, mallocs y reallocs).

Repasemos un poco de teoría y luego veamos un ejemplo sencillo e indoloro

Las variables y arrays en C/C++ ocupan un espacio de memoria limitado e invariable durante la ejecución de un programa.

Para utilizar variables capaces de "crecer" en tiempo de ejecución, es decir, asignar memoria dinámicamente, es necesario recurrir a los punteros y luego a una serie de funciones útiles para trabajar con ellos (malloc, sizeof, realloc, free).

Los programadores suelen (solemos) escapar al uso de punteros pues si cometemos errores (nos olvidamos de liberar memoria "free", o pisamos memoria o hacemos de nuestros programas verdaderos "chupa-memoria") nuestros programas tienden a volverse "inestables". De todas formas, no es para huir despavoridos, al contrario, simplemente hay que ser precavidos y recuerda "malloc never fails"

Sin más palabras, vamos a ver dos ejemplos bien comentados, en el primero de ellos conoceremos a los famosos punteros y las funciones malloc, sizeof y free. En el segundo ejemplo, agregamos la función realloc.

#include /* stándard library, en inglés para que no me discutan si utilizar los términos biblioteca o librería */

int* ptr; /* puntero a enteros */

...

/**
* La función malloc reserva un "hueco" (zona de memoria) de un tamaño de, 300 veces el tamaño de un entero (este valor es en bytes).
* También se puede ver el uso del sizeof para indicar obtener el tamaño, en bytes, de un entero.
*/
ptr = (int*)malloc ( 300*sizeof(int) );

...

/**
* Si malloc no puede asignar el espacio indicado (por ejemplo, si no hay memoria disponible) devuelve un puntero nulo.
*/

if (ptr==0) {
fprintf(stderr,"No puedo alocar memoria!"); fflush(stderr);
exit(EXIT_FAILURE)
}

ptr[100] = 16; /* Aquí trabajo con una parte de memoria asginada, zona que antes del malloc no existía */

free(ptr); /* terminado el uso de la memoria, no olvides liberarla */
ptr=NULL; /* Es buena práctica dejar los punteros apuntando a NULL (hacia ningún lado) luego de su uso */

char *ptr; /* declaramos un punterito a char */
int size;

size = 8 * sizeof(char); /* asignamos a size un número, que representa la cantidad de bytes que alocaremos luego*/

/* asignamos un "hueco" de ocho bytes para ptr*/
ptr = (char *) malloc( (size_t) size);

...

/**
* Suponte que necesitamos nos que nos "quedamos cortos" con el espacio de memoria asignado.
* Con la función podemos cambiar el tamaño de una zona de memoria dinámica previamente pedida mediante la instrucción malloc.
*/
size *= 2; /* duplicamos el valor de size */
ptr = (char *) realloc(ptr, (size_t) size);

/**
* Tal como malloc, realloc, si no puede asignar el espacio indicado (por ejemplo, si no hay memoria disponible) devuelve un puntero nulo.
*/
if (ptr==0) {
fprintf(stderr,"No puedo realocar memoria!"); fflush(stderr);
exit(EXIT_FAILURE)
}

...

/**
* Un detalle, no menor, realloc puede devolvernos una zona de memoria en otra posición y el puntero devuelto por realloc puede, por lo tanto, ser diferente al devuelto en primera instancia por malloc.
* No obstante, realloc se encarca que el contenido apuntado por el puntero sea el mismo.
* Es decir, todo este "manejo" de memoria es trasparente para el programador
*/

free(ptr) /* Free the malloc()s */

Un comentario final, estas funciones vistas son estándares de C y se pueden encontrar, donde más que, en la librería (o biblioteca como dicen los puristas) stdlib.

Indicadores de progreso en C

Luciano — Wed, 18 Nov 2009 14:52:15 +0000

Luego de leer el artículo C/C++: Indicador de progreso de La plaga Tux, me vino a la mente ese indicador de progreso que tiene ese aspecto de "barrita" girando sobre su propio eje.

Entonces, tiempo libre mediante, en principio tomé el artículo original y porté el código de C++ a C (nada de otro mundo). Tal artículo me hizo recordar que hay vida más allá del \n recordándome el \r. Pero como una cosa va encadenada a la otra, también me hizo recordar el \b.

Para quienes hasta aquí me leen perdidos o necesitan un refresco de su memoria, les recuerdo que en el formato de impresión se pueden utilizar varias secuencias de control de cursor:

\n: nueva línea
\r: retorno de carro
\b: backspace
\t: tab
etc.

Con esto, ya tenemos todos los fundamentos para que puedas entender los ejemplos.

Indicador de progreso portado de C++ a C de la versión original del artículo:

#include
#include

int main ( int argc , char **argv )
{
const short operations = 500;
float inc = 100.0f / ((float)operations-1.0);
float progress = 0.0f;
short i,pos=0;

for ( i=0; i) {
progress+=inc;
fprintf( stdout, "Progreso: %d\r" , (int)progress ); fflush(stdout);
usleep(500000);
}

return EXIT_SUCCESS;
}

"Barrita" de progreso girando sobre su propio eje:

#include
#include
#include

int main ( int argc , char **argv )
{
const char s[] = "-\\|/-\\|/";
const short operations = 500;
short i,pos=0;

for ( i=0; i) {
fprintf( stdout, "Progreso: %c\r" , s[pos] ); fflush(stdout);
pos++;
if ( pos>=strlen(s) )
pos=0;
usleep(500000);
}

return EXIT_SUCCESS;
}

Espero que haya servido, a mi al menos me sirve para agregarlo a mi base de conocimientos (mi blog )

Go, la noticia de la semana

Luciano — Sun, 15 Nov 2009 05:48:26 +0000

En la semana una noticia ocupó a la mayoría de los blogs: Go, un nuevo lenguaje de programación. La noticia hubiera pasado desapercibida de no ser porque Go es un nuevo lanzamiento de Google!

Go se promociona a si mismos como un lenguaje:

rápido: el código compilado en Go corre tan rápido como el código compilado en C o C++.
seguro: garantiza seguridad en el manejo de memoria, tiene punteros pero no utiliza la aritmética de punteros que convierten en engorrosa la programación y dan lugar a memory leaks, memory slices y ese otro tipo de males.
concurrente: promueve la escritura de procesos ligeros, comunicados entre si y ejecutar miles de rutinas diciendo adios a los desbordamientos de pila
divertido: sintaxis clara, garbage collector, métodos de cualquier tipo, etc. Go luce como un lenguaje dinámico (Phyton) pero tiene la velocidad y seguridad de un lenguaje estático (C, C++).
código abierto: distribuido bajo licencia BSD

En términos generales, Go es un lenguaje de proposito general, orientado a objetos y open source, que basa su publicidad en la fusión de las mejores características de C y C++ con Python. Go es la respuesta a la ausencia de un lenguaje que fuese eficiente a la hora de compilar y fàcil a la hora de programar.

Para conocer un poco más, el video de promoción:

El video de presentación (de casi una hora):

El enlace a la web oficial: The Go Programming Language

Una curiosidad: ¿sabías en que estaba trabajando Ken Thompson para Google? bien... aquí tenemos la respuesta

Escribir, compilar y ejecutar el “Hola Mundo” en C++ sobre Linux

Luciano — Fri, 25 Sep 2009 01:54:45 +0000

En pocos pasos, veremos como compilar un programa escrito en C++ sobre Linux:

Asegurarse de tener instalado el compilador para C++ (g++):

$ which c++
/usr/bin/c++

$ dpkg -l | grep g++
ii g++ 4:4.3.3-1ubuntu1 The GNU C++ compiler
ii g++-4.3 4.3.3-5ubuntu4 The GNU C++ compiler

En caso de una respuesta negativa instalarlo mediante un gestor de paquetes. En Debian o distribuciones basadas en Debian instalarlo mediante APT.

Escribir el clásico "Hola Mundo", helloworld.cc

#include
using namespace std;

int main ()
{
cout <<"Hola Mundo!";
return 0;
}

Compilar:

c++ helloworld.cc -o helloword

Ejecutar:

$ ./helloworld
Hola Mundo!

Vía: The Geek Stuff

Argumentos variables (varargs) en Java

Luciano — Sat, 16 May 2009 09:00:15 +0000

Para aquellos anticuados como yo que en C, desde que descubrimos la varargs.h no podemos dejar de mandar un número de argumentos variables, hoy veremos que con Java también es posible.

Como introducción, para aquellos con conocimientos en C, sabrán de funciones como prinft que les permite enviar un número ilimitado de argumentos luego de su cadena con formatos.

A continuación, veremos una implementación de la varargs que de muy buena forma nos muestra la Wikipedia:

Ejemplo de función sumar:

#include

int sumar(int n, ...)
{
va_list ap;
int i = 0;

va_start(ap, n);
for (; n; n--) {
i += va_arg(ap, int);
}
va_end(ap);
return i;
}

Ejemplo de llamados a la función:

sumar (1);
sumar (1,2,3,4);

En Java, para hacer que un método tenga un número variable de argumentos se puede hacer enviando un array, o alguna colección, y luego desde el método recorrer el array o los elementos de la colección ¿que mejor ejemplo que el método main?

public static void main(String[] args) {
System.out.println("y los argumentos son:");
for (String arg : args)
System.out.println(arg);
}

Pero bien, no es para desesperar, pues desde Java 5 se puden utilizar argumentos variables a un método de una forma por demás de sencilla:

public static void imprimir(String... cadenas) {
for (String cadena : cadenas)
System.out.println(cadena);
}

Como comentario, no está demás destacar que varargs no es más que una cáscara, pues internamente Java sigue utilizando un array, aunque a nosotros nos alivia mucho la sintaxis y por lo tanto se agradece

Vía: Mundo Geek

Algunas funciones útiles escritas en C

Luciano — Fri, 21 Nov 2008 01:30:48 +0000

Para quienes dan sus primeros pasos en C, pero que vienen de otros lenguajes de más alto nivel, se encontrarán con el faltante de varias funciones disponibles en otros lenguajes (ya sea como funciones o como métodos de algunas clases).

A continuación, pongo a vuestra disposición el código de algunas funciones que pueden resultar de utilidad: las clásicas funciones rtrim, ltrim y trim (para eliminar espacios a la derecha, izquierda y de ambos lados de una cadena) y de la función isNumeric para comprobar si un valor ingresado es numérico o no.

Además, para agregar un poco de valor agregado a la publicación convertiremos a estas funciones en una librería dinámica.

Los pasos a seguir son los siguientes:

Crear un archivo funciones.h con la declaración de las funciones a utilizar. Este header será utilizado, luego, por las aplicaciones que hagan uso de la librería dinámica.

#ifndef _LIBRERIA_FUNCIONES_H
#define _LIBRERIA_FUNCIONES_H
int isNumeric (const char *val);
int isAlpha (const char *val);

char *rtrim (char *str);
char *ltrim (char *str);
char *trim (char *str);
#endif

Crear un archivo funciones.c con la implementación de las funciones.

#include
#include
#include
#include

#include "funciones.h"

/*******************************************************************************
*
*/
int isNumeric(const char *val)
{
int i = 0, s = 0;

for(i = 0; i (val); i++)
if(isdigit(val[i]) == 0)
s = -1;

return s;
}

/*******************************************************************************
*
*/
int isAlpha(const char *val)
{
int i = 0, s = 0;

for(i = 0; i (val); i++)
if(isalnum(val[i]) == 0)
s = -1;

return s;
}

/*******************************************************************************
*
*/
char *rtrim(char *str)
{
char *endStr = 0;

endStr = str + strlen(str) - 1;

while( (endStr>= str) && (*endStr == ' '))
*endStr-- = '\0';

return str;
}

/*******************************************************************************
*
*/
char *ltrim(char *str)
{
char *startStr = 0;

startStr = str;

while(*startStr == ' ')
startStr++;

return startStr;
}

/*******************************************************************************
*
*/
char *trim(char *str)
{
return ltrim(rtrim(ltrim(str)));
}

Creamos un archivo Makefile para facilitar la compilación.

CFLAGS=-Wall

clean:
rm libfunciones.so

libfunciones: funciones.c
cc $(CFLAGS) -c -o funciones.o funciones.c
ld -o libfunciones.so funciones.o -shared
rm funciones.o

Finalmente, compilamos!!!

$ make libfunciones
cc -Wall -c -o funciones.o funciones.c
ld -o libfunciones.so funciones.o -shared
rm funciones.o
$

Para evitarles la tarea de copiar y pegar, pueden descargar los archivos anteriores aquí:

Para una próxima entrega, les estoy debiendo como utilizar esta librería dinámica desde otra aplicación.

Vía: Seraphinux

Ejemplo de función potencia iterativa y recursiva

Luciano — Thu, 21 Aug 2008 00:54:39 +0000

Los algoritmos recursivos no son un recurso tan utilizado por los programadores, inclusive, también se plantean discusiones acerca de algoritmos iterativos vs. recursivos.

Independientemente de la preferencia de cada uno de los programadores, la idea de esta publicación es mostrar con un ejemplo sencillo una misma función "potencia" escrita de ambas formas.

Una función potencia, de forma iterativa se puede escribir de la siguiente manera:




int potencia ( int base, int exponente ) {

    long p=1;

    int i;
    for ( i=1 ; i<=exponente ; i++) {

        p*=base;

    }
    return(p);

}

Ahora, por definición, una función es recursiva cuando en su cuerpo hay un llamado a si misma.
Esta definición es perfectamente aplicable a la potenciación, pues: x^y = x * (x^y-1), por ejemplo:
2⁴ = 2 * (2³)
donde, 2³ = 2 * (2²)
donde, 2² = 2 * (2¹)
donde, 2¹ = 2 * (2⁰)

Por lo tanto, esto se podría escribir de la siguiente manera:




int potencia( int base, int exponente) {

     if(exponente == 0) {

        return 1

     } else {

        return base * potencia(base, exponente -1) // llamada recursiva

     }

}

Tal vez este no sea el caso más representativo, pero una de las principales ventajas por las que se utilizan algoritmos recursivos es la por la disminución de la cantidad de líneas de código necesarias.

Vía: Nuevos Programadores

Programación en C/C++ con Eclipse

Luciano — Fri, 27 Jun 2008 00:53:43 +0000

Eclipse es un IDE conocido para el desarrollo de aplicaciones Java. Sin embargo, es un IDE mucho más flexible de lo imaginado, pues gracias a una infinidad de plugins permite, entra otras cosas, editar clases visuales de Java, programar aplicaciones J2EE, C/C++ y en varios lenguajes más, conectarse a bases de datos y escribir consultas SQL, etc.

Para esta ocación, veremos que debemos hacer para programar en C o C++. Si bien, puedes descargarte una versión preparada para desarrolladores C/C++ , en nuestro caso arrancaremos de un eclipse instalado y utilizado (antes de esta publicación) únicamente para el desarrollo en Java.

Antes que nada debemos instalar el plugin necesario, para ello vamos a Help -> Software Updates -> Find and Install... y en la primer ventana seleccionaremos "Search for new features to install".

A continuación, seleccionamos el servidor de donde obtendremos las actualizaciones (yo seleccioné Callisto Discovery Site, eso no quita que el plugin no pueda estar disponible en otro server). Esta lista de servidores puede ser editada, nos permite agregar, quitar o actualizar servidores.

Luego de descargado el listado de características para instalar, seleccionamos "C and C++ Developement \ Eclipse C and C++ Developement Tools", hacemos clic en Next y esperamos un tiempo hasta que termine la descarga.

Terminada la descarga será necesario reiniciar el IDE para que los cambios tengan efecto. A partir de ahora, al momento de crear un proyecto nuevo, tenemos la opción de elegir un proyecto C o C++.

Cabe destacar, que debes tener el compilador de C/C++ instalado, gcc, gcc para Windows o cualquier otro compilador de C.

Struct, Union y Enum en C

Luciano — Wed, 04 Jun 2008 03:33:23 +0000

A continuación, del Curso de Programación en C de Programar es fácil (o no) veremos un breve resumen de algunas estructuras de datos:

Estructuras
Uniones
Enumeraciones

Struct

Una estructura es una agrupación, bajo un mismo nombre de variable, distintos datos que pueden ser de diferente tipo. Las estructuras vienen a salvar la limitación de los arrays, que solo almacenan un único tipo de dato.

Una estructura también es llamada registro y cabe su analogía con los registros de una tabla, donde un registro tiene varios datos (campos) y estos pueden diferir en su tipo:

Ejemplo:




struct usuarios_t {

   int   dni;

   char     nombres[50];

   char     apellido[30];

   time_t   nacimiento;

};
//un registro usuarios:

struct usuarios_t usuario;

usuario.dni=27651109

strcpy(usuario.nombres,"Jose Maria");

...
//un array de registros:

struct usuarios_t usuarios[10];

usuario[0].dni=27651109

strcpy(usuario[0].nombres,"Jose Maria");

usuario[1].dni=26852789

strcpy(usuario[1].nombres,"Juan Carlos");

...

No es mi intención sumar complejidad a este resumen, solo quiero agregar que se pueden declarar punteros a estructuras, que los elementos de una estructura pueden ser punteros, que se pueden anidar estructuras, pasar estructuras (como punteros a estructuras) como parámetro de funciones, etc.

Union

Una union se declara de la misma forma que una estructura, reemplazando struct por union. La diferencia está en que todos los miembros de la union comparten el mismo espacio en memoria, por lo que solo se puede tener almacenado un miembro de ellos en cada momento. El tamaño de la union estará dado por el miembro más largo de la misma.

Ejemplo:




struct usuarios_t {

   int   dni;

   char     nombres[50];

   char     apellido[30];

   time_t   nacimiento;

};

union usuario_t usuario;        /* Declaración de la variable */

Enum

Una enumeración es un conjunto de constantes enteras. A la enumeración se le puede asignar un nombre, que se comportará como un nuevo tipo de dato que solo podrá contener los valores especificados en la enumeración.

Ejemplo:




enum dias_semana {LUNES=1, MARTES=2, MIERCOLES=3, JUEVES=4, VIERNES=5, SÁBADO=6, DOMINGO=7 };
dias_semana     dia;

dia         =   LUNES;

dia         =   1;    /* Ambas asignaciones son equivalentes */

Vía: Estructuras en C, Uniones en C, Enumeraciones en C