Para empezar, debemos tener clara la organización de los archivos, tendremos un directorio el cual debe tener el nombre del modulo y dentro de él lo siguiente:

• tmpl: Directorio en el cual están los archivos para visualizar el módulo; aclaro que puede llamarse como quiera.
• tmpl/default.php: Recibe todos los datos correspondientes del modulo.
• tmpl/index.php: Digamos que es la plantilla básica que usa default para mostrarse.
• mod_nombre_del_modulo.php: Aquí incluímos las clases y las librerías que necesitaremos para obtener los datos del módulo
• mod_nombre_del_modulo.xml: Este, será el esqueleto en el cual estarán todas las propiedades, archivos y directorios del módulo.
• helper.php: La clase en la cual se realiza la programación pertinente del módulo

A Trabajar!

Vamos a crear un módulo que muestre los usuarios que están cumpliendo años en el mes. Empecemos por crear el archivo mod_cumpleanos.php, en él irán las directivas que necesitamos para obtener los datos:

<?php
defined( '_JEXEC' ) or die( 'Restricted access' );

require_once( dirname(__FILE__).DS.'helper.php' );

$nombres = modCumpleanosHelper::getNombres( $params );
require( JModuleHelper::getLayoutPath( 'mod_cumpleanos','default') );
?>

El archivo helper.php tendrá como función, realizar las consultas que necesitemos para el resultado que mostrará el módulo, en este caso haremos una consulta que nos traiga los usuarios que están cumpliendo años en el mes, éstos organizados por el día:

<?php
class modCumpleanosHelper
{
    function getNombres( $params )
    {
	jimport('joomla.utilities.date');
	$jnow = new JDate();
	$now = $jnow->toMySQL();
        $month = substr($now, 5, 2);
	$db = &JFactory::getDBO();

        $consulta = "select name, cumpleanos from #__users where MONTH(cumpleanos)='".$month."' order by DAY(cumpleanos) ASC";
	$db->setQuery($consulta);

        return $db->loadObjectList();
    }
}
?>

Ahora, dentro de nuestra carpeta temporal, tenemos el archivo default.php el cual recibe todos los datos que necesita para el módulo, además de ser el que le da el estilo al módulo en el Front del Joomla!:

<ul>
<?php
echo "<table class='mod_cumpleanos'>";
echo "<th>Usuario</th><th>Dia</th>";
foreach ($nombres as $usuario) {
	echo "<tr align='center'><td><li>".$usuario->name."</td>
                  <td>".substr($usuario->cumpleanos, 8, 2)."</td></tr></li>";
	}
echo "</table>";
?>
</ul>

Falta poco!

Para terminar solo nos queda crear el archivo mod_cumpleanos.xml, en el cual pondremos todo lo que necesita el módulo para funcionar completamente y poderlo instalar en el Gestor de Módulos del Joomla!:

<?xml version="1.0" encoding="utf-8"?>
<install type="module" version="1.5.0">
    <name>Cumpleanos del Mes</name>
    <author>Cindy Esmeralda Arenas</author>
    <version>1.5.0</version>
    <creationDate>19.06.2010</creationDate>
    <description>Modulo que carga los usuarios que estan cumpliendo anos</description>
    <authorEmail>cearenas@cearenas.com</authorEmail>
    <files>
	<filename module="mod_cumpleanos">mod_cumpleanos.php</filename>
       	<filename>helper.php</filename>
	<filename>mod_cumpleanos.xml</filename>
       	<filename>tmpl/default.php</filename>
       	<filename>tmpl/index.html</filename>
    </files>
</install>

Al instalarlo, lo ubicamos en cualquier Posición de la plantilla y podemos observar un listado de los usuarios que tenemos registrados y que están de cumpleaños en el mes. Descargar

Importante

No olviden consultar las fuentes, los foros de ayuda de Joomla! son buenos y colaborar en ellos también

Código Actividad Principal

package ejemplo.actividades;

public class ActividadPrincipal extends Activity implements OnClickListener {

	private Button btnPresioname;
	private TextView texto;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        btnPresioname = (Button) findViewById(R.id.push);
        btnPresioname.setOnClickListener(this);

