Quienes programamos en MFC Visual C++ algunas veces hemos tenido que eliminar los espacios en blanco de una cadena y sucede que la clase CString no tenia una sola funcion trim, sino las funciones TrimLeft y TrimRight.

Nose por que diablos demoraron tanto (o no se dieron cuenta) en agregar esa funcioncita.

Lo que se hacia normalmente es:

m_sCadena.TrimLeft();

m_sCadena.TrimRight();

Esto ahora ha causado un problema de compatibilidad con las versiones anteriores y no creo que sea la unica.

Al empezar con esto de la programacion uno adopta una forma de escribir el codigo. Este codigo no siempre es bien visto por quienes tiene experiencia (como si se tratara de caligrafia).

No habia nada dicho al respecto de los estandares de codigo fuente, pero muchos se animaron a establecer estandares de «caligrafia» para el C/C++.

En este enlace pueden encontrar reglas que pueden seguir sin miedo para escribir sus programas en C/C++:

Coding Standards
http://www.possibility.com/Cpp/CppCodingStandard.html

GNU tiene sus propios estandares que hay que seguir para escribir codigo para GNU Linux. Se podria decir que es lo mismo, pero en este caso estas reglas estan hechas no solo para escribir codigo limpio sino tambien para que otros programadores entiendan lo que uno ha programado.

GNU Coding Standards
http://www.gnu.org/prep/standards/standards.html

Por mi parte puedo contarles que no me agrada mucho escribir las funciones de esta manera:

void
funcion (var1,var2)
int var1,
int var2
{
  //...
}

Por otro lado es mejor tener los corchetes bien acomodados para entender los bloques.

Prefiero que se vea asi:

int main(int argc, char *argv[])
{
	char str[80];
	while(cin.getline(str,80))
	{
		int len = strlen(str);
		cout<<endl;
		for(int i = 0 ; i < len ; i++)
		{
			cout<<ind(str[i],0,44);
		}
	}
	return 0;
}

que asi:

int main(int argc, char *argv[]){
	char str[80];
	while(cin.getline(str,80)){
		int len = strlen(str);
		cout<<endl;
		for(int i = 0 ; i < len ; i++)
		 cout<<find(str[i],0,44);
	}
	return 0;
}

Minesweeper es uno de los cientos de problemas de la ACM, la idea es basicamente elaborar un programa que resuelva o simule ej juego del buscaminas. Pueden ver los detalles del problema en esta pagina: http://acm.uva.es/p/v101/10189.html

El problema planteado solamente tiene una entrada simple, pero pueda que la solución que estén elaborando no contemple todas las posibilidades. Para ello implementé un programita en c++ para generar entradas de ejemplo para el programa que estén desarrollando del tamaño que se indique, puede serles de mucha utilidad para testear sus programas.

#include <iostream.h>
int main(int argc, char* argv[])
{
    if(argc < 3)
    {
       cout<<"\nUso:\t"<<argv[0]<<" [N] [M] ";
       return 1;
    }

    int n = atoi(argv[1]);
    int m = atoi(argv[2]);
    cout<<n<<" "<<m<<endl;
    for(int i = 0; i < n ;i++)
    {
       for(int j = 0; j < m ;j++)
       {
          if(rand()%14 == 0)
          {
             cout<<"*";
          }else
          {
             cout<<".";
          }
       }
       cout<<endl;
    }
   cout<<"0 0";
	return 0;
}

El programa produce la siguiente salida.

15 30
...............*.....*........
.*.....*......................
.................*.*...*......
...*.......*.*.....*..........
....................*.........
.............*...............*
........*.................*...
*.....*...*........*..........
..............*....*......*...
.*............................
.........*..........*.........
.......*.*....................
................*.............
..*.*....*....*..*.........*..
..............................
0 0

La salida de sus soluciones debería ser como sigue:

Field #1:
111000111000001*10001*10000000
1*10001*1000001121212121100000
11211011101121101*3*201*100000
001*1000001*2*10113*3111100000
00111000001132200012*100000011
0000000111001*100001110001111*
11000112*21111100011100001*111
*10001*212*10111002*2000022200
22100111011101*1002*200001*100
1*1000001110011100122100011100
111000113*2000000001*100000000
0000001*3*20000111011100000000
0112111132200112*2100000001110
01*2*1001*1001*22*100000001*10
011211001110011111100000001110

Si necesitas alguna ayuda adicional puedes consultarla en el foro de programación c++.

Los grafos son un tipo de estructuras de datos; no voy a explicar exactamente de que se tratan los grafos pero pueden encontrar mas información al respecto aqui.

Llegar a implementar en forma básica listas, árboles y grafos es una parte importante en los inicios de la carrera de un programador. Por lo que estoy preparando pequeño artículo sobre como implementar grafos.

Lo interesante de este articulo, que desarrollé hace algunos años, es que lo combiné con un algoritmo de ordenación grafica basada en distancias y para que el parpadeo no moleste lo implementé con double buffering.

Aquí un recorte de muestra del programa en ejecución.

Pueden descargarse un demo ejecutable, por lo pronto, en el siguiente enlace:

grafos.zip

Cuando lo tenga completamente listo voy a publicarlo documentado y podrán descargarlo con código fuente que podran compilar en diferentes sistemas operativos. Espero que luego les pueda servir como punto de inicio y llegar mas lejos con las estructuras de datos.

Update: Pueden descargar el artículo de la siguiente dirección:

Implementacion de Double Buffer en Visual C++:
http://www.latindevelopers.com/vcpp/bitmap/doble-buffer/