// Programa sobre pointers hacia un arreglo de arreglos y como pasarlos a funciones...
#include <iostream>

using namespace std;

void pruebav1(const float *vertex)
{
	cout << "Usando v1, apuntando a una dirección de punto flotante: \n";
	for (int i=0; i<12; i++)
	{
		cout << "Dirección: " << vertex + i;
		cout << " Valor: " << *(vertex+i) <<"\n";
	}

	cout << "\n";	
}

void pruebav2(const float *vertex, const float arreglo[4][3])
{
	cout << "Usando v2, apuntando a un arreglo: \n";
	for (int i=0; i<4; i++)
	{
		vertex = arreglo[i];
		for (int j=0; j<3; j++)
		{
			cout << "Dirección: " << vertex+j;
			cout << " Valor: " << *(vertex+j) <<"\n";
		}
	}

	cout << "\n";	
}

void pruebav3(const float (*vertex)[3])
{
	cout << "Usando v3, apuntando a un arreglo de arreglos: \n";
	/* v3 es un arreglo de pointers o un pointer a arreglos (de pointers),
	 * si incrementamos v3 por uno, la dirección a la que apunta incrementa por tres,
	 * que es en este caso el tamaño de la segunda dimensión de nuestro arreglo. Por ejemplo:
	 */

	for (int i=0; i<4; i++)
	{
		cout << "Dirección["<< i <<"]: " << vertex+i;
		cout << " Valor["<< i <<"]: " <<  *(vertex+i) <<"\n";
	}
	
	cout << "\n";
	
	/* Como se puede ver, el valor del apuntador es otro apuntador,
	 * si queremos obtener el primer valor del arreglo es necesario usar un pointer doble:
	 */

	cout << "Valor de la dirección a la que apunta v3: " << *vertex <<"\n";
	cout << "Valor del apuntador al que apunta v3: " << *(*vertex) <<"\n";

	// Podemos incrementar ambos pointers:
	cout << "Si v3 se incrementa por 1:\n";
	cout << "Dirección: " << vertex+1;
	cout << " Valor: " <<  *(vertex+1);
	cout << " Valor del apuntador: " <<  *(*(vertex+1)) <<"\n";

	cout << "\n";

	cout << "Si el apuntador al que apunta v3 se incrementa en 1:\n";
	cout << "Dirección: " << *vertex+1;
	cout << " Valor: " <<  *(*vertex+1) <<"\n";
}

