int main()
{
	printf("Hola mundo\n");
	return 0;
}
]]>

void f2(); // declaracion, prototipo, (signature)
void f1();

double maximo = -13.499990; // variable global

int main()
{
	f1();
	printf("Se llamo a main(). maximo = %lf\n", maximo);
	return 0;
}

void f1()
{
	printf("Se llamo a f1(). maximo = %.2lf\n", maximo);
	f2();
}

void f2()
{
	printf("Se llamo a f2()\n");
	maximo *= -1.0/2.0;
	if ( -.0001 )
		printf("-1/2 == 0: %i\n", -1/2 == 0);
}
]]>

int main()
{
	int a = 1;
	std::cout << "++a + a = " << ++a + a << std::endl;

	int c = 1;
	std::cout << "c + ++c + ++c = " << c + ++c + ++c << std::endl;

	int b = 1;
	std::cout << "b++ + b = " << b++ + b << std::endl;

	return 0;
}
]]>

int main()
{
	int DD, MM, AAAA;
	int hh, mm;

	printf("Su fecha de nacimiento [DD/MM/AAAA hh:mm]? ");
	scanf("%i/%i/%i %i:%i", &DD, &MM, &AAAA, &hh, &mm);

	printf("En formato universal: %04i-%02i-%02iT%02i:%02i:%02i\n"
		, AAAA, MM, DD, hh, mm, 0);
	return 0;
}
]]>

int main()
{
	int minimo = 0;
	printf("Minimo: ");
	scanf("%i", &minimo);

	int maximo = 0;
	printf("Maximo: ");
	scanf("%i", &maximo);

	for ( int i = minimo; i <= maximo; ++i )
	{
		for ( int j = minimo; j <= maximo; ++j )
			printf("%5i ", i * j);

		printf("\n");
	}

	return 0;
}
]]>

#include 

typedef long double real;

int main()
{
	FILE* archivo = fopen("gr08.txt", "r");
	if ( ! archivo )
	{
		fprintf(stderr, "No se pudo abrir %s\n", "gr08.txt");
		return 1;
	}

	real minimo = DBL_MAX;
	real maximo = -DBL_MAX;
	real valor = 0.0;
	real suma = 0.0;
	unsigned long long contador = 0;

	while ( fscanf(archivo, "%Lf", &valor) != EOF )
	{
		++contador;
		if ( valor < minimo ) minimo = valor;
		if ( valor > maximo ) maximo = valor;
		suma += valor;
	}
	fclose(archivo);

	if ( contador > 0 )
	{
		printf("Minimo: %.2Lf\n", minimo);
		printf("Maximo: %.2Lf\n", maximo);
		printf("Promedio: %.2Lf\n", suma / contador);
	}

	return 0;
}
]]>

#include 

// La cantidad de veces que se va a invocar cada versión de la función para hacer el benchmark
const size_t ITERACIONES = 50000000;

// Crea un tipo de datos nuevo: entero_t que equivale a unsinged long int
typedef unsigned long int entero_t;


// Retorna true si valor es una potencia de 2. El cálculo se hace con divisiones enteras
bool es_potencia_de_2_v1(entero_t valor)
{
	// Divide el valor original sucesivamente por 2 y si todos los módulos fueron 0 es porque
	// el número era una potencia de 2. Apenas no sea divisible por 2 retorna false
	for ( ; valor > 1; valor /= 2 )
		if ( valor %2 != 0 )
			return false;

	return true;
}

// Retorna true si valor es una potencia de 2. El cálculo se hace con operadores de bits
bool es_potencia_de_2_v2(entero_t valor)
{
	// Si el resultado de un AND binario de un número y su predecesor es 0, es una potencia
	// de 2: http://www.cprogramming.com/tutorial/bitwise_operators.html
	return !(valor & (valor - 1));
}


// Defínase esta macro al invocar el compilador para generar un ejecutable con benchmark. Ej:
//     g++ -DBENCHMARK potencia2.cpp -o potencia2_benchmark
#if defined(BENCHMARK)

// Invoca ITERACIONES veces cada una de las dos versiones de la función es_potencia_de_2 y
// cronometriza cuanto tarda cada una y finalmente imprime sus duraciones en segundos; con
// el fin de determinar cuál de las dos versiones es más eficiente
int main()
{
	// [1] Primera versión de es_potencia_de_2: con divisiones enteras
	// Se registra el tick del reloj del procesador en que la primera versión inició su ejecución
	clock_t inicio = clock();

	// Se invoca es_potencia_de_2_v1() ITERACIONES veces y se cuenta cuántas potencias encuentra
	// entre 1 e ITERACIONES, sólo con fines ilustrativos, lo que importa es correr la función
	// muchas veces y cronometrizarla
	size_t conteo_potencias_2 = 0;
	for ( size_t i = 0; i < ITERACIONES; ++i )
		if ( es_potencia_de_2_v1(i) )
			++conteo_potencias_2;

	// Imprimir lo que tardó la versión 1 de la función es_potencia_de_2 con divisiones
	// la diferencia 'clock() - inicio' indica la cantidad de ticks del reloj que transcurrieron
	// mientras se hicieron las ITERACIONES invocaciones. Para convertirlas a segundos se debe
	// hacer división flotante entre la macro CLOCKS_PER_SEC
	std::cout << conteo_potencias_2 << " potencias encontradas con divisiones en "
		<< (static_cast(clock() - inicio) / CLOCKS_PER_SEC) << " segundos" << std::endl;


	// [2] Se repite el proceso anterior con la segunda versión de es_potencia_de_2: con
	// operadores de bits
	inicio = clock();
	conteo_potencias_2 = 0;
	for ( size_t i = 0; i < ITERACIONES; ++i )
		if ( es_potencia_de_2_v2(i) )
			++conteo_potencias_2;

	std::cout << conteo_potencias_2 << " potencias encontradas con operadores de bits "
		<< (static_cast(clock() - inicio) / CLOCKS_PER_SEC) << " segundos" << std::endl;

	return 0;
}

#else // defined(BENCHMARK)

// Permite al usuario ingresar números interactivamente, y muestra cuáles de ellos son
// potencias de 2
int main()
{
	while ( true )
	{
		// Lee un entero de la entrada estándar (usualmente el teclado)
		entero_t valor = 0;
		std::cout << "Número: ";
		std::cin >> valor;

		// Si se ingresó 0, se termina la invocación de main() retornando 0 al sistema operativo
		if ( valor == 0 ) return 0;

		// Si es otro valor, se indica en la salida estándar si es o no potencia de 2
		// Los paréntesis redondos aquí son obligatorios, dado que el operador << tiene
		// precedencia sobre el operador ternario ?:
		std::cout << valor << (es_potencia_de_2_v2(valor) ? " " : " no ") << "es potencia de dos"
			<< std::endl << std::endl;
	}

	return 0;
}

#endif // defined(BENCHMARK)
]]>

void swap(int* a, int* b)
{
	int t = *a;
	*a = *b;
	*b = t;
}

int main()
{
	int a = 1;
	int b = 2;
	printf("a=%i, b=%i\n", a, b);
	swap(&a, &b);
	printf("a=%i, b=%i\n", a, b);

	return 0;
}
]]>

using namespace std;

int main()
{
	cout << "Hola mundo" << " C++" << endl;
	return 0;
}
]]>

using std::cin;
using std::cout;
using std::endl;