        texto = (TextView) findViewById(R.id.texto);
        Bundle recibido = getIntent().getExtras();
        String lenguaje = "";
		if(recibido !=null)
			lenguaje = recibido.getString("Lenguaje");
        texto.setText(lenguaje);

    }
	@Override
	public void onClick(View v) {
			Intent intent = new Intent(ActividadPrincipal.this, ActividadLista.class);
			startActivity(intent);
	}

}

Lo que me parece bueno aclarar, creamos un Bundle para guardar allí los valores que estamos enviando como “parámetros” desde la otra actividad, en este caso es el lenguaje que presionemos, siendo así entonces cambiaríamos la variable texto. Si nos fijamos en esta línea:

Intent intent = new Intent(ActividadPrincipal.this, ActividadLista.class);

Estamos diciéndole la actividad en donde nos encontramos y a la que queremos ir. Para esta actividad tenemos el siguiente xml:

Código Etiquetas

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent" >
<TextView
    android:layout_width="fill_parent"
    android:layout_height="wrap_content"
    android:text="@string/hello" />
<Button
	android:layout_width="wrap_content"
        android:layout_height="wrap_content"
	android:id="@+id/push"
        android:text="@string/texto_boton" />
<TextView
	android:id="@+id/texto" android:text=""
	android:layout_width="wrap_content"
        android:layout_height="wrap_content" />
</LinearLayout>

Importante que tengamos claro cuáles son las cadenas de texto que usaremos en la aplicación, éstas aparecen en el archivo string.xml dentro del directorio values. En este paso, si corremos nuestra aplicación nos debería mostrar lo siguiente: Primera Actividad
Ahora creamos nuestra Actividad Secundaria, la cual nos va a mostrar una lista de lenguajes y cuando presionemos uno nos va a devolver a la Actividad Principal. La llamaremos ActividadLista.java:

Código Actividad Lista

package ejemplo.actividades;

public class ActividadLista extends ListActivity {

	@Override
	public void onCreate(Bundle savedInstanceState) {
	  super.onCreate(savedInstanceState);

	  setListAdapter(new ArrayAdapter<String>(this, R.layout.list_item, LENGUAJES));

	  ListView lv = getListView();
	  lv.setTextFilterEnabled(true);

	  lv.setOnItemClickListener(new OnItemClickListener() {
	    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {

	      Toast.makeText(getApplicationContext(), "Lenguaje: "+((TextView) view).getText(),
	          Toast.LENGTH_LONG).show();
	      Intent intent = new Intent(ActividadLista.this, ActividadPrincipal.class);
	      intent.putExtra("Lenguaje", "Lenguaje presionado: "+((TextView) view).getText());
	      startActivity(intent);
	   }
	  });
	}
	static final String[] LENGUAJES = new String[] {"Java","Php","Python","Ruby"};
}

En la siguiente línea de código estamos incluyendo la variable que vamos a pasar como parámetro a la Actividad Principal:
Definimos el nombre de la variable y si asignación:

intent.putExtra("Lenguaje", "Lenguaje presionado: "+((TextView) view).getText());

Para esta actividad tenemos el siguiente xml, recordemos que es importante tener la interface de cómo queremos que se vea:

Código Etiquetas

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:padding="10dp"
    android:textSize="16sp" >
</TextView>

En este momento si lo corremos, cuando presionemos el botón se nos va a romper la aplicación, para que no nos pase eso, vamos al archivo AndroidManifiest.xml y dentro de la etiqueta aplication insertamos la actividad que queremos pasar:

<activity android:name="ActividadLista" android:label="Lista de Lenguajes"></activity>

Entonces ahora sí, podemos correr nuestra aplicación y nos mostrará lo siguiente cuando presionemos el botón: Lista Lenguajes.

Cuando presionemos cualquier elemento de la lista, nos va a aparecer un Dialog con el nombre del elemento ver e inmediatamente después nos devuelve a la Actividad Principal y allí nos muestra cual fue el lenguaje que presionamos ver

Si quieren pueden descargar el ejemplo del siguiente enlace Descargar! y como siempre, no olviden consultar la fuente

En este ejemplo vamos a usar un artículo que ya se había publicado hace un tiempo por estos lados, Envío de correos con Php , ya que de alguna manera debemos recibir la Ip que estamos esperando.

El código

Vamos a crear un archivo que lleve el nombre “funciones.php”, en éste vamos a tener dos funciones, una que decide cuál es la forma en que está expresada la Ip y otra que tiene el envío del correo:

//Recibir IP
function recibirIP(){
	if ($_SERVER) {
		if ( $_SERVER["HTTP_X_FORWARDED_FOR"] ) {
		   $ip = $_SERVER["HTTP_X_FORWARDED_FOR"];
		} elseif ( $_SERVER["HTTP_CLIENT_IP"] ) {
			$ip = $_SERVER["HTTP_CLIENT_IP"];
		} else {
			$ip = $_SERVER["REMOTE_ADDR"];
		}
	}
	else {
		if (getenv("HTTP_X_FORWARDED_FOR") ) {
			$ip = getenv("HTTP_X_FORWARDED_FOR");
		} elseif (getenv("HTTP_CLIENT_IP") ) {
			$ip = getenv("HTTP_CLIENT_IP");
		} else {
			$ip = getenv("REMOTE_ADDR");
		}
	}
	return $ip;
}

//Enviar el correo
function correo($comentario){
    $para = "cearenas@cearenas.com";
    $desde = "micorreo@correo.com";
    $cabecera = "From: ". $desde." <".$desde. ">\r\n";
    $asunto = "Ip del visitante";
    mail ($para, $asunto, $comentario, $cabecera);
}

Ahora creamos otro archivo para ejecutar nuestros métodos, “local.php” éste va a hacer el llamado correspondiente a las funciones y por suspuesto incluímos funciones.php:

    include("funciones.php");
    $comentario = "Esta es la Ip: ".recibirIP();
    correo($comentario);

Lo nuevo…

$_SERVER: Usamos algunas de las variables de la matriz $_SERVER, ésta contiene información tal como cabeceras, rutas y ubicaciones de scripts creados por el servidor web donde se ejecute el archivo.
getenv:Se encarga de obtener el valor de la variable de entorno que necesitamos.

¿Hasta dónde llega?

Este ejemplo, revela la ip de cualquier computador, pero eyy!, cuando éste es resguardado por un firewall bien configurado, podemos llegar sólamente hasta la puerta de enlace.
Ya para terminar, sólo me queda decir que revisen su correo, allí debe estar la información de la Ip que acaban de obtener además como siempre, si existe alguna duda no olvidar consultar la Fuente

¿Cómo empezar?

Ruby es un lenguaje de programación que se puede manejar orientado a objetos, como Java, Php y C++, con la diferencia que todas sus variables declaradas son de tipo privado. Es sencillo de manejar y aprenderlo es fácil, ya que es de la línea de Phyton y para los programadores suele ser muy claro, relajado y hasta suave de trabajar

Pero bueno, arranquemos, primero que todo importantísimo aclarar que este artículo está trabajado sobre Linux, específicamente en Ubuntu, pero que para los amantes de Windows, la diferencia es relativamente muy poca.

Empecemos por instalar Ruby en nuestro equipo. Como vamos a trabajar interfaces gráficas es importante tener una librería gráfica a usar, como Swing en Java, en este caso usaremos GTK2.

¿GTK2?

GTK2 es un librería para crear interfaces gráficas, publicada bajo licencia pública LGPL. La idea es descargarla y copiarla en el directorio lib de nuestro Ruby. Descargar

A programar!

Un concéntrese clásico es una ventana con un cierto número de fichas las cuales tienen un a imagen al reverso de éstas. El concéntrese que vamos a hacer cumple con ciertas características de la Programación Orientada a Objetos, como la Herencia, Overriding de métodos y manejo de eventos; además vamos a manejar el concepto de Thread (hilo) para la ejecución del programa.

Nuestro concéntrese comienza definiendo la clase BotonConcentrese, la cual es una herencia de la clase Botón de GTK, además se hace uso de variables globales las cuales permitirán el buen funcionamiento del mismo.

Clase Botón

$click = 0
$botones = 6
$bloqueados = 0
$registrados = Array.new

#Clase Boton
class BotonConcentrese < Gtk::Button
	#Constructor
	def initialize(nombre, numero)
	    super(nombre)
	    @numero = numero
	    signal_connect("clicked"){
		Thread.new{jugar(self)}
	    }
	  end

        #Accesor
	  def getNumero
	    return @numero
	  end
end