int main()
{
/*	Esto fue lo que pensé inicialmente, está equivocado porque significa
 *  tres arreglos de cuatro elementos cada uno
 * 
 *	float vertices[3][4];
 *	
 *	vertices[0][0] = 0.0f ; vertices[1][0] = 1.0f ; vertices[2][0] = 2.0f ;
 *	vertices[0][1] = 3.0f ; vertices[1][1] = 4.0f ; vertices[2][1] = 5.0f ;
 *	vertices[0][2] = 6.0f ; vertices[1][2] = 7.0f ; vertices[2][2] = 8.0f ;
 *	vertices[0][3] = 9.0f ; vertices[1][3] = 10.0f ; vertices[2][3] = 11.0f ;
 */

	// Y quería cuatro arreglos de tres elementos cada uno (simulando puntos tridimensionales)
	float vertices[4][3];
	
	vertices[0][0] = 0.0f ; vertices[0][1] = 1.0f ; vertices[0][2] = 2.0f ;
	vertices[1][0] = 3.0f ; vertices[1][1] = 4.0f ; vertices[1][2] = 5.0f ;
	vertices[2][0] = 6.0f ; vertices[2][1] = 7.0f ; vertices[2][2] = 8.0f ;
	vertices[3][0] = 9.0f ; vertices[3][1] = 10.0f ; vertices[3][2] = 11.0f ;

	float * v1;
	float * v2;
	float (*v3)[3];
	
	v1 =&vertices[0][0];
	v2 = NULL;
	v3 = vertices;

/*	
	// Primero imprimimos la tabla dirección-valor usando v1
	
	cout << "Usando v1, apuntando a una dirección de punto flotante: \n";
	for (int i=0; i<12; i++)
	{
		cout << "Dirección: " << v1 + i;
		cout << " Valor: " << *(v1+i) <<"\n";
	}

	cout << "\n";
*/

	pruebav1(v1);

/*
	cout << "Usando v2, apuntando a un arreglo: \n";
	for (int i=0; i<4; i++)
	{
		v2 = vertices[i];
		for (int j=0; j<3; j++)
		{
			cout << "Dirección: " << v2+j;
			cout << " Valor: " << *(v2+j) <<"\n";
		}
	}

	cout << "\n";
*/

	pruebav2(v2,vertices);

/*	Los comentarios los dejé en pruebav3 para no tener comentarios anidados

	cout << "Usando v3, apuntando a un arreglo de arreglos: \n";

	for (int i=0; i<4; i++)
	{
		cout << "Dirección["<< i <<"]: " << v3+i;
		cout << " Valor["<< i <<"]: " <<  *(v3+i) <<"\n";
	}
	
	cout << "\n";
	
	cout << "Valor de la dirección a la que apunta v3: " << *v3 <<"\n";
	cout << "Valor del apuntador al que apunta v3: " << *(*v3) <<"\n";

	cout << "Si v3 se incrementa por 1:\n";
	cout << "Dirección: " << v3+1;
	cout << " Valor: " <<  *(v3+1);
	cout << " Valor del apuntador: " <<  *(*(v3+1)) <<"\n";

	cout << "\n";

	cout << "Si el apuntador al que apunta v3 se incrementa en 1:\n";
	cout << "Dirección: " << *v3+1;
	cout << " Valor: " <<  *(*v3+1) <<"\n";
*/

	pruebav3(v3);
	
	return 0;
}

Usando v1, apuntando a una dirección de punto flotante: 
Dirección: 0xbf91939c Valor: 0
Dirección: 0xbf9193a0 Valor: 1
Dirección: 0xbf9193a4 Valor: 2
Dirección: 0xbf9193a8 Valor: 3
Dirección: 0xbf9193ac Valor: 4
Dirección: 0xbf9193b0 Valor: 5
Dirección: 0xbf9193b4 Valor: 6
Dirección: 0xbf9193b8 Valor: 7
Dirección: 0xbf9193bc Valor: 8
Dirección: 0xbf9193c0 Valor: 9
Dirección: 0xbf9193c4 Valor: 10
Dirección: 0xbf9193c8 Valor: 11

Usando v2, apuntando a un arreglo: 
Dirección: 0xbf91939c Valor: 0
Dirección: 0xbf9193a0 Valor: 1
Dirección: 0xbf9193a4 Valor: 2
Dirección: 0xbf9193a8 Valor: 3
Dirección: 0xbf9193ac Valor: 4
Dirección: 0xbf9193b0 Valor: 5
Dirección: 0xbf9193b4 Valor: 6
Dirección: 0xbf9193b8 Valor: 7
Dirección: 0xbf9193bc Valor: 8
Dirección: 0xbf9193c0 Valor: 9
Dirección: 0xbf9193c4 Valor: 10
Dirección: 0xbf9193c8 Valor: 11

Usando v3, apuntando a un arreglo de arreglos: 
Dirección[0]: 0xbf91939c Valor[0]: [0, 1, 2]
Dirección[1]: 0xbf9193a8 Valor[1]: [3, 4, 5]
Dirección[2]: 0xbf9193b4 Valor[2]: [6, 7, 8]
Dirección[3]: 0xbf9193c0 Valor[3]: [9, 10, 11]

Valor de la dirección a la que apunta v3: [0, 1, 2]
Valor del apuntador al que apunta v3: 0
Si v3 se incrementa por 1:
Dirección: 0xbf9193a8 Valor: [3, 4, 5] Valor del apuntador: 3

Si el apuntador al que apunta v3 se incrementa en 1:
Dirección: 0xbf9193a0 Valor: 1