class Entero
{
  protected:
	long valor;

  public:
	Entero(long valor)
		: valor(valor)
	{
	}

	bool esPar()
	{
		return valor % 2 == 0;
	}

	void imprimirPropiedades()
	{
		cout << valor << " es par: " << esPar() << endl;
	}
};

int main()
{
	long valor = 0;
	cout << "Número: ";
	cin >> valor;

	Entero entero(valor);
	entero.imprimirPropiedades();

	return 0;
}
]]>

// Todo lo que se defina dentro de ucr se debe acceder como ucr::algo
namespace ucr
{
	// una variable global dentro del espacio de nombres ucr
	double cout = 0.0;

	// Las clases y estructuras son otros espacios de nombres
	struct Impresora
	{
		static bool cout;
	};

	bool Impresora::cout = false;
} // namespace ucr

// Una varable global accesible como ::cout desde cualquier contexto
char cout = '\n';

int main()
{
	// Una variable local tapa a la variable global homonima
	int cout = 0;
	cout = 1;
	std::cout << "cout = " << cout << std::endl;

	// Accede a la variable global, que se encuentra en el contexto global ::
	::cout = 'z';
	std::cout << "::cout = " << ::cout << std::endl;

	// Accede a una variable global dentro de un espacio de nombres llamado ucr
	ucr::cout = 3.14;
	std::cout << "ucr::cout = " << ucr::cout << std::endl;

	// Accede a un miembro de una clase o estructura que esta dentro de un namespace
	ucr::Impresora::cout = true;
	std::cout << "ucr::Impresora::cout = " << ucr::Impresora::cout << std::endl;

	// C++ sabe cual es el cout de la std, imprimir su tamanno en bytes
	std::cout << "sizeof(std::cout) = " << sizeof(std::cout) << std::endl;

	return 0;
}
]]>

// Por defecto los miembros de una estructura son publicos en C++
struct Fecha
{
	int dia;
	int mes;
	int anno;

	// Las estructuras y las clases pueden tener metodos
	// Los constructores son metodos especiales que se invocan siempre que
	// un objeto es creado con el fin de inicializar los miembros de datos
	// Note la sintaxis para inicializar Constructor() : miembro(valorIni)
	Fecha(int d = 0, int m = 0, int a = 0) : dia(d), mes(m), anno(a) { }
};


// Las enumeraciones declaran un tipo de datos nuevo en el programa: un
// numero entero que solo puede tomar los valores declarados en el cuerpo
// de la enumeracion, que son constantes
enum Sexo
{
	desconocido, // 0
	hombre,      // 1
	mujer        // 2
};

// Textos equivalentes a las constantes de la enumeracion Sexo
const char* const SexoStr[] =
{
	"desconocido",
	"hombre",
	"mujer"
};


// Por defecto los miembros de una clase son privados en C++
class Persona
{
	private:
		long cedula;
		Fecha fechaNacimiento; // una estructura dentro de otra
		Sexo sexo;
		char* nombre;
		static long totalPersonas;

	public:
		static long obtenerTotalPersonas() { return totalPersonas; }

	public:
		// Constructor. Los miembros de datos se deben inicializar en el
		// mismo orden en que fueron declarados. El constructor Fecha() se
		// invoca automaticamente cuando llegue el turno de inicializar
		// la estructura fechaNacimiento
		Persona(long cedula = 0, const Fecha& fn = Fecha(), Sexo sexo = desconocido, const char* nombre = "");
		~Persona();

		// Un metodo: una funcion que esta dentro de una clase o estructura
		int calcularEdad() const;

		inline long obtenerCedula() const { return this->cedula; }
		inline const char* obtenerNombre() const { return nombre; }
		void imprimir() const;
}; // nunca olvidar los dos puntos

#endif
]]>

persona.h

#include 
#include 

// Las variables estaticas son variables globales, hay que darles memoria
long Persona::totalPersonas = 0;

// Constructor. Los miembros de datos se deben inicializar en el mismo orden en
// que fueron declarados. El constructor Fecha() se invoca automaticamente cuando
// llegue el turno de inicializar la estructura fechaNacimiento
Persona::Persona(long cedula, const Fecha& fn, Sexo sexo, const char* nombre)
	: cedula(cedula)
	, fechaNacimiento(fn)
	, sexo(sexo)
	, nombre(strdup(nombre))
{
	++totalPersonas;
}

Persona::~Persona()
{
	free(nombre);
}

// Un metodo: una funcion que esta dentro de una clase o estructura
int Persona::calcularEdad() const
{
	// El parametro Persona* this es automaticamente agregado por
	// el compilador de C++, es buena practica acceder a los miembros
	// a traves de this->miembro, pero no es necesario
	return 2013 - /*this->*/fechaNacimiento.anno;
}

void Persona::imprimir() const
{
	std::cout << cedula << ": " << nombre << ". " << SexoStr[sexo];
	//fechaNacimiento.imprimir();

	static long invocaciones = 0;
	++invocaciones;
	std::cout << "\nimprimir ha sido invocado " << invocaciones << " veces\n";
}
]]>

persona.cpp

//using std::cout;
//using std::endl;

//using namespace std;

int main()
{
	// Un metodo estatico solo puede acceder a variables estaticas
	std::cout << "total personas: " << Persona::obtenerTotalPersonas() << std::endl;

	// esto crea un objeto completo de ~104 bytes, no un puntero de 8 bytes ni una
	// refeferencia como ocurre en Java, y luego llama al constructor por defecto
	Persona persona;

	// Crea un objeto automatico persona1 utilizando el constructor mas general
	Persona persona1(101929328, Fecha(7,5,2000), mujer, "Ana Soto");
	persona1.imprimir();

	// Crea un ojeto en memoria dinamica con el operador new, el cual llama al constructor
	Persona* persona2 = new Persona(191990212, Fecha(), hombre);
	persona2->imprimir();

	// Crea un arreglo de objetos, a cada uno se le invoca el constructor por defecto
	Persona* familia = new Persona[3];
	for ( size_t i = 0; i < 3; ++i )
		familia[i].imprimir();
	for ( size_t i = 0; i < 3; ++i )
		familia[i].imprimir();

	// Imprime el total de objetos de la clase Persona creados hasta el momento
	std::cout << "total personas: " << Persona::obtenerTotalPersonas() << std::endl;

#if 0
	// persona es un objeto, no un puntero, por lo que se usa el operador .
	// para acceder a los miembros publicos
	std::cout << "Edad 1 en años cumplidos: " << persona1.calcularEdad() << std::endl;
	std::cout << "Edad 2 en años cumplidos: " << persona2->calcularEdad() << std::endl;
	std::cout << "Edad f.2 en años cumplidos: " << familia[1].calcularEdad() << std::endl;
#endif

	// persona2 es un objeto alojado en memoria dinamica, evitar fugas
	delete persona2;
	persona2 = NULL; // innecesario, pero es una buena practica

	// Eliminar un arreglo requiere el operador delete[] y no delete
	delete [] familia;

	return 0;
}
]]>

main.cpp

#include "Fraction.h"

int main()
{
#if 0
	Fraction arr[10];
	for (size_t i = 0; i < 10; ++i )
		std::cout << i << ": " << arr[i] << std::endl;
#endif

	std::cout << "Input first fraction (a/b): ";
	Fraction f1;
	std::cin >> f1;

	std::cout << "Input second fraction (a/b): ";
	Fraction f2;
	std::cin >> f2;

	std::cout << f1 << " * " << f2 << " = " << f1 * f2 << std::endl;
	std::cout << f1 << " + " << f2 << " = " << f1 + f2 << std::endl;

	return 0;
}
]]>