En la primera línea se puede observar la forma en que la clase está heredando de Botón, a continuación se definen sus métodos como el constructor, el accesor getNumero (el cual retorna el valor asignado al botón), y jugar.
Es en este método donde se encuentra la interactividad del juego. El cual recibe como parámetro un botón, es decir el botón que haya sido oprimido por el usuario, es aquí donde cada botón del Concéntrese tiene relacionada una imagen, pero resulta que cada imagen tiene una copia que debe estar asignada en otro botón, es por eso que en esta parte se asigna teniendo en cuenta que solo exista una copia y no varias.

	#Metodo Principal Jugar
	  def jugar(boton)
		  $click = $click+1
		  image = Gtk::Image.new(boton.getNumero + ".jpg")
		  imagen = Gtk::Window.new
		  imagen.add(image)
		  imagen.show_all
		  #Puntaje - Actualizacion de Inferfaz
		  if $click==2
			$click = 0
			if $primeraOpcion.getNumero == boton.getNumero
				#desactivando los botones
				boton.set_sensitive(false)
				$primeraOpcion.set_sensitive(false)
				$primeraOpcion = BotonConcentrese.new("?", "0")
				$bloqueados = $bloqueados + 2
			end

		  else
		     $primeraOpcion = boton
		  end 

		  sleep (2)
		  imagen.destroy
		  if $bloqueados == $botones
			puts "Juego Completo!"
			terminar = Gtk::Image.new("terminado2.jpg")
			terminado = Gtk::Window.new
			terminado.add(terminar)
			terminado.show_all
			sleep (3)
			terminado.destroy
			Gtk.main_quit
		  end
	  end

A continuación entonces la serie de código en el cual se controla y se crean los botones aleatoriamente:

#Metodo para controlar la creacion de los botones
def estaRegistrado(num)
  cont = 0
  $registrados.each do |x|
    if x == num
      cont = cont + 1
    end
  end

  if cont < 2
    return false
  end

  if cont == 2
     return true
  end
  return true
end

#Creacion de los metodos
for j in 0..($botones-1)
  numero = (rand(5)%3)+1
  while estaRegistrado(numero) && $registrados.length != 0 do
     numero = (rand(5)%3)+1
  end
  $registrados << numero
  box1.pack_start(BotonConcentrese.new(Gtk::Stock::DIALOG_QUESTION, numero.to_s), true, true, 0)
end

Esta mini-aplicación hace que cuando se escoja algún botón, éste se cierre por sí solo, gracias a los Hilos que se ejecutan. Subo el comprimido con los fuentes para los que quieran descargarlo y probarlo. Y como siempre, no olviden dejar sus comentarios y consultar la fuente: Fuente

Además la idea de hacer este post, es para combinar un poco de Bases de Datos con esta funcionalidad, entonces aquí va el ejemplo básico de la generación del documento:

Código

require_once('clases/class.ezpdf.php');
$pdf =& new Cezpdf('a4');
$pdf->selectFont('fonts/Courier.afm');
$pdf->ezSetCmMargins(1,1,1.5,1.5);

$conexion = mysql_connect("localhost", "root", "");
mysql_select_db("personal", $conexion);
$queEmp = "SELECT nombre, correo, telefono FROM persona ORDER BY nombre ASC";
$resEmp = mysql_query($queEmp, $conexion) or die(mysql_error());
$totEmp = mysql_num_rows($resEmp);

$ixx = 0;
while($datatmp = mysql_fetch_assoc($resEmp)) {
	$ixx = $ixx+1;
	$data[] = array_merge($datatmp, array('num'=>$ixx));
}
$titles = array(
				'nombre'=>'<b>Nombres</b>',
				'correo'=>'<b>Correo</b>',
				'telefono'=>'<b>Telefono</b>'
			);
$options = array(
				'shadeCol'=>array(0.9,0.9,0.9),
				'xOrientation'=>'center',
				'width'=>500,
				'justification'=>'center'
			);
$txttit = "<b>Programacion Php, Java y C++</b>\n";
$txttit.= "Listado de Personal \n";

$pdf->ezImage("../Imagenes/logo.jpg", 0, 100, 'none', 'center');
$pdf->ezText($txttit, 12, $options, 0);
$pdf->ezTable($data, $titles, '', $options);
$pdf->ezText("\n\n\n", 10);
$pdf->ezText("<b>Fecha:</b> ".date("d/m/Y"), 10);
$pdf->ezText("<b>Hora:</b> ".date("H:i:s")."\n\n", 10);
$pdf->ezStream();

