====== Examen Final - 75.42. Taller de programación I ======

**Cátedra:** Veiga\\
**Fecha:** 1er Cuatrimestre 2007\\
**Día:** 17/07/2007\\
**Tema:** 3

<note important>
Esta página está incompleta; podés ayudar completando el material.
</note>

===== Enunciado =====
  - **Codifique** un ejemplo que muestre la **necesidad** de declarar el **operator<** como **const**
  - Escriba un programa para ambiente gráfico **Windows/Linux** que cree **una ventana**
  - Escriba una aplicación **ANSI C** que tome **dos nros. hexadecimales por línea de comandos e imprima su resta** (primero - segundo) **en base octal**
  - Escriba un programa **ANSI C** que modifique el archivo **enteros.bin** sobre sí mismo, **pasando los enteros de 32 bits** leídos de **little-endian** a **big-endian**.
  - ¿Qué formas existen de **detener** un **thread**.
  - ¿Por qué la función **BIND** toma como parámetro una estructura que tiene una **IP**? ¿en qué casos sirve esa **IP**?
  - Para implementar una **lista genérica**, se puede optar por el uso de **templates** o **punteros**. **Enumere** las ventajas de cada método.
  - ¿Qué significa la palabra **static** cuando precede a una **declaración de un método** de una clase? **Ejemplifique**.
  - ¿Puede un **constructor de copia** recibir su **parámetro por valor**? **Justifique**. 
  - Escriba un trozo de código **ANSI C** que muestre:
    - Una **declaración** de una **variabe carcter sin signo, global, no visible fuera del fuente**, llamada **X**.
    - Una **definición** de una **función** llamada **MiFuncion** que tome **un arreglo de enteros largos con signo** y devuelva un **puntero a caracter**.
    - Una **definición** de un **arreglo de 10 punteros a entero**, llamado **Y**.

===== Resolución =====


==== Punto I ====
<code cpp>
void ImprimirMenor ( const Complejo& A, const Complejo& B)
{
	if (A < B)
		std::cout << A;
	else
		std::cout << B;
}
</code>

Esta función (como cualquier otra que tome parametros const) no podria hacer uso de aquellos métodos no indicados como que no modifican la instancia.


==== Punto II ====
<code c>
int main (int argc, char* argv[])
{
	GtkWindow* window;
	gtk_init(&argc, &argv);
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	gtk_widget_show (window);
	gtk_main ();
	return 0;
}
</code>

==== Punto III ====
Cabe aclarar que al momento de explicar este tema, Veiga dejo claro que no era necesario control alguno sobre los parametros.
<code c>
int main (int argc, char* argv[])
{
	char* primero = argv[1];
	char* segundo = argv[2];

	/* O armen una función que reste un par de valores hexadecimales */
	char resultado = ( ( valor(primero[0]) - valor(segundo[0]) ) <<4 ) +
			   ( valor(primero[1]) - valor(segundo[1]) ) ;

	print_octal (resultado);

	return 0;
}

char valor (char c)
{
	if (c >= '0') && (c <= '9')
		return (c - '0');

	switch (c)
	{
		case 'A': return 10;
		case 'B': return 11;
		case 'C': return 12;
		case 'D': return 13;
		case 'E': return 14;
		case 'F': return 15;
		default: break;
	}
	return 0;
}

void print_octal (char c)
{
	do
		printf ("%c",(char)(c%8)+'0'));
		c/= 8;
	while (c > 0);
	printf ("\n");
}
</code>




==== Punto IV ====
Te aviso que la sintaxis no es 100% correcta pero deberia darte una idea de la solución.
<code c>
int main (int argc, char* argv[])
{
	char palabra[4];
	FILE* fd = open ("enteros.bin");

	if (fd < 0) return -1;

	while ( read(fd,&palabra,4) != EOF )
	{
		seek (fd, ???, -4);
		
		write (fd, &palabra[3],1);
		write (fd, &palabra[2],1);
		write (fd, &palabra[1],1);
		write (fd, &palabra[0],1);
	}

	return 0;
}
</code>
==== Punto V ====
Se puede detener un thread desde el mismo hilo de ejecución usando una función como ptrhead_exit, otra opción es terminar la ejecución de otro hilo desde la función pthread_kill enviando fla señal kill al descriptor correspondiente. Finalmente se puede detener la ejecución de un hilo a la espera de la finalización de otro con pthread_join.
==== Punto VI ====

==== Punto VII ====
Implementación con punteros
  * El espacio que ocupa LA ESTRUCTURA crece linealmente con las inserciones de datos
  * Existe un sólo código compilado, sin importar la cantidad de tipos para los que se la use
Implementación con templates
  * Es type-sage (Nadied podrá insertar elementos que no sean del tipo para el que fue instanciada). Esto evita casteos al acceder a un elemento.
  * Puede hacerse especialización para ciertos tipos, con fines de optimización
  * Sirve para cualquier tipo de datos, sin necesidad de casteos ni validaciones en runtime

==== Punto VIII ====
Al indicar un método como static se el mismo pasa a pertencer a la clase, y puede ser ejecutado sin la existencia de instancia alguna.
<code cpp>
class Clase A
{
	static std::string& getNombreClase() const { return "Clase A"; };
}
</code>
Esta clase A permite identificar su nombre (hay mejores mecanismos de RTTI), cosa util para por ejemplo la construcción dinamica de objetos.
==== Punto IX ====
No. Si el constructor de copia recibe su parametro por valor, una llamada al mismo se volveria recursiva, pues para cargar los datos de su parametro requeriria llamarse a si mismo.

==== Punto X ====
<code c>
/* Una variable caracter sin signo, global, no visible fuera del fuente, llamada X. */
static unsigned char X;
/* Definicion de una funcion llamada MiFuncion que tome un arreglo de enteros largos con signo y devuelva un puntero fa carácter. */
char* MiFuncion (long num[]) { return NULL;} ;
/* Definición de un arreglo de 10 punteros a entero, llamado Y. */
int* Y[10];
</code>

===== Discusión =====

<note warning>
Si ves algo que te parece incorrecto en la resolución y no te animás a cambiarlo, dejá tu comentario acá.
</note>