typedef long long FractionPart;

class Fraction
{
	private:
		FractionPart numerator;
		FractionPart denominator;

	public:
		// Default constructor allows building arrays of Fraction objects
		Fraction(FractionPart num = 0, FractionPart den = 1);
		~Fraction();
		inline FractionPart getNumerator() const { return numerator; }
		inline FractionPart getDenominator() const { return denominator; }
		Fraction operator*(const Fraction& other) const;
		bool simplify();
		static FractionPart greatestCommonDivisor(FractionPart a, FractionPart b);

	public:
		friend std::istream& operator>>(std::istream& input, Fraction& fraction);
		friend std::ostream& operator<<(std::ostream& output, const Fraction& fraction);
};

// cin >> f1 >> f2 >> ... >> fN
std::istream& operator>>(std::istream& input, Fraction& fraction);

// cout << f1 << f2 << ... << fN
std::ostream& operator<<(std::ostream& output, const Fraction& fraction);

// can be implemented as member function also
Fraction operator+(const Fraction& f1, const Fraction& f2);

#endif
]]>

Fraction::Fraction(FractionPart num, FractionPart den)
	: numerator(num)
	, denominator(den ? den : 1)
{
	simplify();
}

Fraction::~Fraction()
{
}

FractionPart Fraction::greatestCommonDivisor(FractionPart a, FractionPart b)
{
	a = abs(a);
	b = abs(b);

	while (b)
	{
		FractionPart t = b;
		b = a % t;
		a = t;
	}
	return a;
}

bool Fraction::simplify()
{
	FractionPart gdc = greatestCommonDivisor(numerator, denominator);
	numerator /= gdc;
	denominator /= gdc;
	return gdc > 1;
}

std::istream& operator>>(std::istream& input, Fraction& fraction)
{
	input >> fraction.numerator;

	// ignore '/' separator and whitespace
	while ( isspace(input.get()) )
		;

	return input >> fraction.denominator;
}

std::ostream& operator<<(std::ostream& output, const Fraction& fraction)
{
	return output << fraction.numerator << '/' << fraction.denominator;
}

Fraction Fraction::operator*(const Fraction& other) const
{
	return Fraction(numerator * other.numerator, denominator * other.denominator);
}

Fraction operator+(const Fraction& f1, const Fraction& f2)
{
	return Fraction(f1.getNumerator() * f2.getDenominator()
		+ f1.getDenominator() * f2.getNumerator()
		, f1.getDenominator() * f2.getDenominator() );
}
]]>

#include "Fraccion.h"

using namespace std;

int main()
{
	cout << "Ingrese una fracción en formato a/b: ";
	Fraccion f1;
	cin >> f1;

	Fraccion f2;
	f2 = 2;

	cout << "Ingrese una tercera fracción en formato a/b: ";
	Fraccion f3;
	cin >> f3;

	cout << "-1 + " << f1 << " + " << f2 << " + " << f3 << " = " << -1 + f1 + f2 + f3 << endl;
	return 0;
}
]]>

typedef long long entero;

class Fraccion
{
  private:
	entero numerador;
	entero denominador;

  public:
	/// Constructor por defecto y constructor de conversion
	Fraccion(entero numerador = 0, entero denominador = 1);
	/// Destructor
	~Fraccion();
	// La relacion de amistad permite a los operadores sobrecargados como funciones libres acceder
	// a los miembros privados y protegidos de los objetos Fraccion
	friend std::ostream& operator<<(std::ostream& salida, const Fraccion& fraccion);
	friend std::istream& operator>>(std::istream& entrada, Fraccion& fraccion);
	friend Fraccion operator+(const Fraccion& a, const Fraccion& b);
};

/// Permite cout << f1 << f2 << ...
std::ostream& operator<<(std::ostream& salida, const Fraccion& fraccion);

/// Permite cin >> f1 >> f2 >> ...
std::istream& operator>>(std::istream& entrada, Fraccion& fraccion);

/// Permite f1 + f2
/// Permite f1 + 13
/// Permite 13 + f2
/// Nunca se invoca con dos tipos primitivos como: 13 + 2
Fraccion operator+(const Fraccion& a, const Fraccion& b);

#endif // FRACCION_H
]]>

Fraccion::Fraccion(entero numerador, entero denominador)
	: numerador(numerador)
	, denominador(denominador)
{
}

Fraccion::~Fraccion()
{
}

std::ostream& operator<<(std::ostream& salida, const Fraccion& fraccion)
{
	return salida << fraccion.numerador << '/' << fraccion.denominador;
}

std::istream& operator>>(std::istream& entrada, Fraccion& fraccion)
{
	entrada >> fraccion.numerador;
	entrada.ignore();
	entrada >> fraccion.denominador;
	return entrada;
}

Fraccion operator+(const Fraccion& a, const Fraccion &b)
{
	return Fraccion(a.numerador * b.denominador + a.denominador * b.numerador
		, a.denominador * b.denominador);
}
]]>

#include 

int eprintf(int errorcode, const char* format, ...)
{
	va_list list;
	va_start(list, format);
	vfprintf(stderr, format, list);
	va_end(list);
	return errorcode;
}

]]>

#include 
#include "String.h"

using namespace std;

int main()
{
	// Llama al constructor de conversion. Equivale a String s1 = String("Hola mundo");
	String s1 = "Hola mundo";

	// Llama al constructor por defecto
	String s2;

	// Llama al operador de asignacion
	s2 = s1;

	// Verifica el contenido de cada objeto
	std::cout << s1 << endl;
	std::cout << s2 << endl;

	// Concatena un String con el operador +
	// El String temporal resultado de filename + ".idx" se envia como primer parametro de
	// fopen(const char*, const char*), es decir, un objeto String esta en un contexto
	// donde se requiere un const char*, el operador de conversion es invocado entonces
	String filename = "horoscopo.txt";
	FILE* index = fopen(filename + ".idx", "r");
	if ( ! index )
		cerr << "No se pudo abrir " << (filename + ".idx") << endl;
	else
		fclose(index);

	return 0;
}
]]>

#include 

const int null = 0;

#define implicit


/** @class String
	@brief Facilita el trabajo con cadenas de caracteres de C
*/
class String
{
  private:
	/// La cadena de C terminada en nulo. Siempre tiene memoria alojada en segmento de heap
	char* str;
	/// La longitud actual de la cadena apuntada por @a str
	size_t len;