Entonces, la idea es incluir las clases que construyen el pdf con todas sus características, hacer la consulta en la base de datos, crear unos arreglos donde se incluyan los títulos y los campos que nos dan como resultado de la consulta y a continuación ponerlos en el pdf, como textos del mismo. Quizás lo único que hay para destacar es la forma en la que se ubica la imagen en el documento:

$pdf->ezImage("../Imagenes/logo.jpg", 0, 100, 'none', 'center');

Ya que se está haciendo el llamado de la imagen, se ubica en el centro del documento y con su tamaño al 100%. Y por supuesto la recomendación de siempre, ir a la Fuente Ahh bueno desde aquí pueden descargar el ejemplo: Descargar

Lo nuevo

* simplexml_load_string: Toma una cadena xml y devuelve un objeto de la clase SimpleXMLElement, con las propiedades del xml leído. Ej.:

// Lo que convierte es algo así:
SimpleXMLElement Object(
  [nombre] => David Fernando
  [telefono] => 311 123 4567
)

*count: Como vimos en temas anteriores, lo que hace count, es precisamente contar los elementos que contiene un arreglo; en este ejemplo, la etiqueta se convierte en un arreglo y sus elementos son nombre y teléfono.

El XML

Llamaremos a nuestro archivo directorio.xml, este será el que usaremos para la lectura.

<?xml version="1.0" encoding="utf-8"?>
<directorio>
	<persona>
		<nombre>David Fernando</nombre>
		<telefono>311 123 4567</telefono>
	</persona>
	<persona>
		<nombre>Viviana Marcela</nombre>
		<telefono>300 987 6543</telefono>
	</persona>
</directorio>

Nuestro Php en función

Y para que todo esto funcione creamos un archivo llamado directorio.php, así veremos en funcionamiento la lectura de nuestro XML.
Si notamos de todas formas no estamos dejando de lado las funciones de manipulación de archivos generales. Cuando ya tenemos el string listo como xml, lo que hacemos entonces es crear un ciclo para que nos muestre una a una las personas que se encuentran en el directorio. (La tabla es para que se vea un poco ordenado).

<?php
$url = "persona.xml";
$contenido_xml = "";
if($d = fopen($url, "r")){
  while ($aux= fgets($d, 1024)){
    $contenido_xml .= $aux;
  }
  fclose($d);
}else{
  echo "No se pudo abrir el XML";
}
$xml = simplexml_load_string($contenido_xml);
?>
<table align="center" border="1">
    	<tr><td>Nombre</td><td>Telefono</td>
<?php
	for($i=0; $i<count($xml->persona); $i++)
		echo '<tr><td>'.$xml->persona[$i]->nombre.'</td><td>'.$xml->persona[$i]->telefono.'</td></tr>';
?>
</table>

Terminamos!

Lo subimos a nuestro servidor ya sea local o remoto y, bueno ahí está la solución a nuestros problemas con las lecturas de archivos xml. Y por supuesto la recomendación de siempre, ir a la Fuente

Aclaro que este post es para Desarrolladores de Joomla! (pero no es complicado para novatos), ya que deben tener conocimientos de los directorios y algunas funciones que se nombraran, aunque diré cuál es su funcionalidad.

A saber…

• _JEXEC: Constante para poder entrar a los archivos de Joomla!
• DIRECTORY_SEPARATOR: Constante nativa de PHP, osea que no es definida por Joomla!, ésta contiene el separador de directorios del sistema operativo de nuestro servidor. Así que si el sistema es Unix se usa ‘/’ o por si lo contrario es es windows se usa ‘\’.
• __FILE__: También es una constante nativa de PHP, muestra la ruta del sistema del archivo que se está ejecutando. Hay que tener en cuenta que la ruta del sistema es diferente a la ruta http, ya que si es un sistema Unix sería algo así: “/var/www/…” o si es Windows entonces sería asi: “C:\Apache2\…”.
• JFactory/getApplication:Retorna una referencia del objeto aplicación (de tipo JApplication), pero esto solo si la referencia existe.

Entonces lo que hacemos es generar un archivo que enlace los datos de Joomla! y de ahí para allá los archivos que necesitemos, en realidad aquí solo vamos a hacer uno, ya que es suficiente.
Lo que vamos a mostrar es los datos del usuario que está en sesión en la plantaforma.

Código para el Enlace..

Creamos un archivo llamado enlace.php, importante que se encuentre en el directorio raiz de Joomla!.