  public:
	/// Constructor por defecto y de conversion
	/// ToDo: recibir un parametro 'size_t len = (size_t)-1' por si el llamador conoce el length
	implicit String(const char* str = "");
	/// Crea un buffer con la capacidad dada
	explicit String(size_t capacity);
	/// Constructor de copia. Se invoca cuando
	/// String str2 = str1;
	/// String str3 = String("algo");
	/// String str4 = "algo";
	/// void foo(String str5); foo("algo");
	String(const String& other);
	/// Operador de asignacion. Se invoca cuando
	/// String str1;
	/// str1 = str0;
	/// str1 = String("algo");
	/// str1 = "algo";
	const String& operator=(const String& other);
	/// Destructor
	~String();
	/// Retorna la cantidad de caracteres almacenados en el String
	inline size_t length() const { return len; }
	/// Permite acceder al string de C solo para lectura
	inline const char* c_str() const { return str; }
	/// Permite utilizar un objeto String en un contexto donde se requiere un const char*
	inline operator const char*() const { return str; }
	/// Permite acceder al i-esimo caracter almacenado en el String
	/// El caracter puede ser modificado por el llamador, lo cual afectara al objeto String
	/// @remarks No se verifica que @a i este fuera de rango
	inline char& operator[](size_t i) { return str[i]; }
	/// Permite acceder al caracter i-simo del String en modo solo lectura
	/// @remarks No se verifica que @a i este fuera de rango
	inline const char& operator[](size_t i) const { return str[i]; }
	/// Obtiene el sub-string de length caracteres a partir del caracter start
	String substr(size_t start, size_t length = (size_t)-1) const;
	/// Obtiene el sub-string de length caracteres a partir del caracter start
	String operator()(size_t start, size_t length = (size_t)-1) const;

	// Amistad con los operadores sobrecargados para que puedan acceder a los miembros de datos
	friend std::ostream& operator<<(std::ostream& output, const String& str);
	friend String operator+(const String& a, const String& b);
};

/// Permite cout << str1 << str2 << ...
std::ostream& operator<<(std::ostream& output, const String& str);

/// Permite str1 + str2
String operator+(const String& a, const String& b);

#endif // STRING_H
]]>

#include 

String::String(const char* str)
	: str( strdup(str) )
	, len( strlen(str) )
{
}

String::String(size_t capacity)
	: str( (char*) malloc(capacity ? capacity : 1) )
	, len(0)
{
	*str = '\0';
}

String::String(const String &other)
	: str( strdup(other.str) )
	, len( other.len )
{
}

const String& String::operator =(const String &other)
{
	// Evita fugas de memoria si se asgina el objeto a si mismo
	if ( this != &other )
	{
		free(str);
		str = strdup(other.str);
		len = other.len;
	}
	return *this;
}

String::~String()
{
	free(str);
}

std::ostream& operator<<(std::ostream& output, const String& str)
{
	return output << str.str;
}

String operator+(const String& a, const String& b)
{
	size_t newLen = a.len + b.len;
	String resultado( newLen + 1 );
	strcpy(resultado.str, a.str);
	strcpy(resultado.str + a.len, b.str );
	resultado.len = newLen;
	return resultado;
}

]]>

#include "Array.h"

using std::cout;
using std::endl;
using std::cin;

int main()
{
	Array arr;
	Array arr2;

	char value = char();
	while ( cin >> value )
		arr.add(value);

	for (size_t i = 0; i < arr.count(); ++i )
		cout << i << ": " << arr[i] << endl;

	return 0;
}

]]>

const size_t incrementFactor = 2;
const size_t initialCapacity = 10;

template 
class Array
{
  private:
	/// The count of elements stored in the array
	size_t size;
	/// The quantity of elements that can be stored in the array
	/// without asking for more memory
	size_t capacity;
	/// A C-type array of elements
	DataType* arr;

  public:
	/// Default constructor and conversion constructor
	explicit Array(size_t capacity = initialCapacity);
	/// Destructor
	~Array();
	/// Adds a copy of the given value to the ending position of the array
	/// @return true if the element was added, false if no enough memory is available
	bool add(const DataType& element);
	/// Returns the number of elements stored in the array
	inline size_t count() const { return size; }
	/// Gets read and write access to the i-th element
	inline DataType& operator[](size_t i) { return arr[i]; }
	/// Gets read-only access to the i-th element
	inline const DataType& operator[](size_t i) const { return arr[i]; }

  private:
	/// Copy constructor
	Array(const Array& other);
	/// Assignment operator
	const Array& operator=(const Array& other);
	/// Makes room for more values
	bool incrementArray();
};

#include 

template 
Array::Array(size_t capacity)
	: size(0)
	, capacity(capacity ? capacity : initialCapacity)
	, arr( new DataType[capacity] )
{
	assert(arr);
}

template 
Array::~Array()
{
	delete [] arr;
}

template 
bool Array::add(const DataType &element)
{
	if ( size == capacity )
		if ( ! incrementArray() )
			return false;

	arr[size++] = element;
	return true;
}

template 
bool Array::incrementArray()
{
	size_t newCapacity = capacity * incrementFactor;
	DataType* newArr = new DataType[newCapacity];
	if ( ! newArr ) return false;

	for ( size_t i = 0; i < size; ++i )
		newArr[i] = arr[i];

	capacity = newCapacity;
	delete [] arr;
	arr = newArr;
	return true;
}

#endif // ARRAY_H
]]>

#include "Queue.h"

using namespace std;

int main()
{
	Queue cola;
	double data = 0.0;
	while ( cin >> data )
		cola.add(data);
	cout << cola << endl;

	for ( Queue::ConstIterator itr = cola.begin(); itr != cola.end(); ++itr)
		cout << *itr << ", ";

	cout << endl;

#if 0
	cin.clear();
	Queue colaStr;
	string text;
	while ( cin >> text )
		colaStr.add(text);
	cout << colaStr << endl;
#endif

	return 0;
}
]]>

const int null = 0;

template 
class Queue
{
  private:

	/// For each element stored in the queue, a Node is created to keep pointers to
	/// the next element. Note Node is for Queue class use exclusively (private)
	struct Node
	{
		/// A copy of the original element to be stored in the queue
		DataType data;
		/// A pointer to the next node in the queue
		Node* next;

	  public:
		/// Conversion constructor
		explicit Node(const DataType& data) : data(data), next(null) { }
	};

  private:
	/// A pointer to the first node in the queue. Null if queue is empty
	Node* head;
	/// A pointer to the last node in the queue. Null if queue is empty
	Node* tail;
	/// The count of elements currently stored in the queue
	size_t size;

  public:
	/// Default constructor
	Queue() : head(null), tail(null), size(0) { }
	/// Destructor: when the queue is destroyed, all its values are deleted also
	~Queue()
	{
		clear();
	}
	/// Returns true if queue is empty
	inline bool empty() const { return head == null; }
	/// Adds a copy of the given element into the queue
	/// @return true on success, false if not enough memory
	bool add(const DataType& data)
	{
		Node* node = new Node(data);
		if ( ! node ) return false;

		if ( empty() )
			tail = head = node;
		else
			tail = tail->next = node;

		return ++size;
	}
	/// Remove all elements from the queue
	void clear()
	{
		for ( Node* node = head; head; node = head)
		{
			head = head->next;
			delete node;
		}

		tail = null;
		size = 0;
	}
	/// Prints all elements of the queue to the given output stream
	/// @param output File or stream to print
	/// @param separator Each element will be separated from another with this text
	std::ostream& print(std::ostream& output, const char* separator = " ") const
	{
		for ( Node* node = head; node; node = node->next)
			output << node->data << separator;
		return output;
	}

  public:
	/// Allows traversing the queue or pointing to a specific value in the queue
	class ConstIterator
	{
	  private:
		/// An iterator mimics a pointer to this element which is stored in the queue
		const Node* node;

	  public:
		/// Default constructor and conversion constructor
		explicit ConstIterator(const Node* node = null) : node(node) { }
		/// Returns true if this iterator points to the same element than other iterator
		inline bool operator!=(const ConstIterator& other) const { return node != other.node; }
		/// Get read-only access to the pointed element in array
		inline const DataType& operator*() const { return node->data; }
		/// Pre-increment operator: ++itr
		const ConstIterator& operator++()
		{
			node = node->next;
			return *this;
		}
		/// Post-increment operator: itr++
		ConstIterator operator++(int)
		{
			ConstIterator previous(node);
			node = node->next;
			return previous;
		}
	};

	/// Returns an iterator to the first element in the queue
	inline ConstIterator begin() const { return ConstIterator(head); }
	/// Returns an iterator to an invalid position in the queue
	inline ConstIterator end() const { return ConstIterator(); }

  private:
	Queue(const Queue& other);
	const Queue& operator=(const Queue& other);
};

/// Allows std::cout << myqueue1 << myqueue2 << ... ;
template 
std::ostream& operator<<(std::ostream& output, const Queue& queue)
{
	return queue.print(output);
}

#endif // QUEUE_H
]]>

int main()
{
	BinarySearchTree tree;
	double valor;

	while ( true )
	{
		std::cout << "Valor " << tree.count() + 1 << ": ";
		std::cin >> valor;
		if ( valor == 0.0 )
			break;
		tree.insert(valor);
	};

	size_t i = 0;
	for ( typename BinarySearchTree::ConstIterator itr = tree.begin(); itr != tree.end(); ++itr )
		std::cout << ++i << ": " << *itr << std::endl;

	std::cout << std::endl;
	return 0;
}
]]>

#include 

template 
class less
{
  public:
	bool operator()(const DataType& a, const DataType& b) const
	{
		return a < b ? a : b;
	}
};

template  >
class BinarySearchTree
{
  private:
	class Node
	{
	  friend class BinarySearchTree;
	  private:
		DataType data;
		Node* parent;
		Node* left;
		Node* right;

	  public:
		Node(const DataType& data, Node* parent = null, Node* left = null, Node* right = null)
			: data(data), parent(parent), left(left), right(right)
		{
		}

		~Node()
		{
			delete left;
			delete right;
		}
	};

  private:
	Node* root;
	size_t elementCount;

  public:
	BinarySearchTree() : root(null), elementCount(0) { }
	~BinarySearchTree() { delete root; }
	inline size_t count() const { return elementCount; }
	/// @return true if the value was successfully inserted in the tree,
	/// false if not enough memory
	bool insert(const DataType& value)
	{
		Comparator comp;
		Node **node = &root, *parent = null;
		for ( ; *node; node = comp(value, (*node)->data) ? &(*node)->left : &(*node)->right )
			parent = *node;

		*node = new Node(value, parent);
		return *node ? ++elementCount : 0;
	}
	void clear()
	{
		delete root;
		root = null;
		elementCount = 0;
	}

	void print() const
	{
		print(root);
	}


  private:
	void print(Node* node) const
	{
		if ( ! node ) return;
		print(node->left);
		std::cout << node->data << ' ';
		print(node->right);
	}

	static Node* minimum(Node* node)
	{
		while ( node && node->left )
			node = node->left;
		return node;
	}

	static Node* findNextNode(Node* node)
	{
		if ( node->right )
			return minimum(node->right);

		while ( node->parent && node->parent->right == node )
		{
			node = node->parent;
			if ( ! node->parent ) return null;
		}

		if ( node->parent && node->parent->left == node )
			node = node->parent;

		return node;
	}

  public:
	class ConstIterator
	{
	  private:
		Node* ptr;
	  public:
		explicit ConstIterator(Node* ptr) : ptr(ptr) { }
		inline const DataType& operator*() const { return ptr->data; }
		inline bool operator==(const ConstIterator& other) const { return ptr == other.ptr; }
		inline bool operator!=(const ConstIterator& other) const { return ptr != other.ptr; }
		ConstIterator& operator++()
		{
			return moveToNextNode();
		}
		ConstIterator operator++(int)
		{
			ConstIterator result = *this;
			moveToNextNode();
			return result;
		}
	  private:
		ConstIterator& moveToNextNode()
		{
			if ( ! ptr ) return *this;
			Node* next = BinarySearchTree::findNextNode(ptr);
			ptr = ptr == next ? (Node*)null : next;
			return *this;
		}
	};

	ConstIterator begin() const
	{
		return ConstIterator( minimum(root) );
	}

	ConstIterator end() const { return ConstIterator(null); }
};

#endif // BINARYSEARCHTREE_H
]]>

#include 

#include 
#include 

#include 
#include "PreguntaSeleccionUnica.h"

using namespace std;

int main()
{
	vector preguntas;
	PreguntaSeleccionUnica pregunta;

	ifstream archivo("preguntas.txt");
	while ( archivo >> pregunta )
		preguntas.push_back(pregunta);
	archivo.close();

	for ( size_t i = 0; i < preguntas.size(); ++i )
		cout << preguntas[i];

	return 0;
}
]]>

#include 
#include 

class Pregunta
{
  protected:
	std::string texto;
	size_t respuesta;

  public:
	Pregunta();

  private:
	friend std::istream& operator>>(std::istream& in, Pregunta& pregunta);
	friend std::ostream& operator<<(std::ostream& out, const Pregunta& pregunta);
};

// cin >> pregunta
std::istream& operator>>(std::istream& in, Pregunta& pregunta);
// cout << pregunta
std::ostream& operator<<(std::ostream& out, const Pregunta& pregunta);

#endif // PREGUNTA_H
]]>

>(std::istream& in, Pregunta& pregunta)
{
	const size_t bufferSize = 2048;
	char buffer[bufferSize];
	in.getline(buffer, bufferSize);
	pregunta.texto = buffer;

	in >> pregunta.respuesta; in.ignore();
	return in;
}

std::ostream& operator<<(std::ostream& out, const Pregunta& pregunta)
{
	out << pregunta.texto << std::endl << "Respuesta: " << pregunta.respuesta << std::endl;
	return out;
}
]]>

 opciones;

  public:
	PreguntaSeleccionUnica();

  private:
	friend std::istream& operator>>(std::istream& in, PreguntaSeleccionUnica& pregunta);
	friend std::ostream& operator<<(std::ostream& out, const PreguntaSeleccionUnica& pregunta);
};

// cin >> pregunta
std::istream& operator>>(std::istream& in, PreguntaSeleccionUnica& pregunta);
// cout << pregunta
std::ostream& operator<<(std::ostream& out, const PreguntaSeleccionUnica& pregunta);


#endif // PREGUNTASELECCIONUNICA_H
]]>

>(std::istream& in, PreguntaSeleccionUnica& pregunta)
{
	const size_t bufferSize = 2048;
	char buffer[bufferSize];

	in.getline(buffer, bufferSize);
	pregunta.texto = buffer;
	in >> pregunta.respuesta; in.ignore();

	pregunta.opciones.clear();
	for ( size_t i = 0; i < 4; ++i )
	{
		in.getline(buffer, bufferSize);
		pregunta.opciones.push_back(buffer);
	}

	in.ignore();
	return in;
}

std::ostream& operator<<(std::ostream& out, const PreguntaSeleccionUnica& pregunta)
{
	for ( size_t i = 0; i < pregunta.opciones.size(); ++i )
		out << '\t' << i + 1 << ": " << pregunta.opciones[i] << std::endl;
	return out << std::endl;
}


]]>

#include 
#include "PreguntaSeleccionUnica.h"
#include "PreguntaAbierta.h"