<?php
define( '_JEXEC', 1 );
define('JPATH_BASE', dirname(__FILE__) );
define( 'DS', DIRECTORY_SEPARATOR );
require_once ( JPATH_BASE .DS.'includes'.DS.'defines.php' );
require_once ( JPATH_BASE .DS.'includes'.DS.'framework.php' );

$mainframe =& JFactory::getApplication('site');
?>

…Ahora el código de la aplicación..

Después de tener nuestro archivo de enlace creamos el archivo de la aplicación aplicacion.php, es decir, el archivo en el que vamos a usar la información del usuario que está en sesión.

<?php
include('../enlace.php');
	if (JFactory::getUser()->usertype == NULL){
		echo "No está conectado";
	}
	else{
		$user = JFactory::getUser();
		if($user->usertype=='Registered'){
                        echo "Usuario Registrado. UserName: ".$user->username;
		}
	}
?>

Con eso ya terminamos, vieron muy fácil, además nos estamos asegurando que solamente se haga lo que necesitamos cuando el usuario esté registrado.

Por Último:

Como siempre, seguir la documentación para no perdernos de cosas importantes, además por si necesitamos algo no hay nada mejor que ir a la fuente

El ejemplo que vamos a ver está hecho en C++ usando MySQL y en Windows, en el siguiente tema, lo veremos en Linux, para los que les gusta usar software libre

Cuando hice este ejercicio, lo desarrollé sobre DevC++ , un editor de código bueno para trabajar en C. Arranquemos pues, entonces creamos un nuevo proyecto a ese proyecto, antes de empezar con el código es importante que en las propiedades del proyecto en los parámetros se enlace la librería de mysql, con eso nos aseguramos que se puedan hacer las conexiones correspondientes en el proyecto a la base de datos. Ver Propiedades

¿Qué es nuevo y necesario?

1. Incluir las librerías de mysql, mysql_error y windows, ya que sin ellas no será posible realizar el ejercicio.
2. Creamos el objeto que nos va a llevar el enlace con MySQL.
3. Nos conectamos a el servidor y, la base de datos. (El mismo paso del tema anterior).
4. Por último, hacemos una consulta normal en MySQL e imprimimos los datos del resultado de nuestra consulta.

Y.. El código:

//Librerías
#include <windows.h>
#include <mysql/mysql.h>
#include <mysql/mysqld_error.h>

int main()
{
   MYSQL             *objDatos;
   MYSQL_RES       *res;

   // Intentar iniciar MySQL:
   if(!(objDatos = mysql_init(0))) {
      // Imposible crear el objeto objDatos
      cout << "ERROR: imposible crear el objeto objDatos." << endl;
      getchar();
      return 1;
   }

   // Debe existir un usuario, clave y base de datos
   if(!mysql_real_connect(objDatos,NULL,"root","","estudiante",MYSQL_PORT,NULL,0)){
      cout << "Imposible conectar con servidor mysql en el puerto "
           << MYSQL_PORT << " Error: " << mysql_error(objDatos) << endl;
      mysql_close(objDatos);
      getchar();
      return 1;
   }

   // Conectar a base de datos.
   if(mysql_select_db(objDatos, "estudiante")) {
      cout << "ERROR: " << mysql_error(objDatos) << endl;
      mysql_close(objDatos);
      getchar();
      return 2;
   }

   // Hacer una consulta con el comando "SELECT * FROM datos":
   if(mysql_query(objDatos, "SELECT * FROM datos")) {
      cout << "ERROR: " <<  mysql_error(objDatos) << endl;
      mysql_close(objDatos);
      getchar();
      return 2;
   }

   // Almacenar el resultado de la consulta:
   if((res = mysql_store_result(objDatos))) {
      // Obtener el número de registros seleccionados:
      int i = (int) mysql_num_rows(res);
      // Obtener el número de columnas por fila:
      int j = (int) mysql_num_fields(res);
      for(int l = 0; l < i; l++) {
      MYSQL_ROW   row = mysql_fetch_row(res);
         // Mostramos cada campo
         for(int k = 1 ; k < j ; k++)
            cout << row[k] << ((k==j-1)? " ": ", " ) ;
         cout << endl;
      }
  mysql_free_result(res);
   }
 mysql_close(objDatos);   

   getchar();
   return 0;
}