using namespace std;

int main()
{
	vector preguntas;
	string tipo;

	ifstream archivo("preguntas.txt");
	while ( archivo >> tipo )
	{
		archivo.ignore();
		if ( tipo == "abierta" )
		{
			PreguntaAbierta* pregunta = new PreguntaAbierta();
			archivo >> *pregunta;
			preguntas.push_back(pregunta);
		}
		else if ( tipo == "seleccion_unica" )
		{
			PreguntaSeleccionUnica* pregunta = new PreguntaSeleccionUnica();
			archivo >> *pregunta;
			preguntas.push_back(pregunta);
		}
	}
	archivo.close();

	for ( size_t i = 0; i < preguntas.size(); ++i )
		cout << * preguntas[i];

	size_t contador = 0;
	for ( size_t i = 0; i < preguntas.size(); ++i )
	{
		PreguntaSeleccionUnica* psu = dynamic_cast(preguntas[i]);
		if ( psu )
			++contador;

		delete preguntas[i];
	}
	cout << endl << contador << " preguntas de seleccion unica eliminadas" << endl;

	return 0;
}
]]>

#include 
#include 

class Pregunta
{
  protected:
	std::string tipo;
	std::string texto;
	std::string respuesta;

  public:
	Pregunta(const std::string& tipo);
	virtual ~Pregunta() { }
	std::istream& leer(std::istream& in);
	virtual std::ostream& imprimir(std::ostream& out) const;
//	virtual size_t aplicar() const = 0;
};

// cin >> pregunta
inline std::istream& operator>>(std::istream& in, Pregunta& pregunta)
{
	return pregunta.leer(in);
}

// cout << pregunta
inline std::ostream& operator<<(std::ostream& out, const Pregunta& pregunta)
{
	return pregunta.imprimir(out);
}

#endif // PREGUNTA_H
]]>

 opciones;

  public:
	PreguntaSeleccionUnica();
	virtual ~PreguntaSeleccionUnica() { }
	std::istream& leer(std::istream& in);
	virtual std::ostream& imprimir(std::ostream& out) const;
};

// cin >> pregunta
inline std::istream& operator>>(std::istream& in, PreguntaSeleccionUnica& pregunta)
{
	return pregunta.leer(in);
}

// cout << pregunta
inline std::ostream& operator<<(std::ostream& out, const PreguntaSeleccionUnica& pregunta)
{
	return pregunta.imprimir(out);
}

#endif // PREGUNTASELECCIONUNICA_H
]]>

#include 
#include "PreguntaSeleccionUnica.h"
#include "PreguntaAbierta.h"

using namespace std;

Pregunta* crearPregunta(const string& tipo)
{
	if ( tipo == "abierta" ) return new PreguntaAbierta();
	if ( tipo == "seleccion_unica" ) return new PreguntaSeleccionUnica();
	return 0;
}

int main()
{
	vector preguntas;
	string tipo;

	ifstream archivo("preguntas.txt");
	while ( archivo >> tipo )
	{
		archivo.ignore();
		Pregunta* pregunta = crearPregunta(tipo);
		archivo >> *pregunta;
		preguntas.push_back(pregunta);
	}
	archivo.close();

	for ( size_t i = 0; i < preguntas.size(); ++i )
		cout << * preguntas[i] << endl;

	for ( size_t i = 0; i < preguntas.size(); ++i )
		delete preguntas[i];

	return 0;
}
]]>

#include 
#include 

class Pregunta
{
  protected:
	std::string tipo;
	std::string texto;
	std::string respuesta;

  public:
	Pregunta(const std::string& tipo);
	virtual ~Pregunta() { }
	virtual std::istream& leer(std::istream& in);
	virtual std::ostream& imprimir(std::ostream& out) const;
	/// Aplica la pregunta al jugador. ES decir, le hace la pregunta y espera la respuesta.
	/// Retorna la cantidad de puntos obtenidos por el jugador, lo cual depende de si
	/// contesto o no correctamente la pregunta.
	virtual int aplicar() const = 0;
};

// cin >> pregunta
inline std::istream& operator>>(std::istream& in, Pregunta& pregunta)
{
	return pregunta.leer(in);
}

// cout << pregunta
inline std::ostream& operator<<(std::ostream& out, const Pregunta& pregunta)
{
	return pregunta.imprimir(out);
}

#endif // PREGUNTA_H
]]>

 opciones;

  public:
	PreguntaSeleccionUnica();
	virtual ~PreguntaSeleccionUnica() { }
	virtual std::istream& leer(std::istream& in);
	virtual std::ostream& imprimir(std::ostream& out) const;
};

#endif // PREGUNTASELECCIONUNICA_H
]]>

#include 
#include 

#include "Student.h"
#include "Employee.h"

void print_population(const vector& population)
{
	for (size_t i = 0; i < population.size(); ++i)
		population[i]->print(cout);

}

// Factory method. It could be a class
Person* createPerson(const string& role)
{
	if ( role == "estudiante" )
		return new Student();
	if ( role == "administrativo" )
		return new Employee();
	// ...
	return NULL;
}

int main()
{
	ifstream source("poblacion.txt");
	vector population;

	string role;
	while ( source >> role )
	{
		Person* person = createPerson(role);
		if ( person )
		{
			person->load(source);
			population.push_back(person);
#if 0
			Student* temp = dynamic_cast(person);
			if ( temp )
				temp->specificMethodOfStudent();
#endif
		}
	}

	source.close();
	print_population(population);

	for (size_t i = 0; i < population.size(); ++i)
		delete population[i];

	return 0;
}
]]>

using namespace std;

enum SocioeconomicalStatus
{
	  socioeconomicalStatusUnknown

	, socioeconomicalStatusPoor
	, socioeconomicalStatusLow
	, socioeconomicalStatusMedium
	, socioeconomicalStatusHigh
	, socioeconomicalStatusRich

	, socioeconomicalStatusCount
};

const char* const SocioeconomicalStatusStr[] =
{
	  "unknown"

	, "poor"
	, "low"
	, "medium"
	, "high"
	, "rich"

	, ""
};

class Person
{
  protected:
	long id;
	string name;
	string birthDate;

  public:
	explicit Person(long id = 0.0, const string& name = "", const string& birthDate = "");
	virtual ~Person() { }
	virtual istream& load(istream& output);
	virtual ostream& print(ostream& output) const;
	virtual SocioeconomicalStatus getSocioeconomicalStatus() const = 0; // pure virtual method

  private:
	Person(const Person& other);
	const Person& operator=(const Person& other);
};

inline istream& operator>>(istream& in, Person& person) { return person.load(in); }
inline ostream& operator<<(ostream& out, const Person& person) { return person.print(out); }
istream& readline(istream& in, string& str);

#endif // PERSON_H
]]>

> id; in.ignore();
	return readline(in, name) >> birthDate;
}

ostream& Person::print(ostream& output) const
{
	return output << id << ": " << name << " (" << birthDate << ')'
				  << " status=" << SocioeconomicalStatusStr[getSocioeconomicalStatus()];
}

istream& readline(istream& in, string& str)
{
	char buffer[1024];
	in.getline(buffer, 1024);
	str = buffer;
	return in;
}
]]>

>(istream& in, Student& student);
ostream& operator<<(ostream& out, const Student& student);

#endif // 0

#endif // STUDENT_H
]]>

> carnet >> ppm;
	input.ignore();
	return readline(input, majors);
}

ostream &Student::print(ostream &output) const
{
	return Person::print(output) << ' ' << carnet << ": " << ppm
			   << " [" << majors << "]" << endl;
}

#if 0

istream& operator>>(istream& in, Student& student)
{
	in >> (Person&)student >> student.carnet >> student.ppm;
	in.ignore();
	return readline(in, student.majors);
}

ostream& operator<<(ostream& out, const Student& student)
{
	return out << (const Person&)student << student.carnet << ": " << student.ppm
			   << " [" << student.majors << "]" << endl;
}

#endif // 0
]]>

Employee::Employee()
	: salary(0.0) // base class' default constructor is called here
{
}

istream &Employee::load(istream &input)
{
	Person::load(input) >> salary;
	input.ignore();
	return readline(input, departments);
}

ostream &Employee::print(ostream &output) const
{
	return Person::print(output)
			<< " c" << fixed << setprecision(2) << salary << ": " << departments << endl;
}

SocioeconomicalStatus Employee::getSocioeconomicalStatus() const
{
	if ( salary > 5000000 ) return socioeconomicalStatusRich;
	if ( salary > 1500000 ) return socioeconomicalStatusHigh;
	if ( salary > 750000 ) return socioeconomicalStatusMedium;
	if ( salary > 400000 ) return socioeconomicalStatusLow;
	if ( salary > 0 ) return socioeconomicalStatusPoor;
	return socioeconomicalStatusUnknown;
}
]]>

int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	MainWindow mainWindow;
	mainWindow.show();

	return app.exec();
}
]]>

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
	Q_OBJECT

private:
	Ui::MainWindow *ui;

public:
	explicit MainWindow(QWidget *parent = 0);
	~MainWindow();

private slots:
	bool openFile();
};

#endif // MAINWINDOW_H
]]>

#include 

MainWindow::MainWindow(QWidget *parent) :
	QMainWindow(parent),
	ui(new Ui::MainWindow)
{
	ui->setupUi(this);
	connect(ui->actionOpen, SIGNAL(triggered(bool)), this, SLOT(openFile()));
}

MainWindow::~MainWindow()
{
	delete ui;
}

bool MainWindow::openFile()
{
	QString fileName = QFileDialog::getOpenFileName(this);
	if ( fileName.isEmpty() ) return false;

	QFile file(fileName);
	if ( ! file.open(QIODevice::ReadOnly | QIODevice::Text) )
		return false;

	ui->textEdit->setPlainText( QString( file.readAll() ) );
	return true;
}
]]>

    
        icons/document-new.png
        icons/document-open.png
        icons/document-save.png
        icons/edit-copy.png
        icons/edit-cut.png
        icons/edit-paste.png
        icons/edit-redo.png
        icons/edit-undo.png
    

]]>

#include 

class Question; // forward declaration

static const QString triviaFilename = "Trivia.xml";

class TriviaApp : public QApplication
{
	Q_OBJECT

  protected:
	QVector questions;

  public:
	TriviaApp(int argc, char* argv[]);
	~TriviaApp();
	int exec();
	static Question* createQuestion(const QString& type);

  protected:
	bool loadQuestions();
	void printQuestions() const;

signals:

public slots:

};

#endif // TRIVIAAPP_H
]]>

#include 
#include 
#include "Question.h"

TriviaApp::TriviaApp(int argc, char* argv[]) :
	QApplication(argc, argv)
{
}

TriviaApp::~TriviaApp()
{
	qDeleteAll(questions);
}

int TriviaApp::exec()
{
	if ( ! loadQuestions() ) return 1;

	printQuestions();

	return 0;
}

inline bool showError(const QString& message)
{
	QMessageBox::critical(0, "Error", message);
	return false;
}

bool TriviaApp::loadQuestions()
{
	QFile file(triviaFilename);
	if ( ! file.open(QIODevice::ReadOnly | QIODevice::Text) )
		return showError( QString("Could not open %1").arg(triviaFilename) );

	QDomDocument document("trivia");
	QString errorMsg;
	int errorLine = 0;
	int errorColumn = 0;
	if ( ! document.setContent(&file, &errorMsg, &errorLine, &errorColumn) )
	{
		file.close();
		return showError(QString("%1:%2.%3: %4")
			.arg(triviaFilename).arg(errorLine).arg(errorColumn).arg(errorMsg));
	}
	file.close();

	QDomElement triviaElement = document.documentElement();
	for( QDomNode node = triviaElement.firstChild(); ! node.isNull(); node = node.nextSibling() )
	{
		QDomElement element = node.toElement(); // try to convert the node to an element.
		if( element.isNull() || element.tagName() != "question" ) continue;

		Question* question = createQuestion(element.attribute("type"));
		if ( ! question->loadFromNode(element) )
		{
			// Hubo una pregunta mala. Que hacer con ella?
			delete question;
			continue;
		}

		questions.append(question);
	}

	return true;
}

void TriviaApp::printQuestions() const
{
	for ( int i = 0; i < questions.count(); ++i )
		questions[i]->print();
}

Question* TriviaApp::createQuestion(const QString& /*type*/)
{
	//if ( type == "single_choice" ) return new SingleChoiceQuestion();
	//if ( type == "numeric" ) return new NumericQuestion();
	//...
	return new Question();
}
]]>

class QDomElement;

class Question
{
  protected:
	QString text;
	QString answer;

  public:
	Question();
	virtual ~Question();
	virtual bool loadFromNode(const QDomElement& element);
	virtual void print() const;
};

#endif // QUESTION_H
]]>

Question::Question()
{
}

Question::~Question()
{
}

bool Question::loadFromNode(const QDomElement& element)
{
	for ( QDomNode child = element.firstChild(); ! child.isNull(); child = child.nextSibling() )
	{
		QDomElement element = child.toElement();
		if ( element.isNull() ) continue;

		if ( element.tagName() == "text" )
			text = element.text();
		else if ( element.tagName() == "answer" )
			answer = element.text();
	}
	return true;
}

#include 

void Question::print() const
{
	std::cout << '[' << qPrintable(text) << ": " << qPrintable(answer) << ']' << std::endl;
}
]]>

	
		Cuantos metros hay en un kilometro?
		1000
	

	
		Quien tiene 4 estomagos?
		2
		
			Una gallina
			Una vaca
			El Botija
			Una maquina tragamonedas
		
	

	
		Si a < b, & b < 0, entonces el valor de a es?
		negativo
	

	

]]>

int main(int argc, char *argv[])
{
	QApplication app(argc, argv);
	MainWindow window;
	window.show();

	return app.exec();
}
]]>

namespace Ui
{
	class MainWindow;
}

class ConnectDialog;

class MainWindow : public QMainWindow
{
	Q_OBJECT

  private:
	Ui::MainWindow *ui;
	ConnectDialog* connectDialog;

  public:
	explicit MainWindow(QWidget *parent = 0);
	virtual ~MainWindow();
	QString getUserNickname() const;

  public slots:
	void newConnection();
	void dataReceived(const QString& text);
	void connectionEstablished();
	void connectionLost();

  signals:
	void sendMessage(const QString& text) const;

  protected slots:
	void buttonSendPressed();

  protected:
	bool createConnectDialog();
};

#endif // MAINWINDOW_H
]]>