::El SQL::

--Estructura de tabla para crear la tabla 'datos'
CREATE TABLE IF NOT EXISTS 'datos' (
  'idEstudiante' int(3) NOT NULL AUTO_INCREMENT,
  'nombre' text NOT NULL,
  'identificacion' text NOT NULL,
  'edad' int(3) NOT NULL,
  PRIMARY KEY ('idEstudiante')
) ENGINE=MyISAM  DEFAULT CHARSET=latin1 AUTO_INCREMENT=3 ;

-- Datos para la tabla 'datos'
INSERT INTO 'datos' ('idEstudiante', 'nombre', 'identificacion', 'edad') VALUES
(1, 'Andrea', '1.010.101.010 de Bogota', 28),
(2, 'Catalina', '1.012.312.010 de Bogota', 30)

Después de compilar y ejecutar el proyecto, nos debe dar como resultado un listado de estudiantes con sus datos personales, bueno en este caso Resultado

Recuerda

Que no debes dejar de revisar la documentación pertinente y con eso te informas más sobre lo que aparece en este post. Eso es muy importante! Documentación ahh y obviamente si algo no quedó claro, de una no dudes en decirlo, así mejoramos el tema.

Arrancaremos con Php, todos alguna vez hemos hecho una conexion a mysql con php, porque es la más sencilla y porque existe bastante documentación de cómo realizarla en la web, bueno en esta ocasión una vez más mostraremos cómo llevarla a cabo, pero además veremos más adelante en paralelo la forma de hacerlo con Java y C/C++, a lo que quizás nosotros como estudiantes le tenemos un poco de sustillo.

Para los que no saben como hacerlo, entraré en detalle en cada uno de las líneas, si queda algo inconcluso, de una me avisan, así lo aclaramos..

Conexión con Php

Creamos un archivo que se llame funciones.php, allí creamos la función Conectarse(), en ella damos los datos básicos de siempre, tales como el servidor, el usuario y la contraseña, si se conecta al servidor entonces intentamos conectarnos a la base de datos.

<?php
   function Conectarse()
   {
      if (!($link=mysql_connect("localhost","root",""))){
         echo "Error conectando al servidor.";
         exit();
      }
      if (!mysql_select_db("datos",$link)){
         echo "Error seleccionando la base de datos.";
         exit();
      }
     return $link;
   }
?>

De nuevo creamos un nuevo archivo index.php, en él vamos a hacer ejecutar la conexión y hacer una consulta básica, así obtendremos la info de la base de datos.

<?php
	include ("funciones.php");
	$enlace = Conectarse();
?>
<body>
	<?php
		$consulta = mysql_db_query("datos","select * from estudiante");

		while($estudiante = mysql_fetch_array($consulta)){
	?>
    	<p>Nombre: <?php echo $estudiante['nombre'];?><br />
       	      Identificacion: <?php echo $estudiante['identificacion'];?><br />
              Edad: <?php echo $estudiante['edad']; ?>
        </p>
    <?php
		}
	?>
</body>
<?php
	mysql_close($enlace);
?>

Este sería el resultado de lo que acabamos de hacer… sí, lo sé, está simple, pero el resto queda para su creatividad. Resultado

Pero espera, recuerda que…

No hay que dejar de consultar las fuentes de información, pasa por php.net y mira más a fondo lo que vimos en este post.

¿Qué hay de nuevo?

En realidad lo nuevo es como hacer el llamado de mail(), como se puede ver recibe como parámetros el correo al que queremos enviar, el asunto, el mensaje, y la cabecera del mensaje, ésta es la que nos muestra el formato de donde viene el correo (en este caso).

<?php
	$para = "ceamha@gmail.com";
	$desde = "micorreo@correo.com";
	$cabecera = "From: ". $desde . " <" . $desde . ">\r\n";

	$asunto = "Envio de correo con php";
	$comentario = "Nuestro mensaje en el correo";
	mail ($para, $asunto, $comentario, $cabecera);
?>

Cuando lo ejecutemos en nuestra bandeja de entrada vamos a ver un nuevo correo así:

Y si vemos el contenido, podemos observar que tiene el comentario que queríamos que apareciera

Esta es la forma más sencilla de hacerlo, el ejemplo sencillito, si ya quieres hacer algo más complejo, solo es que pruebes!
Ahh no olvides ver la documentación de la función en la página oficial