setupUi(this);
	connect( ui->actionConnect, SIGNAL(triggered(bool)), this, SLOT(newConnection()) );
	connect( ui->buttonSend, SIGNAL(clicked()), this, SLOT(buttonSendPressed()) );
}

MainWindow::~MainWindow()
{
	delete ui;
}

QString MainWindow::getUserNickname() const
{
	Q_ASSERT(connectDialog);
	return connectDialog->getUserNickname();
}

void MainWindow::newConnection()
{
	if ( ! createConnectDialog() ) return;

	// Show the dialog, if it is already shown, this call has no effect
	connectDialog->show();

	// If dialog is already shown, make it top and active
	connectDialog->raise();
	connectDialog->activateWindow();
}

void MainWindow::dataReceived(const QString& text)
{
	ui->whiteBoard->append(text);
}

void MainWindow::connectionEstablished()
{
	ui->inputMessage->setEnabled(true);
	ui->buttonSend->setEnabled(true);
	qDebug("Connection established");
}

void MainWindow::connectionLost()
{
	ui->inputMessage->setEnabled(false);
	ui->buttonSend->setEnabled(false);
	qDebug("Connection lost");
}

bool MainWindow::createConnectDialog()
{
	// If already created, done
	if ( connectDialog ) return true;

	// Create a dialog and test for success
	connectDialog = new ConnectDialog(this);
	if ( ! connectDialog ) return false;

	return true;
}

void MainWindow::buttonSendPressed()
{
	QString text = ui->inputMessage->document()->toPlainText().trimmed();
	text = '[' + getUserNickname() + "] " + text;
	ui->whiteBoard->append(text);
	emit sendMessage(text);
	ui->inputMessage->document()->setPlainText("");
}

]]>

class QPushButton;
class ChatServer;
class ChatClient;

namespace Ui
{
	class ConnectDialog;
}

class ConnectDialog : public QDialog
{
	Q_OBJECT

  private:
	Ui::ConnectDialog *ui;
	QPushButton* buttonConnect;
	ChatServer* chatServer;
	ChatClient* chatClient;

  public:
	explicit ConnectDialog(QWidget *parent = 0);
	virtual ~ConnectDialog();
	QString getUserNickname() const;

  protected slots:
	void tryEnableConnectButton();
	void serverModeSelected();
	void clientModeSelected();
	void buttonConnectPressed();

  protected:
	bool canEnableConnectButton() const;
	bool connectAsServer();
	bool connectAsClient();
};

#endif // CONNECTDIALOG_H
]]>

#include "ChatServer.h"
#include "ChatClient.h"
#include "MainWindow.h"

ConnectDialog::ConnectDialog(QWidget *parent) :
	QDialog(parent),
	ui(new Ui::ConnectDialog),
	chatServer(NULL),
	chatClient(NULL)
{
	ui->setupUi(this);

	buttonConnect = ui->buttonBox->addButton(tr("&Connect"), QDialogButtonBox::AcceptRole);
	buttonConnect->setDefault(true);
	buttonConnect->setEnabled(false);
	connect( buttonConnect, SIGNAL(clicked()), this, SLOT(buttonConnectPressed()) );

	connect( ui->buttonBox, SIGNAL(rejected()), this, SLOT(close()) );
	connect( ui->radioButtonServerMode, SIGNAL(clicked()), this, SLOT(serverModeSelected()) );
	connect( ui->radioButtonClientMode, SIGNAL(clicked()), this, SLOT(clientModeSelected()) );

	// Try to enable connect button
	connect( ui->lineEditNickname, SIGNAL(textChanged(QString)), this, SLOT(tryEnableConnectButton()) );
	connect( ui->lineEditAddress, SIGNAL(textChanged(QString)), this, SLOT(tryEnableConnectButton()) );
	connect( ui->lineEditPort, SIGNAL(textChanged(QString)), this, SLOT(tryEnableConnectButton()) );
}

ConnectDialog::~ConnectDialog()
{
	delete ui;
}

QString ConnectDialog::getUserNickname() const
{
	return ui->lineEditNickname->text().trimmed();
}

void ConnectDialog::tryEnableConnectButton()
{
	buttonConnect->setEnabled( canEnableConnectButton() );
}

void ConnectDialog::serverModeSelected()
{
	ui->lineEditAddress->setEnabled(false);
	tryEnableConnectButton();
}

void ConnectDialog::clientModeSelected()
{
	ui->lineEditAddress->setEnabled(true);
	tryEnableConnectButton();
}

void ConnectDialog::buttonConnectPressed()
{
	ui->radioButtonServerMode->isChecked() ? connectAsServer() : connectAsClient();
}

bool ConnectDialog::canEnableConnectButton() const
{
	// Nickname is always required
	if ( ui->lineEditNickname->text().trimmed().isEmpty() )
		return false;

	// Address (IP or domain) is only required in client mode
	if ( ui->radioButtonClientMode->isChecked() && ui->lineEditAddress->text().trimmed().isEmpty() )
		return false;

	// Port is always required
	if ( ui->lineEditPort->text().trimmed().isEmpty() ) return false;

	// Everything is suffixed, connect button can be enabled
	return true;
}

bool ConnectDialog::connectAsServer()
{
	if ( ! chatServer ) chatServer = new ChatServer(this);
	int port = ui->lineEditPort->text().toInt();
	if ( ! chatServer->listen(QHostAddress::Any, port) )
	{
		qDebug("Failed to bind to port %i", port);
		return false;
	}

	qDebug("Listening in port %i", port);
	close();
	return true;
}

bool ConnectDialog::connectAsClient()
{
	MainWindow* mainWindow = dynamic_cast(parent());
	Q_ASSERT(mainWindow);

	if ( ! chatClient ) chatClient = new ChatClient(mainWindow, this);
	QString address = ui->lineEditAddress->text();
	int port = ui->lineEditPort->text().toInt();
	chatClient->connectToHost(address, port);
	qDebug("Connecting to server %s:%i...", qPrintable(address), port);
	connect(chatClient, SIGNAL(connected()), this, SLOT(close()));
	return true;
}
]]>

class ChatServer : public QTcpServer
{
	Q_OBJECT

  public:
	explicit ChatServer(QObject *parent = 0);

  protected:
	virtual void incomingConnection(int socketId);
	virtual void incomingConnection(qintptr socketId);
};

#endif // CHATSERVER_H
]]>

(parent()->parent());
	Q_ASSERT(mainWindow);

	ChatClient* socket = new ChatClient(mainWindow, this);
	if ( ! socket->setSocketDescriptor(socketId) )
		return qDebug("Server: incomming connection REJECTED");

	qDebug("Server: incomming connection accepted");
	mainWindow->connectionEstablished();

	// This chat is only for 2 peers, after connection is established, stop listening
	close();
}

void ChatServer::incomingConnection(qintptr socketId)
{
	return incomingConnection((int)socketId);
}
]]>

class MainWindow;

class ChatClient : public QTcpSocket
{
	Q_OBJECT

  protected:
	MainWindow* mainWindow;

  public:
	explicit ChatClient(MainWindow* mainWindow, QObject *parent = 0);

  signals:

  protected slots:
	void dataReceived();
	void sendData(const QString& text);
};

#endif // CHATCLIENT_H
]]>

dataReceived(text);
	qDebug("Data received: \"%s\"", qPrintable(text));
}

void ChatClient::sendData(const QString& text)
{
	write( text.toUtf8() );
	qDebug("Data sent: \"%s\"", qPrintable(text));
}
]]>