INSTITUTO TECNOLOGICO SUPERIOR DE ESCARCEGA

INGENIERIA EN SISTEMAS COMPUTACIONALES

“TOPICOS SELECTOS DE PROGRAMACION”

NOMBRE DE PROFESOR:

FRANCISCO BALLINA SANCHEZ.

NOMBRE DEL ALUMNO:

JOAQUIN ARMANDO MOO MEX.

TRABAJO:

TAREAS DE UNIDA 1 Y 2.

MATRICULA:

080201006

GRUPO:

ISMA 3

FECHA:

6/12/09

Escárcega, Campeche a 6 de Diciembre de 2009

LPT o Puerto Paralelo.

Aunque utilizados con mucha anterioridad, hasta la norma IEEE1284 en el 1.994 no se

normaliza.

Teóricamente el sistema de comunicación entre la impresora y el ordenador es mas o

menos simple, aunque varía según el conector. Pero básicamente el ordenador envía
impulsos a la impresora y esta responde conforme que puede seguir enviando o no, es lo
que se suele denominar una respuesta de tipo "Low", y si no da tiempo a la impresión
(prácticamente siempre será más rápido el envío que la salida impresa) se irá
almacenando en el buffer de memoria de la impresora. En el caso de que éste se agote y
siga recibiendo datos, responderá con un "busy" y la cola de impresión del ordenador se
detendrá a la espera de recibir el nuevo "Low".

Los puertos de impresión se configuran en la Bios del ordenador y se denominan LPT

(Line PrinTer) y hay algunas en que pueden configurarse 2 y en otras 4, las direcciones
varían, y cada uno tiene tres registros: el de datos, el de estado y el de control.

Los estándares iniciales, a partir de la normativa indicada, eran los SPP (Standard Parallel
Port), que es el original, o al menos el compatible, con lo que se denominó desde sus
inicios el puerto Centronics. Uno de los motivos de que impresoras antiguas no funcionen
con BIOS nuevas es que por defecto este venga deshabilitado, con lo que en la
configuración del LPT correspondiente hay que indicar que debe de ser compatible con
estos. Este modo acepta hasta un máximo de 150 kb por segundo.

http://www.elrinconcito.com/DiccAmpliado/LPT.htm

Parte transmisora:

 La parte transmisora checa la línea busy para ver si la parte receptora está ocupada. Si
la línea busy está activa, la parte transmisora espera en un bucle hasta que la línea busy
esté inactiva.
 La parte transmisora coloca la información en las líneas de datos.
 La parte transmisora activa la línea de strobe.
 La parte transmisora espera en un bucle hasta que la línea acknowledge está activa.
 La parte transmisora inactiva la línea de strobe.
 La parte transmisora espera en un bucle hasta que la línea acknowledge esté inactiva.
 La parte transmisora repite los pasos anteriores por cada byte a ser transmitido.

Parte receptora:

 La parte receptora inactiva la línea busy (asumiendo que está lista para recibir
información).
 La parte receptora espera en un bucle hasta que la línea strobe esté activa.
 La parte receptora lee la información de las líneas de datos (y si es necesario, procesa
los datos).
 La parte receptora activa la línea acknowledge.
 La parte receptora espera en un buclehasta que esté inactiva la línea de strobe.
 La parte receptora inactiva la línea acknowledge.
 La parte receptora repite los pasos anteriores por cada byte que debe recibir.

El hardware del puerto paralelo

El puerto paralelo de una típica PC utiliza un conector hembra de tipo D de 25 patitas

(DB-25 S), éste es el caso más común, sin embargo es conveniente mencionar los tres
tipos de conectores definidos por el estándar IEEE 1284, el primero, llamado 1284 tipo A
es un conector hembra de 25 patitas de tipo D, es decir, el que mencionamos al principio.
El orden de las patitas del conector es éste:

El segundo conector se llama 1284 tipo B que es un conector de 36 patitas de tipo

centronics y lo encontramos en la mayoría de las impresoras; el tercero se denomina
1284 tipo C, se trata de un conector similar al 1284 tipo B pero más pequeño, además se
dice que tiene mejores propiedades eléctricas y mecánicas, éste conector es el
recomendado para nuevos diseños. La siguiente tabla describe la función de cada patita
del conector 1284 tipo A:

Patita E/S Polaridad activa Descripción

1 Salida 0 Strobe
Líneas de datos
2~9 Salida -
(bit 0/patita 2, bit 7/patita 9)
Línea acknowledge
10 Entrada 0
(activa cuando el sistema remoto toma datos)
Línea busy
11 Entrada 0
(si está activa, el sistema remoto no acepta datos)
Línea Falta de papel
12 Entrada 1
(si está activa, falta papel en la impresora)
Línea Select
13 Entrada 1
(si está activa, la impresora se ha seleccionado)
Línea Autofeed
14 Salida 0 (si está activa, la impresora inserta una nueva
línea por cada retorno de carro)
Línea Error
15 Entrada 0
(si está activa, hay un error en la impresora)
Línea Init
(Si se mantiene activa por al menos 50
16 Salida 0
micro-segundos, ésta señal
autoinicializa la impresora)
 Línea Select input
17 Salida 0 (Cuando está inactiva, obliga a la
impresora a salir de línea)
18 ~ 25 - - Tierra eléctrica

Tabla 1: Configuración del puerto paralelo estándar

Observe que el puerto paralelo tiene 12 líneas de salida (8 líneas de datos, strobe,
autofeed, init, y select input) y 5 de entrada (acknowledge, busy, falta de papel, select y
error). El estándar IEEE 1284 define cinco modos de operación:

1. Modo compatible
2. Modo nibble
3. Modo byte
4. Modo EPP, puerto paralelo ampliado
5. Modo ECP, puerto de capacidad extendida

El objetivo del estándar es diseñar nuevos dispositivos que sean totalmente

compatibles con el puerto paralelo estándar (SPP) definido originalmente por la IBM (en
éste artículo trataré solamente el modo compatible). Hay tres direcciones de E/S
asociadas con un puerto paralelo de la PC, éstas direcciones pertenecen al registro de
datos, el registro de estado y el registro de control. El registro de datos es un puerto
de lectura-escritura de ocho bits. Leer el registro de datos (en la modalidad unidireccional)
retorna el último valor escrito en el registro de datos. Los registros de control y estado
proveen la interface a las otras líneas de E/S. La distribución de las diferentes señales
para cada uno de los tres registros de un puerto paralelo esta dada en las siguientes
tablas:

Dirección Nombre Lectura/Escritura Bit # Propiedades

Base + 0 Puerto de datos Escritura Bit 7 Dato 7
Bit 6 Dato 6
Bit 5 Dato 5
Bit 4 Dato 4
Bit 3 Dato 3
Bit 2 Dato 2
Bit 1 Dato 1
Bit 0 Dato 0

Tabla 2: Registro de datos

Dirección Nombre Lectura/Escritura Bit # Propiedades

Base + 1 Puerto de estado Sólo Lectura Bit 7 Busy
Bit 6 Acknowledge
Bit 5 Falta de papel
 Bit 4 Select In
Bit 3 Error
Bit 2 IRQ (Not)
Bit 1 Reservado
Bit 0 Reservado

Tabla 3: Registro de estado

Dirección Nombre Lectura/Escritura Bit # Propiedades

Base + 2 Puerto de control Lectura/Escritura Bit 7 No usado
Bit 6 No usado
Permite puerto
Bit 5
bidireccional
Permite IRQ a
través de la
Bit 4
línea
acknowledge
Selecciona
Bit 3
impresora
Inicializa
Bit 2
impresora
Nueva línea
Bit 1
automática
Bit 0 Strobe

Tabla 4: Registro de control

Una PC soporta hasta tres puertos paralelo separados, por tanto puede haber hasta
tres juegos de registros en un sistema en un momento dado. Existen tres direcciones
base para el puerto paralelo asociadas con tres posibles puertos paralelo: 0x3BCh,
0x378h y 0x278h, nos referimos a éstas como las direcciones base para el puerto LPT1,
LPT2 y LPT3, respectivamente. El registro de datos se localiza siempre en la dirección
base de un puerto paralelo, el registro de estado aparece en la dirección base + 1, y el
registro de control aparece en la dirección base + 2. Por ejemplo, para un puerto LPT2
localizado en 0x378h, ésta es la dirección del registro de datos, al registro de estado le
corresponde la dirección 0x379h y su respectivo registro de control está en la dirección
0x37Ah. Cuando la PC se enciende el BIOS ejecuta una rutina para determinar el número
de puertos presentes en el sistema asignando la etiqueta LPT1 al primer puerto
localizado, si existen más puertos entonces se asignarán consecutivamente las etiquetas
LPT2 y LPT3 de acuerdo a la siguiente tabla:

Dirección inicial Función

0000:0408 Dirección base para LPT1
0000:040A Dirección base para LPT2
 0000:040C Dirección base para LPT3
0000:040E Dirección base para LPT4

Tabla 5: Direcciones base en el BIOS

Puerto paralelo Centronics

El puerto paralelo más conocido es el puerto de impresora (que cumplen más o menos la
norma IEEE 1284, también denominados tipo Centronics) que destaca por su sencillez y
que transmite 8 bits. Se ha utilizado principalmente para conectar impresoras, pero
también ha sido usado para programadores EPROM, escáneres, interfaces de red
Ethernet a 10 MB, unidades ZIP, SuperDisk y para comunicación entre dos PC (MS-DOS
trajo en las versiones 5.0 ROM a 6.22 un programa para soportar esas transferencias).

El puerto paralelo de las computadoras, de acuerdo a la norma Centronics, está

compuesto por un bus de comunicación bidireccional de 8 bits de datos, además de un
conjunto de líneas de protocolo. Las líneas de comunicación cuentan con un retenedor
que mantiene el último valor que les fue escrito hasta que se escribe un nuevo dato, las
características eléctricas son:

 Tensión de nivel alto: 3,3 o 5 V.

 Tensión de nivel bajo: 0 V.
 Intensidad de salida máxima: 2,6 mA.
 Intensidad de entrada máxima: 24 mA.

Los sistemas operativos basados en DOS y compatibles gestionan las interfaces de

puerto paralelo con los nombres LPT1, LPT2 y así sucesivamente, Unix en cambio los
nombra como /dev/lp0, /dev/lp1, y demás. Las direcciones base de los dos primeros
puertos son:

 LPT1 = 0x378.
 LPT2 = 0x278

La estructura consta de tres registros: de control, de estado y de datos.

 El registro de control es un bidireccional de 4 bits, con un bit de configuración

que no tiene conexión al exterior, su dirección en el LPT1 es 0x37A.
 El registro de estado, se trata de un registro de entrada de información de 5 bits,
su dirección en el LPT1 es 0x379.
 El registro de datos, se compone de 8 bits, es bidireccional. Su dirección en el
LPT1 es 0x378.
 Inicialmente se colocó al puerto paralelo en la tarjeta del "Adaptador de impresora
de IBM", o también con la tarjeta del "monitor monocromático y adaptador de
impresora de IBM".
 Con la llegada de clones al mercado, se crea un controlador de múltiples entradas
y salidas (Multi I/O) donde se instalan controladores de discos, puertos serie,
puerto de juegos y el puerto paralelo.
 En la actualidad (2009) el puerto paralelo se incluye comúnmente incluido en la
placa madre de la computadora (MotherBoard). No obstante, la conexión del
 puerto con el mundo externo no ha sufrido modificaciones. Este puerto utiliza un
conector hembra DB25 en la computadora y un conector especial macho llamado
Centronic que tiene 36 pines.

Puerto serie

Puerto en serie ATX

Un puerto serie o puerto serial es una interfaz de comunicaciones de datos digitales,

frecuentemente utilizado por computadoras y periféricos, en donde la información es
transmitida bit a bit enviando un solo bit a la vez, en contraste con el puerto paralelo que
envía varios bits simultáneamente. La comparación entre la transmisión en serie y en
paralelo se puede explicar con analogía con las carreteras. Una carretera tradicional de
un sólo carril por sentido sería como la transmisión en serie y una autovía con varios
carriles por sentido sería la transmisión en paralelo, siendo los coches los bits.

Puerto serie asincrónico [editar]

El puerto serie RS-232 (también conocido como COM) es del tipo asincrónico, utiliza
cableado simple desde 3 hilos hasta 25 y que conecta computadoras o
microcontroladores a todo tipo de periféricos, desde terminales a impresoras y módems
pasando por mouses.

La interfaz entre el RS-232 y el microprocesador generalmente se realiza mediante una

UART 8250 (computadoras de 8 y 16 bits, PC XT) o 16550 (IBM Personal Computer/AT y
posteriores).

El RS-232 original tenía un conector tipo DB-25, sin embargo la mayoría de dichos pines
no se utilizaban, por lo que IBM estandarizó con su gama IBM Personal System/2 el uso
del conector DE-9 (ya introducido en el AT) mayoritariamente usado en computadoras.
Por contra, excepto en los mouses el resto de periféricos solían presentar el DB-25

En Europa la norma RS-422, similar al RS-232, es un estándar utilizado en el ámbito

industrial.

Puertos serie modernos [editar]

Uno de los defectos de los puertos serie iniciales era su lentitud en comparación con los
puertos paralelos -hablamos de 19.2 kbits por segundo- sin embargo, con el paso del
tiempo, están apareciendo multitud de puertos serie de alta velocidad que los hacen muy
interesantes ya que utilizan las ventajas del menor cableado y solucionan el problema de
la velocidad con un mayor apantallamiento y más barato usando la técnica del par
trenzado. Por ello, el puerto RS-232 e incluso multitud de puertos paralelos están siendo
reemplazados por nuevos puertos serie como el USB, el FireWire o el Serial ATA.

Un puerto de red puede ser puerto serie o puerto paralelo.

Tipos de comunicaciones seriales [editar]

Simplex

En este caso el transmisor y el receptor están perfectamente definidos y la

comunicación es unidireccional. Este tipo de comunicaciones se emplean
usualmente en redes de radiodifusión, donde los receptores no necesitan enviar
ningún tipo de dato al transmisor.

Duplex, half duplex o semi-duplex

En este caso ambos extremos del sistema de comunicación cumplen funciones de

transmisor y receptor y los datos se desplazan en ambos sentidos pero no
simultáneamente. Este tipo de comunicación se utiliza habitualmente en la
interacción entre terminales y un computador central.

Full Duplex

El sistema es similar al duplex, pero los datos se desplazan en ambos sentidos

simultáneamente. Para ello ambos transmisores poseen diferentes frecuencias de
transmisión o dos caminos de comunicación separados, mientras que la
comunicación semi-duplex necesita normalmente uno solo. Para el intercambio de
datos entre computadores este tipo de comunicaciones son más eficientes que las
transmisiones semi-duplex.

Puerto serial

Los puertos seriales (también llamados RS-232, por el nombre del estándar al que hacen
referencia) fueron las primeras interfaces que permitieron que los equipos intercambien
información con el "mundo exterior". El término serial se refiere a los datos enviados
mediante un solo hilo: los bits se envían uno detrás del otro (consulte la sección sobre
transmisión de datos para conocer los modos de transmisión).

Originalmente, los puertos seriales sólo podían enviar datos, no recibir, por lo que se
desarrollaron puertos bidireccionales (que son los que se encuentran en los equipos
actuales). Por lo tanto, los puertos seriales bidireccionales necesitan dos hilos para que la
comunicación pueda efectuarse.
 La comunicación serial se lleva a cabo asincrónicamente, es decir que no es necesaria
una señal (o reloj) de sincronización: los datos pueden enviarse en intervalos aleatorios. A
su vez, el periférico debe poder distinguir los caracteres (un carácter tiene 8 bits de
longitud) entre la sucesión de bits que se está enviando.
Ésta es la razón por la cual en este tipo de transmisión, cada carácter se encuentra
precedido por un bit de ARRANQUE y seguido por un bit de PARADA. Estos bits de
control, necesarios para la transmisión serial, desperdician un 20% del ancho de banda
(cada 10 bits enviados, 8 se utilizan para cifrar el carácter y 2 para la recepción).
Los puertos seriales, por lo general, están integrados a la placa madre, motivo por el cual
los conectores que se hallan detrás de la carcasa y se encuentran conectados a la placa
madre mediante un cable, pueden utilizarse para conectar un elemento exterior.
Generalmente, los conectores seriales tienen 9 ó 25 clavijas y tienen la siguiente forma
(conectores DB9 y DB25 respectivamente):

Un PC posee normalmente entre uno y cuatro puertos seriales.

Puerto paralelo

La transmisión de datos paralela consiste en enviar datos en forma simultánea por varios
canales (hilos). Los puertos paralelos en los PC pueden utilizarse para enviar 8 bits (un
octeto) simultáneamente por 8 hilos.

Los primeros puertos paralelos bidireccionales permitían una velocidad de 2,4 Mb/s. Sin
embargo, los puertos paralelos mejorados han logrado alcanzar velocidades mayores:

 El EPP (puerto paralelo mejorado) alcanza velocidades de 8 a 16 Mbps

 El ECP (puerto de capacidad mejorada), desarrollado por Hewlett Packard y Microsoft.
Posee las mismas características del EPP con el agregado de un dispositivo Plug and
Play que permite que el equipo reconozca los periféricos conectados.

Los puertos paralelos, al igual que los seriales, se encuentran integrados a la placa
madre. Los conectores DB25 permiten la conexión con un elemento exterior (por ejemplo,
una impresora).
El nombre de “serie” viene por el hecho de que un puerto serie “serializa” los datos. Esto
significa que coge un byte de datos y transmite los 8 bits que contiene el byte uno a la
vez. La ventaja es que los puertos serie solo necesitan un hilo para transmitir los 8 bits,
mientras que los paralelo necesitan 8. La desventaja es que lleva 8 veces más tiempo que
si tuviera 8 hilos. Los puertos serie bajan el coste de los cables y hacen que sean más
pequeños.

(serial port). Puerto para conectar un dispositivo a una computadora. La información se

transmiten por un solo conducto y por lo tanto bit a bit de forma serial. Por esta razón los
puertos seriales tradicionales son sumamente lentos y son usados para conectar el
mouse o el teclado. En cambio el puerto paralelo puede enviar múltiples bits en forma
paralela.

La mayoría de los puertos serie de las PC obedecen el estándar RS-232C o el RS-422.

Las computadoras tienen dos puertos seriales: COM1 y COM2

Actualmente los puertos seriales modernos poseen grandes velocidades como el puerto
USB, el firewire o el SATA.

GTK

GTK+ o The GIMP Toolkit es un conjunto de bibliotecas multiplataforma para desarrollar

interfaces gráficas de usuario (GUI), principalmente para los entornos gráficos GNOME,
XFCE y ROX aunque también se puede usar en el escritorio de Windows, MacOS y otros.

Inicialmente fueron creadas para desarrollar el programa de edición de imagen GIMP, sin
embargo actualmente se usan mucho por muchos otros programas en los sistemas
GNU/Linux. Junto a Qt es uno de las bibliotecas más populares para X Window System.

GTK+ se ha diseñado para permitir programar con lenguajes como C, C++, C#, Java,
Ruby, Perl, PHP o Python.

Licenciado bajo los términos de LGPL, GTK+ es software libre y es parte del proyecto
GNU.

GTK#

Gtk # es una interfaz gráfica de usuario Toolkit para mono y. Net. El proyecto se une la
GTK + (http://www.gtk.org/) kit de herramientas y una variedad de GNOME
(http://www.gnome.org/) las bibliotecas, permitiendo plenamente nativas de desarrollo de
GNOME gráfica de aplicaciones utilizando el Mono y. Net marcos de desarrollo.

WINDOWS FORMS

Windows Forms es el nombre dado a la interfaz gráfica de programación de aplicaciones

(API), incluido como una parte de. NET Framework de Microsoft, proporcionando acceso
a los elementos nativos interfaz de Microsoft Windows envolviendo la API de Windows
existentes en el código administrado. Si bien es visto como un reemplazo de la anterior y
más complejo de C + + basados en Microsoft Foundation Class Library, que no ofrece un
paradigma comparable al modelo-vista-controlador. Algunos después de mercado y las
bibliotecas de terceros han sido creadas para proporcionar esta funcionalidad. El más
utilizado de ellos es el Proceso de Interfaz de Usuario bloque de aplicación, que es
liberado por los patrones y prácticas Microsoft grupo como una descarga gratuita que
incluye el código fuente de ejemplos de inicio rápido.

QT

Qt o biblioteca Qt es una herramienta de programadores para desarrollar interfaces

gráficas de usuario. Es un sistema integral de desarrollo para aplicaciones multi-
plataforma.

Qt (que se pronuncia como la palabra Inglés "lindo" [2]), es una aplicación marco de la
plataforma de desarrollo, ampliamente utilizado para el desarrollo de los programas de
interfaz gráfica de usuario (en cuyo caso se conoce como un Widget Toolkit), y también se
utiliza para el desarrollo no programas de gráficas, tales como herramientas de la consola
y servidores. Qt es principalmente usado en KDE, Google Earth, Skype, Qt Extended,
Adobe Photoshop Album, VirtualBox y OPIE.

LIBRERÍAS DINÁMICAS

Conocidas como DLLs, acrónimo de su nombre en inglés ("Dynamic Linked Library").

Estas librerías se utilizan mucho en la programación para el SO Windows. Este Sistema
contiene un gran número de tales librerías de terminación .DLL, aunque en realidad
pueden tener cualquier otra terminación .EXE, .FON, .BPI, .DRV etc. Cualquiera que sea
su terminación, de forma genérica nos referiremos a ellas como DLLs, nombre por el que
son más conocidas.

Una de las grandes ventajas del uso de librerías dinámicas, aparte de tener ficheros
ejecutables más pequeños, es que podemos modificar la implementación de las librerías
sin tener que recompilar los programas.

Clases

Una clase es basicamente un agregado de datos y funciones para manipular esos datos.
Las clases, y la programacion 'orientada a objetos' en general, ha representado un gran
avance para produccion de software a gran escala, los recursos de herencia,
encapsulamiento, ocultacion de datos, clases virtuales, etc., estan pensados con esa
finalidad. Aqui solo nos detendremos en la nocion minima de 'clase' y el modo en que es
almacenado un objeto en memoria.

Supongamos una clase muy simple:

class gente
{
 char nombre[10];
int edad;
public:
gente (char*cad, int a)
{
strcpy(nombre,cad);
edad = a;
}
};

Se trata de una clase cuyos miembros son dos datos y una sola funcion. Una vez
declarada la clase podemos definir objetos como pertenecientes a ese tipo. Una clase no
ocupa espacio, pero si un objeto perteneciente a esa clase. El espacio ocupado en
memoria por tal objeto puede ser conocido a traves de 'sizeof'.
gente pp1;
cout<<sizeof(pp1); //saca en pantalla '12'
El valor podria ser ligeramente diferente segun el compilador, por efecto de optimizacion.
Lo importante es observar que el monto de memoria del objeto (retornado por sizeof), esta
determinado por la suma del espacio ocupado por los datos, 'sizeof' no tiene en cuenta a
la funcion.
Cada objeto de tipo 'gente' ocupara 12 bytes, pues posee una copia individual de los
datos de clase, en cambio hay una sola copia del miembro funcion (aqui el constructor)
utilizado por todos los objetos.

Declaremos dos objetos de tipo 'gente':

gente pp1("gerardo", 33);

gente pp2("miguel",34);

Observaremos ahora que efectos producen estas entidades 'pp1' y 'pp2', en memoria. Los
datos que utilizaremos se obtienen en TurboC++ (cualquier version) posando el cursor
sobre el objeto que nos interesa (aqui 'pp1' y 'pp2') y pulsando 'Alt+f4', tambien
consultaremos los registros de la CPU (con "Windows/Registers"). En un programa, que
define la clase 'gente' y dos objetos (pp1 y pp2) inicializados como muestran las lineas de
codigo previas, se puede observar lo siguiente:

El valor especifico de cada dato (como el valor de segmento) puede variar con cada
ejecucion, lo que cuenta es la relacion entre tales valores. Interpretemos estos datos.

1- En la ventana de cada objeto (pp1 y pp2) figura en primer lugar la direccion de memoria
donde almacena sus valores, ambas direcciones tienen el mismo valor de segmento
(0x8F86), que coincide por otra parte con el valor de DS (segmento de datos) y de SS
(segmento de stack) de la CPU. Sus direcciones difieren ligeramente en offset, la resta
de los mismos (0xFFEA - 0xFFDE) es igual a 12, que es el espacio que ocupa (en bytes)
cada objeto en memoria.

2- Esos 12 bytes por objeto corresponden a 10 para la cadena de caracteres ('cad') y 2

para almacenar el entero ('edad'). Estos datos estan almacenados alli donde indica el
offset, no en otro sitio, por lo tanto un puntero al objeto 'pp1' apuntara (en este caso) a la
misma direccion de memoria que un puntero a su elemento 'cad', y otro tanto para 'pp2'.
Las datos miembros se exponen con sus nombres a la izquierda y el valor que contienen
a la derecha. La cadena de caracteres es terminada en '\0' (seguido de caracteres
aleatorios), y el entero es mostrado en formato decimal y hexadecimal

3-Debajo, y separado por una linea, se encuentra un espacio donde se enumeran las
funciones miembro de la clase. Alli encontramos el prototipo de la funcion miembro y al
lado la direccion de memoria donde se inicia su codigo. Ese es el valor que almacenaria
un puntero a dicha funcion. Observese que tal direccion es la misma para ambos objetos,
por la razon antes mencionada de que hay solo una copia de funciones miembro por
objeto. El segmento donde se encuentra tal funcion se corresponde con el valor que
muestra la ventana CPU para CS (segmento de codigo).

Podemos sintetizar lo visto respecto a clases del siguiente modo:

-Una clase no es un 'dato' (es un tipo), no tiene una localidad de memoria asociada y por
lo tanto no puede almacenar ningun valor.
-Un objeto de tal clase si define una region de memoria, un espacio de almacenamiento
de datos. Esta es la diferencia entre 'clase' y 'objeto'.
-Cada objeto de una misma clase posee una copia propia de cada uno de los datos
miembros de la clase, pero comparte una misma copia de las funciones miembros.

Por otra parte, un array de objetos (instancias de clase) es almacenado como una
sucesion consecutiva, mientras que un puntero a objeto sera (como todo puntero) un par
de bytes que apunte a una direccion de memoria donde se almacena el objeto.

Recursión

Un tema fundamental para los próximos temas es el de recusrión. La recursión es muy

importante tanto en mateáticas como em computación, pues se usa recursión para definir
procedimientos autosimilares.

Definición 6 Decimos que un objeto es recursivo si en su definición se nombra a sí

mismo.

En programación, una función es recursiva si en el ámbito de esa función hay una llamada
a sí misma, C/C++ permite esta clase de acciones. Los algoritmos recursivos dan
elegancia a las soluciones de los problemas. Un ejemplo clásico es el factorial de un
número.

Una manera de definir el factorial de un número es:

es decir, el producto de todos los números enteros menores o guales que él, lo que se
puede resolver fácilmente con una función iterativa, esto es, una función con un ciclo que
itere suficientes veces, incrementando un valor y entonces ir almacenando en una
variable el resultado de esas multiplicaciones.

Una implementación de esta definición iterativa es:

(1) int i,n;

(2) long double valorAc;
(4) valorAc=1.0;
(5) std::cout << "Numero entero:";
(6) std::cin>> n;
(7) for(i=1; i<=n; i++) valorAc = valorAc*i;
(8) std::cout<<"El factorial de "<<n<<" es:"<<valorAc;

El ciclo principal es en la línea (7). No hay ningún truco hasta aquí. La única observación
importante es en la línea (2) en donde se declara el tipo long double para el valor del
resultado, la razón para tal acción es que el número factorial crece muy rápido y aún con
entradas en el rango de los caracteres (hasta 255), el factorial es muy grande. Este
procedimiento computacional no hace uso de técnicas especiales empleadas para tratar
números grandes.

Sin embargo una solución más elegante es usar la definición recursiva, y esta es:

El programa en C/C++ es el que se muestra a continuación:

( 1) double factorial(double a){

( 2) if (a<=1) return 1.0;
( 3) else return (a *factorial(a-1.0)); }
( 4)
( 5) int main (int argc, char * const argv[]) {
( 6) double n;
( 7) std::cout << "Numero entero:";
( 8) std::cin>> n;
( 9) std::cout<<"El factorial de "<<n<<" es: "<< factorial(n);
(10) return 0; }

Aquí hay varias cosas que señalar, en primer lugar se ha creado una nueva función, a
diferencia de la definición iterativa en donde era suficiente trabajar en el programa
principal. Esta función se llama factorial (como era de suponerse), y empieza su
encabezado en la línea (1).
Allí mismo en la misma línea (1), es de notar que hemos emplado ahora el tipo double
tanto para el tipo devuelto como para el tipo del argumento, a diferencia de la versión
iterativa en donde empleábamos tipos diferentes. La razón es que al iniciar la recursión el
argumento es del tipo devuelto, asi que deben ser del mismo tipo.

Cada llamada recursiva genera una entrada a una pila, en donde se guardan (como
elementos) los estados generales del sistema al momento de hacer la llamada, entonces,
cuando se termina la función se recupera una entrada de la pila. En la figura 16 ilustra
cómo funciona la recursividad cuando se intenta obtener el factorial(5).

Figura 16: Recursividad cuando se ejecuta factorial(5)

Conversión de números romanos a arábigos.

El proceso de conversión de Números Arábigos (1, 2, 3,…) a Números Romanos (I, II,
III,…) consiste en lo siguiente:

Dado un número, se realiza una serie de comparaciones contra cada uno de los valores
correspondientes a los símbolos romanos enlistados una tabla que los contenga
ordenados de mayor a menor.

La clave es dicha tabla (que por facilidad puede ser también dos vectores paralelos) que
nos muestre los valores romanos ordenados desde el más alto y hasta terminar en el más
bajo (o sea el 1) así como su “Valor nominal”.
 Romanos[
i Valores[ ]
]

1 M 1000

2 CM 900

3 D 500

4 CD 400

5 C 100

6 XC 90

7 L 50

8 XL 40

9 X 10

10 IX 9

11 V 5

12 IV 4

13 I 1

Pseudocódigo

Este mismo proceso en pseudo-código, el cual quedaría de la siguiente manera:

1.Inicio
2.Dadas las tablas Romanos[] y Valores[]
3.Pedir: A
4.Hacer Resultado = ""
5. Ciclo en i para cada elemento de Romanos
6. Mientras Valores<i> <= A hacer
7. Resultado = Resultado + Romanos<i>
8. A = A - Valores<i>
9. Fin-Mientras
10. Fin-Ciclo
11.Mostrar Resultado
12.Fin

NOTA: El algoritmo se puede hacer más eficiente si se valida que cuando A llegue a cero,
se interrumpa el ciclo. De ese modo sería más óptimo, aunque funcionaría igual.

Diagrama de flujo.

CONVERTIR NÚMEROS ROMANOS A ARÁBIGOS

El proceso de conversión de Números Romanos (I, II, III,…) a Números Arábigos (1, 2,
3,…) es un proceso bastante simple y consiste en

La suma de los valores individuales de los caracteres que forman el Número Romano

Así pues tenemos que la conversión sería así:

I=1
II =1+1
III =1+1+1
IV = 1 + 4 ?
Y aquí viene el primer tropiezo, ya que números como el 4 (IV), el 9 (IX) o el 900(CM)
requieren de una resta. Para solucionarlo podemos tomar dos caminos, uno sería tener
una tabla con los valores romanos de todos los elementos, incluyendo los valores
compuestos, e ir comparando cada uno contra dicha tabla asegurándonos de comparar
primero XC antes de X y IV antes de I.

La otra manera es implementando un sistema de sumas y restas condicionadas donde

para cada número estemos revisando también el de adelante y si el de adelante es
mayor, entonces es una resta, y si es menor o igual entonces es una suma.

Punteros

Como dijimos más arriba, los programas, leen y escriben datos de manera temporal en la
memoria RAM.

Para hacer esto, se utilizan las variables y constantes, que sirven para “etiquetar” partes
de la memoria, de manera que referirnos a ella más adelante. Y de esta manera
almacenar datos en esa variable, sin saber exactamente a que posición de memoria está
asociada la misma. Además, una vez que esa variable fue creada, se le asocia una
posición de memoria, y esta asociación no se puede borrar, esa variable siempre va a
estar asociada con esa posición de memoria y no otra. Por si no se entiende eso, veamos
un ejemplo:

1char numero = 'a';

Al declarar la variable numero, se reserva una posición de memoria X, y se almacena

dentro el valor „a‟. Si después hacemos esto:

1numero = 'b';

Se pierde el dato „a‟, y se le asigna a la variable el dato „b‟. Pero la posición de memoria
sigue siendo la misma. No hay manera de que esa variable no esté directamente
asociada con esa posición de memoria.

Además, al declarar la variable, la posición de memoria se elige de manera aleatoria, no

podemos por ejemplo decidir cual posición de memoria queremos leer o escribir.

para muchas cosas sirven, entre otras podemos mencionar:

Optimizar la memoria: el trabajar directamente con la memoria, nos permite optimizarla,

de manera de poder liberar determinada posición de memoria cuando queramos, o
guardar los datos de manera que se pueda aprovechar mejor la memoria disponible, etc.

Pasarle direcciones de memoria como parámetros a las funciones: como ya sabrán,

cuando le pasamos a una función un dato como parámetro, le estamos pasando una
copia del dato, es decir que si la función tiene que cambiar ese dato, va a cambiar la
copia, la cual por cierto se va a destruir al finalizar la ejecución de la función. Para evitar
esto, en vez de pasarle como parámetro una variable común, le pasamos un puntero con
la dirección de memoria a la cual está asociada dicha variable, y de esta manera, la
función puede modificar el dato sin problemas (modificando directamente la posición de
memoria).

La creación de un puntero es igual a la de una variable, sólo que se le antepone al

nombre de la variable el operador * (asterisco).

1int *miPuntero;

Como podrán observar, se le indica el tipo de dato al cual va a poder apuntar (en este
caso un int).

NOTA: hay individuos que se confunden, y piensan que la declaración del puntero varía
según donde se coloque el operador *. La respuesta es NO. Es exactamente lo mismo
hacer int * miPuntero, que int* miPuntero, que int *miPuntero. Lo que pasa es que por
norma, debería ponerse el * al lado de la variable, ya que cuando hacemos esto: int *
miPuntero, otraVariable, sólo la primera variable se declara como puntero. Pero es lo
mismo donde pongamos el asterisco, el compilador lo toma de la misma manera.

Bueno, al declarar un puntero, sucede prácticamente lo mismo que cuando declaramos

una variable común, es decir, se reservan X posiciones de memoria para poder almacenar
el dato. Sólo que en este caso, en vez de un dato común como puede ser un int, un float,
etc. se trata de un puntero, o sea una dirección de memoria (un número hexadecimal).

codigo...

1int unLindoVector[3];

2int *unHermosoPuntero;

3for (x=0; x&lt;3; x++) {

4printf("Indice %i: %pn", x, unHermosoPuntero++);

5}

RAII (Resource Acquisition Is Initialization)

RAII es un idioma que combina la obtención y liberación de recursos con la inicialización y

destrucción de objetos. Facilitando así a los programadores la tarea de liberar recursos.
Aunque por su nombre tal vez no sea muy conocido, es utilizado en varios lugares de la
STL, los Smart Pointers por ejemplo, son una clara implementación de RAII.

Depuración de programas (Debugging)

Depuración de programas es el proceso de identificar y corregir errores de

programación.
En inglés se le conoce como debugging, ya que se asemeja a la eliminación
de bichos (bugs), manera en que se conoce informalmente a los errores de programación.
Se dice que el término bug proviene de la época de las computadoras de válvula
termoiónicabulbos, en las cuales los problemas se generaban por los insectos que eran
atraídos por las luces y estropeaban el equipo.

USB.

(Universal Serial Bus) Puerto de gran velocidad para comunicar computadoras y

periféricos. Soporta plug & play y conexión en caliente (hot plugging).

Soporta transferencias de 12 MBps. Un sólo puerto USB permite ser usado para conectar
más de 127 dispositivos periféricos como ratones, módems, teclados, impresoras, etc.

Comenzó a ser utilizado en 1996, pero la popularidad llegó en las iMac en 1998.

Prácticamente reemplazó a los puertos serial y puertos paralelo.

Versiones USB más populares disponibles:

* USB 1.1
* USB 2.0 (HiSpeed)
* USB 3.0 (SuperSpeed USB)
Definición de USB 2.0

USB 2.0 es un bus externo que soporta hasta 480 Mbits/s de transferencia de datos. Se
trata de una extensión del USB 1.1, por lo tanto utiliza los mismos cables y conectores, y
es compatible con éste.

Fue desarrollado por Hewlett-Packard, Intel, Lucent, Microsoft, NEC y Philips.

USB 2.0 fue lanzado en abril de 2000.

Definición de USB 3.0

(SuperSpeed USB). USB 3.0 es una de las versiones del USB, sucesora de la versión
USB 2.0. Permite transferencias teóricas de hasta 4,8 Gbps.

Se lo ha llamado SuperSpeed USB, a diferencia de su versión anterior, la 2.0, llamada

HiSpeed.

USB 3.0 consume menos electricidad, es más rápida y sus puertos son compatibles con
los puertos USB 2.0.

Su desarrollo fue terminado en noviembre de 2008.

QUE ES UN PUERTO FIREWIRE.

Firewire se denomina al tipo de puerto de comunicaciones de alta velocidad desarrollado

por la compañía Apple.
La denominación real de esta interfaz es la IEEE 1394. Se trata de una tecnología para la
entrada/salida de datos en serie a alta velocidad y la conexión de dispositivos digitales.

Esta interfaz se caracteriza principalmente por:

- Su gran rapidez, siendo ideal para su utilización en aplicaciones multimedia y

almacenamiento, como videocámaras, discos duros, dispositivos ópticos, etc...

- Alcanzan una velocidad de 400 megabits por segundo, manteniéndola de forma bastante
estable.

- flexibilidad de la conexión y la capacidad de conectar un máximo de 63 dispositivos.

- Acepta longitudes de cable de hasta 425 cm.

- Respuesta en el momento. FireWire puede garantizar una distribución de los datos en

perfecta sincronía.

- Alimentación por el bus. Mientras el USB 2.0 permite la alimentación de dispositivos que
consuman un máximo de 5v, , los dispositivos FireWire pueden proporcionar o consumir
hasta 25v, suficiente para discos duros de alto rendimiento y baterías de carga rápida. En
este punto hay que hacer reseña de que existe un tipo de puerto Firewire que no
suministra alimentación, tan sólo da servicio de comunicación de datos. Estos puertos
tienen sólo 4 contactos, en lugar de los 6 que tiene un puerto Firewire alimentado.

- Conexiones de enchufar y listo, conocidas como plug & play. No tenemos más que
enchufar un dispositivo para que funcione.

- Conexión en caliente (permite conectar dispositivos con el PC encendido sin ningún

riesgo de rotura).

Firewire
Bus serial de Apple; es un solo enchufe, pero pueden conectarse hasta 63 dispositivos.
Transfiere información de hasta 400 MB por segundos.
IEEE 1394

Logotipo de FireWire. Conector FireWire de 6 pins.

Connectores de 6 y 4 pins.

El IEEE 1394 (conocido como FireWire por Apple Inc. y como i.Link por Sony) es un
estándar multiplataforma para entrada/salida de datos en serie a gran velocidad. Suele
utilizarse para la interconexión de dispositivos digitales como cámaras digitales y
videocámaras a computadoras.

Historia

El Firewire fue desarrollado por Apple Computer a mediados de los 90, para luego
convertirse en el estándar multiplataforma IEEE 1394. A principios de este siglo fue
adoptado por los fabricantes de periféricos digitales hasta convertirse en un estándar
establecido. Sony utiliza el estándar IEEE 1394 bajo la denominación i.Link, y Texas
Instruments bajo la denominación Lynx.

Versiones

Su velocidad hace que sea la interfaz más utilizada para audio y vídeo digital. Así, se usa
mucho en cámaras de vídeo, discos duros, impresoras, reproductores de vídeo digital,
sistemas domésticos para el ocio, sintetizadores de música y escáneres.

Existen tres versiones:

FireWire 400 (IEEE 1394-1995)

Lanzado en 1995. Tiene un ancho de banda de 400 Mbit/s, 30 veces mayor que el USB
1.1 (12 Mbps) y similar a la del USB 2.0 (480 Mbps), aunque en pruebas realizadas, en
transferencias de lectura de 5000 ficheros con un total de 300 Mb, FireWire completó el
proceso con un 33% más de velocidad que USB 2.0, debido a su arquitectura peer-to-
peer mientras USB utiliza arquitectura slave-master [1]. La longitud máxima permitida con
un único cable es de 4,5 metros, pudiendo utilizarse hasta 16 repetidores para prolongar
la longitud (no pudiendo sobrepasar nunca la distancia de 72 metros). Su conector está
dotado de 6 pines, dos de ellos destinados a la alimentación del dispositivo (excepto en la
versión distribuida por sony, iLink, que carece de estos dos pines de alimentación)
ofreciendo un consumo de unos 7 u 8 W por puerto a 25 V (nominalmente).

Revisión IEEE 1394a-1995

En 2000 se implementó una revisión de IEEE 1394-1995, añadiéndole características

como difusión asíncrona, una reconfiguración de bus más rápida, concatenación de
paquetes, y ahorro de energía en modo suspensión.

FireWire 800 (IEEE 1394b-2000)

Lanzado en 2000. Duplica aproximadamente la velocidad del FireWire 400, hasta 786.5
Mbps con tecnología full-duplex, cubriendo distancias de hasta 100 metros por cable.
Firewire 800 reduce los retrasos en la negociación, utilizando para ello 8b10b (código que
codifica 8 bits en 10 bits, que fue desarrollado por IBM y permite suficientes transiciones
de reloj, la codificación de señales de control y detección de errores. El código 8b10b es
similar a 4B/5B de FDDI (que no fue adoptado debido al pobre equilibrio de corriente
continua), que reduce la distorsión de señal y aumenta la velocidad de transferencia. Así,
para usos que requieran la transferencia de grandes volúmenes de información, resulta
muy superior al USB 2.0. Posee compatibilidad retroactiva con Firewire 400 utilizando
cables híbridos que permiten la conexión en los conectores de Firewire400 de 6 pines y
los conectores de Firewire800, dotados de 9 pines. No fue hasta 2003 cuando Apple lanzó
el primer uso comercial de Firewire800.

FireWire s1600 y s3200 (IEEE 1394-2008)

Anunciado en Diciembre de 2007. Permiten un ancho de banda de 1'6 y 3'2 Gbit/s,

cuadruplicando la velocidad del Firewire 800, utilizando el mismo conector de 9 pines de
Firewire800

FireWire s800T (IEEE 1394c-2006)

Anunciado en Junio de 2007. Aporta mejoras técnicas que permite el uso de FireWire con
puertos RJ45 sobre cable CAT 5, combinando así las ventajas de Ethernet con
Firewire800.

Características generales

 Soporta la conexión de hasta 63 dispositivos con cables de una longitud máxima

de 425 cm con topología en árbol.
 Soporte Plug-and-play.
 Soporta comunicación peer-to-peer que permite el enlace entre dispositivos sin
necesidad de usar la memoria del sistema o la CPU
 Soporta conexión en caliente.
 Todos los dispositivos Firewire son identificados por un identificador IEEE EUI-64
exclusivo (una extensión de las direcciones MAC Ethernet de 48-bit)
Aplicaciones de FireWire

Edición de vídeo digital

La edición de vídeo digital con FireWire ha permitido que tuviera lugar una revolución en
la producción del vídeo con sistemas de escritorio. La incorporación de FireWire en
cámaras de vídeo de bajo costo y elevada calidad permite la creación de vídeo
profesional en Macintosh o PC. Atrás quedan las carísimas tarjetas de captura de vídeo y
las estaciones de trabajo con dispositivos SCSI de alto rendimiento. FireWire permite la
captura de vídeo directamente de las nuevas cámaras de vídeo digital con puertos
FireWire incorporados y de sistemas analógicos mediante conversores de audio y vídeo a
FireWire.

Redes IP sobre FireWire

Como explica Apple, "con este software instalado, se pueden utilizar entre computadoras
Macintosh y periféricos los protocolos IP existentes, incluyendo AFP, HTTP, FTP, SSH,
etcétera. En todos los casos, se puede utilizar Bonjour (Rendezvous) para su
configuración, resolución de nombres y descubrimiento." Si unimos la posibilidad de usar
las conexiones FireWire para crear redes TCP/IP a las prestaciones de FireWire 2
(FireWire 800), tenemos razones muy serias para que Apple recupere rápidamente la
atención de los fabricantes de periféricos para satisfacer las necesidades de los usuarios
de aplicaciones que requieren gran ancho de banda en redes locales, como todas las
relacionadas con el vídeo digital. Por no hablar de introducirse en un posible mercado
nuevo.

Licencias

COPYRIGHT

El derecho de autor y copyright constituyen dos concepciones sobre la propiedad literaria

y artística. El primero proviene de la familia del derecho continental, particularmente del
derecho francés, mientras que el segundo procede del derecho anglosajón (o common
law).

El derecho de autor se basa en la idea de un derecho personal del autor, fundado en una
forma de identidad entre el autor y su creación. El derecho moral está constituido como
emanación de la persona del autor: reconoce que la obra es expresión de la persona del
autor y así se le protege.

La protección del copyright se limita estrictamente a la obra, sin considerar atributos

morales del autor en relación con su obra, excepto la paternidad; no lo considera como un
autor propiamente tal, pero tiene derechos que determinan las modalidades de utilización
de una obra.

Comentarios
Este tipo de licenciamientos es mas de modo que el usuario esta mas restringido de las
características que hay en el lenguaje de progamacion y este solo se conforma con el
entorno visual

GPL

Los programas de ordenador suelen distribuirse con licencias propietarias o cerradas.

Estas licencias son intransferibles y no exclusivas, es decir, no eres propietario del

programa, sólo tienes derecho a usarlo en un ordenador o tantos como permita
expresamente la licencia y no puedes modificar el programa ni distribuirlo.

La licencia GPL o General Public License, desarrollada por la FSF o Free Software
Foundation, es completamente diferente. Puedes instalar y usar un programa GPL en un
ordenador o en tantos como te apetezca, sin limitación. También puedes modificar el
programa para adaptarlo a lo que tu quieras que haga. Además, podrás distribuir el
programa GPL tal cual o después de haberlo modificado.

Puedes hacer esto, regalando el programa o vendiéndolo, tu única obligación, es facilitar

siempre con el programa binario el código fuente, es decir, el programa de forma que
pueda ser leido por un programador.

Los programas propietarios o cerrados, solo se distribuyen en binario, listos para

ejecutarse en el ordenador.

Un programa GPL es libre, es decir, no es \"shareware\" o \"freeware\", éstos también

puedes conseguirlos en un cd-rom al comprar un revista o descargarlos de internet, pero
no incluyen el código fuente y no tienes permiso para modificarlos, es decir, no son libres.

Los programas distribuidos con licencia GPL tampoco son piratas, utiliza otra licencia para
atacar barcos.

Los programas GPL no tienen garantía, igual que casi todos los programas propietarios,
no obstante, ofrecen más derechos a sus usuarios y su sistema abierto hace que los
defectos sean detectados y depurados a gran velocidad con la ayuda de cientos de
programadores a través de internet. Por otro lado, nada impide a una empresa garantizar
el Software Libre junto a otros servicios que oferte.

https://login.live.com/ppsecure/sha1auth.srf?lc=2058

Comentarios.

Esta licencia se vasa en ayudame que yo te ayudare esto es que puedes ejecutarlo desde
cualquier ordenado y realizarle mejoras lo que conyeva a dejarlas claras las mejora y
publicarlas para que los de mas usuarios las vean.
GNU

El proyecto GNU fue iniciado por Richard Stallman con el objetivo de crear un sistema
operativo completamente libre: el sistema GNU.1 El 27 de septiembre de 1983 se anunció
públicamente el proyecto por primera vez en el grupo de noticias net.unix-wizards. Al
anuncio original, siguieron otros ensayos escritos por Richard Stallman como el
"Manifiesto GNU", que establecieron sus motivaciones para realizar el proyecto GNU,
entre las que destaca "volver al espíritu de cooperación que prevaleció en los tiempos
iniciales de la comunidad de usuarios de computadoras".

Esta licencia, a diferencia de otras, asegura que el material licenciado bajo la misma esté
disponible de forma completamente libre, pudiendo ser copiado, redistribuido, modificado
e incluso vendido siempre y cuando el material se mantenga bajo los términos de esta
misma licencia (GNU GFDL). En caso de venderse en una cantidad superior a 100
ejemplares, deberá distribuirse en un formato que garantice futuras ediciones (debiendo
incluir para ello el texto o código fuente original).

http://es.wikipedia.org/wiki/GNU

comentarios.

Este tipo de software es mas bien un tipo lucro ya que en este podemos encontrar una
combinación de licencias por que podemos ejecutarlos desde cualquier ordenador y
mejorar el código fuente pero además podemos venderlo como si nosotros lo hubiéramos
hecho. Lo cual es muy poco llamativo en el caso de querer comprar uno de estos.

LICENCIAS CREATIVE COMMONS

Las licencias Creative Commons o CC están inspiradas en la licencia GPL (General

Public License) de la Free Software Foundation, sin embargo no son un tipo de
licenciamiento de software. La idea principal es posibilitar un modelo legal ayudado por
herramientas informáticas para así facilitar la distribución y el uso de contenidos.

Existe una serie de licencias Creative Commons, cada una con diferentes configuraciones
o principios, como el derecho del autor original a dar libertad para citar su obra,
reproducirla, crear obras derivadas, ofrecerla públicamente y con diferentes restricciones
como no permitir el uso comercial o respetar la autoría original.

Una de las licencias que ofrecía Creative Commons es la que llevaba por nombre
"Developing Nations" (Naciones en Desarrollo), la cual permitía que los derechos de autor
y regalías por el uso de las obras se cobraran sólo en los países desarrollados del primer
mundo, mientras que se ofrecían de forma abierta en los países en vías de desarrollo.
Esta licencia ha sido retirada por problemas comerciales.

Aunque originalmente fueron redactadas en inglés, las licencias han sido adaptadas a
varias legislaciones en otros países del mundo. Entre otros idiomas, han sido traducidas
al español, al portugués, al gallego, al euskera y al catalán a través del proyecto Creative
Commons International. Existen varios países de habla hispana que están involucrados
en este proceso: España, Chile, Guatemala, Argentina, México, Perú, Colombia y Puerto
Rico ya tienen las licencias traducidas y en funcionamiento, en tanto que Ecuador y
Venezuela se encuentran en proceso de traducción e implementación de las mismas.
Brasil también tiene las licencias traducidas y adaptadas a su legislación

http://es.wikipedia.org/wiki/Creative_Commons

Comentarios.

Esta licencia se basa más en un entorno más comercial que en la ayuda a la mejora de
alguna obra aunque su ideal proviene de las licencias GPL no son completamente
parecida a esta.

LA LICENCIA MIT

Es una de tantas licencias de software que ha empleado el MIT (Massachusetts Institute

of Technology) a lo largo de su historia, y quizás debería llamarse más correctamente
licencia X11, ya que es la licencia que llevaba este software de muestra de la informacion
de manera gráfica X Window System originario del MIT en los años 80. Pero ya sea como
MIT o X11, su forma es idéntica.

El texto de la licencia no tiene copyright, lo que permite su modificación. No obstante esto,

puede no ser recomendable e, incluso, muchas veces dentro del Open Source
desaconsejan el uso de este texto para una licencia, a no ser que se indique que es una
modificación, y no la versión original.

La licencia MIT es muy parecida a la licencia BSD en cuanto a efectos.

Esta licencia permite reutilizar el Software así licenciado tanto para ser software libre
como para ser software no libre, permitiendo no liberar los cambios realizados al
programa original.

También permite licenciar dichos cambios con licencia BSD, GPL, u otra cualquiera que
sea compatible (es decir, que cumpla las cláusulas de distribución).

Con esta licencia se tiene software libre. Ejemplos en los que podría interesar su
aplicación serían las licencias duales, si se pretende difundir un estándar mediante una
implementación de referencia, o si simplemente se pretende que el producto sea Libre sin
mayores consideraciones.

http://es.wikipedia.org/wiki/MIT_License

Comentarios

en esta licencia carece completamente de copyright ya que es una combinación de varias

licencia lo que lo hace aun mejor ya que es menos lucro y mas bien una mejora en el caso
de códigos fuente y mejora extras,
LICENCIA BSD

La licencia BSD es la licencia de software otorgada principalmente para los sistemas BSD
(Berkeley Software Distribution). Es una licencia de software libre permisiva como la
licencia de OpenSSL o la MIT License. Esta licencia tiene menos restricciones en
comparación con otras como la GPL estando muy cercana al dominio público. La licencia
BSD al contrario que la GPL permite el uso del código fuente en software no libre.

Es muy similar en efectos a la licencia MIT.

El autor, bajo esta licencia, mantiene la protección de copyright únicamente para la

renuncia de garantía y para requerir la adecuada atribución de la autoría en trabajos
derivados, pero permite la libre redistribución y modificación.

Puede argumentarse que esta licencia asegura “verdadero” software libre, en el sentido
que el usuario tiene libertad ilimitada con respecto al software, y que puede decidir incluso
redistribuirlo como no libre. Otras opiniones están orientadas a destacar que este tipo de
licencia no contribuye al desarrollo de más software libre.

http://es.wikipedia.org/wiki/BSD_license

Comentarios.

Este licencia se vasa a algo mas liberal de tal forma que se encuentra al alcnaze de
cualquier usuario que desea obtener producto con este tipo de licencia parecida a la del
MIT pero con un ideal mas liberal son una forma perfecta para el desarrollo y mejora de
software.

Campos de Bits

Los campos de bits, o simplemente campos, son grupos de un número determinado de

bits, que pueden o no tener un identificador asociado. Representan un artificio que
permite utilizar miembros de tamaño arbitrario en estructuras, uniones y clases;
independiente de la posibilidad que proporcionan los tipos básicos cuyo tamaño está
predeterminado por el lenguaje. Por ejemplo, en ocasiones es necesario almacenar
semáforos (flags) con determinados estados del programa, para los que en realidad solo
hace falta un bit, pero incluso una variable bool ocupa un octeto. Los campos de bits
permiten utilizar cada bit de un octeto independientemente, aumentando así su capacidad
de representación.

Nota: esta técnica, de manejo independiente de bits en una palabra, ha sido ampliamente
utilizada desde siempre en la programación, no solo de C/C++; casi todos los lenguajes
ofrecen la posibilidad de operadores "bitwise", que permiten esto de forma más o menos
artesanal.

Entre otros usos, los campos de bits se han utilizado históricamente para empaquetar
variables en un espacio más pequeño, pero obligan al compilador a generar código
adicional para manejarlos, lo que resulta costoso en términos de tamaño y velocidad del
ejecutable. El resultado es que frecuentemente, el código resulta mayor y más lento si se
usan estos tipos, por lo que generalmente se desaconseja su uso excepto para
aplicaciones muy específicas de bajo nivel, en las que la alineación exacta de los
patrones de bits a utilizar es un aspecto primordial. Por ejemplo, transmisiones de datos

Otra cuestión distinta, a veces decisiva para su utilización, es la significativa reducción de

espacio de almacenamiento externo (disco por ejemplo) que puede conseguirse cuando
en determinados casos, se almacena gran número de registros que utilizan campos de
bits en sustitución de tipos básicos.

Declaración

La sintaxis para declaración de campos es la siguiente:

especificador-de-tipo <identificador> : ancho;

Ejemplos:

int Uno : 8;
unsigned int Dos : 16;
int : 2;

Definición de Interfaz

1. En software, parte de un programa que permite el flujo de información entre un usuario

y la aplicación, o entre la aplicación y otros programas o periféricos. Esa parte de un
programa está constituida por un conjunto de comandos y métodos que permiten estas
intercomunicaciones.

2. Intefaz también hace referencia al conjunto de métodos para lograr interactividad entre
un usuario y una computadora. Una interaz puede ser del tipo GUI, o línea de comandos,
etc. También puede ser a partir de un hardware, por ejemplo, el monitor, el teclado y el
mouse, son interfaces entre el usuario y el ordenador.

En C#, una clase es un tipo de datos muy eficaz. Como las estructuras, las clases definen
los datos y el comportamiento del tipo de datos. Los programadores pueden crear objetos
que son instancias de una clase. A diferencia de las estructuras, las clases admiten
herencia, que es una parte fundamental de la programación orientada a objetos. Para
obtener más información, vea Herencia.
Declarar clases

Las clases se definen mediante la palabra clave class, como se muestra en el ejemplo
siguiente:

C#

public class Customer

{
//Fields, properties, methods and events go here...
}

El nivel de acceso precede a la palabra clave class. En este caso, se utiliza public, que
significa que cualquiera puede crear objetos a partir de esta clase. El nombre de la clase
sigue a la palabra clave class. El resto de la definición es el cuerpo de clase, donde se
definen el comportamiento y los datos. Los campos, propiedades, métodos y eventos de
una clase se conocen colectivamente como miembros de clase.

Crear objetos

Aunque se utilizan a veces de forma intercambiable, una clase y un objeto son cosas
diferentes. Una clase define un tipo de objeto, pero no es propiamente un objeto. Un
objeto es una entidad concreta basada en una clase y, a veces, se denomina instancia de
una clase.

Los objetos se pueden crear con la palabra clave new seguida del nombre de la clase en
la que se basará el objeto, de la manera siguiente:

C#

Customer object1 = new Customer();

Cuando se crea una instancia de una clase, una referencia al objeto se vuelve a pasar al
programador. En el ejemplo anterior, object1 es una referencia a un objeto basado en
Customer. Esta referencia hace referencia el nuevo objeto, pero no contiene los datos del
propio objeto. De hecho, se puede crear una referencia a objeto sin crear un objeto:

C#

Customer object2;

No se recomienda la creación de referencias a objetos como ésta, que no hace referencia

a un objeto, porque al intentar el acceso a un objeto a través de esa referencia se
producirá un error en tiempo de ejecución. Sin embargo, este tipo de referencia se puede
crear para hacer referencia a un objeto, ya sea creando un nuevo objeto o asignándola a
un objeto existente, de la forma siguiente:

C#
Customer object3 = new Customer();
Customer object4 = object3;

Este código crea dos referencias a objeto que se refieren al mismo objeto. Por
consiguiente, los cambios realizados en el objeto a través de object3 se reflejarán en los
usos posteriores de object4. El hecho de que las clases se conozcan como tipos de
referencia se debe a que se hace referencia a los objetos basados en clases por
referencia.

Herencia de clase

La herencia se realiza a través de una derivación, lo que significa que una clase se
declara utilizando una clase base de la cual hereda los datos y el comportamiento. Una
clase base se especifica anexando dos puntos y el nombre de la clase base a
continuación del nombre de la clase derivada, del modo siguiente:

C#

public class Manager : Employee

{
// Employee fields, properties, methods and events are inherited
// New Manager fields, properties, methods and events go here...
}

Cuando una clase declara una clase base, todos los miembros de clase definidos para la
clase base también pasan a formar parte de la nueva clase. Dado que una clase base se
puede heredar de otra clase, que a su vez se heredó de otra clase y así sucesivamente,
una clase puede provenir de varias clases base.

Las estructuras se definen mediante la palabra clave struct, por ejemplo:

C#

public struct PostalAddress

{
// Fields, properties, methods and events go here...
}

Casi todas las estructuras comparten la misma sintaxis que las clases, aunque están más
limitadas que éstas:

 Dentro de una declaración de estructura, los campos no se pueden inicializar a

menos que se declaren como constantes o estáticos.
 Una estructura no puede declarar un constructor predeterminado (es decir, un
constructor sin parámetros) ni un destructor.

El compilador crea y destruye automáticamente copias de estructuras, de modo que un

constructor y destructor predeterminados son innecesarios. De hecho, el compilador
implementa el constructor predeterminado asignando a todos los campos sus valores
predeterminados (vea Tabla de valores predeterminados (Referencia de C#)). Las
estructuras no pueden heredar de clases u otras estructuras.

Las estructuras son tipos de valor; cuando un objeto se crea a partir de una estructura y
se asigna a una variable, la variable contiene el valor completo de la estructura. Cuando
se copia una variable que contiene una estructura, todos los datos se copian y cualquier
modificación a la nueva copia no cambia los datos de la copia antigua. Como las
estructuras no utilizan referencias, no tienen identidad; no existe ninguna forma de
distinguir entre dos instancias de un tipo de valor con los mismos datos. En C#, todos los
tipos de valor derivan inherentemente de ValueType, que hereda de Object.

El compilador puede convertir tipos de valor en tipos de referencia en un proceso

conocido como conversión boxing. Para obtener más información, vea Boxing y Unboxing.

Información general sobre las estructuras

Las estructuras tienen las propiedades siguientes:

 Las estructuras son tipos de valor, mientras que las clases son tipos de referencia.
 A diferencia de las clases, se pueden crear instancias de las estructuras sin utilizar
un operador new.
 Las estructuras pueden declarar constructores, pero deben utilizar parámetros.
 Una estructura no puede heredar de otra estructura o clase, ni puede ser la base
de una clase. Todas las estructuras heredan directamente de System.ValueType,
que hereda de System.Object.
 Una estructura puede implementar interfaces.
 HILOS

La creación de cada hilo se realiza mediante las líneas Thread th1 = new Thread(new
ThreadStart(msg.Mostrar1));. Esta línea indica que se crea una instancia de la clase
Thread, con nombre th1, a partir de un delegado de la clase ThreadStart, que apunta al
método Mostrar1 del objeto msg creado anteriormente.

Una vez creados los dos hilos hay que activarlos, para lo que se llama al método Start de
cada uno de ellos. Tras este punto cada hilo se ejecuta en paralelo entre si, y con el
programa principal, por lo que utilizamos el método Join de ambos hilos para esperar a
que terminen los hilos antes de finalizar el programa.

El delegado ThreadStart no acepta parámetros de entrada ni de salida, por lo que si

queremos crear un hilo sobre un método que los necesite, hay que utilizar algún
mecanismo auxiliar. Una posible forma de conseguir esto es crear una nueva clase con
los parámetros necesarios en la entrada y con un nuevo método sin parámetros que llame
al método que queremos hacer paralelo, enviándole estos parámetros. A partir de aquí
tendríamos que crear una instancia de dicha clase con los parámetros que queremos
enviar al método original, y hacer que el hilo se ejecutase sobre el nuevo método de la
clase. En el caso de que quisiéramos obtener el resultado de la ejecución, deberíamos
crear una función que acepte como parámetro de entrada el tipo del valor devuelto por el
método original, y hacer que la nueva clase creada disponga también de un delegado que
indique la función a la que llamar tras la ejecución.

Como esto puede parecer un poco lioso, vamos a ver otro ejemplo. En esta ocasión
disponemos de una clase de funciones matemáticas y queremos llamar de forma paralela
a una de ellas. Este método acepta un valor entero en la entrada y devuelve otro entero.

using System;
using System.Threading;
using System.IO;

public class EjemploMates{

public static int CalculoComplejo(int n)

{
// sumo uno y espero 5 segundos
n = n+1;
Thread.Sleep(5000);
return n;
}

public class HiloParaMates{

protected int n;
protected MatesCallback callback = null;
public HiloParaMates(int n, MatesCallback callback){
this.n = n;
this.callback = callback;
}
public void CalculoComplejo()
{
int result = EjemploMates.CalculoComplejo(n);
if(callback != null)
callback(result);
}
}

// creo un delegado con la firma necesaria para capturar

// el valor devuelto por el método CalculoComplejo
public delegate void MatesCallback(int n);

public class Ejemplo{

public static void Main()

{
HiloParaMates hpm = new HiloParaMates(1000, new MatesCallback(ResultCallback));

Thread th = new Thread(new ThreadStart(hpm.CalculoComplejo));

th.Start();
th.Join();

public static void ResultCallback(int n)

{
Console.WriteLine("Resultado de la operación: "+n);
}
}

En el anterior código la clase HiloParaMates es la que nos permite encapsular la llamada

al método EjemploMates.Calcular. Este método requiere un parámetro de tipo entero, por
lo que la clase requiere este parámetro en su constructor. Además se requiere en el
constructor otro parámetro más, un delegado MatesCallback, que acepta un entero en la
entrada. La idea es que tras realizar el cálculo se llame al método que se indique
proporcionándole el resultado.

Para hacer funcionar todo esto, en Main se crea una instancia de la clase HiloParaMates
indicándole que queremos utilizar el valor numérico 1000 y que se llame al método
(estático) ResultCallback cuando se obtenga el resultado. Para crear el hilo es suficiente
con indicar que se quiere hacer sobre el método CalculoComplejo de la instancia hpm.

System. Object

Ahora que sabemos lo que es la herencia es el momento apropiado para explicar que en
.NET todos los tipos que se definan heredan implícitamente de la clase System.Object
predefinida en la BCL, por lo que dispondrán de todos los miembros de ésta. Por esta
razón se dice que System.Object es la raíz de la jerarquía de objetos de .NET.
A continuación vamos a explicar cuáles son estos métodos comunes a todos los objetos:

 public virtual bool Equals(object o): Se usa para comparar el objeto sobre el
que se aplica con cualquier otro que se le pase como parámetro. Devuelve true si
ambos objetos son iguales y false en caso contrario.

La implementación que por defecto se ha dado a este método consiste en usar

igualdad por referencia para los tipos por referencia e igualdad por valor para los
tipos por valor. Es decir, si los objetos a comparar son de tipos por
referencia sólo se devuelve true si ambos objetos apuntan a la misma referencia
en memoria dinámica, y si los tipos a comparar son tipos por valor sólo se
devuelve true si todos los bits de ambos objetos son iguales, aunque se
almacenen en posiciones diferentes de memoria.

Como se ve, el método ha sido definido como virtual, lo que permite que los
programadores puedan redefinirlo para indicar cuándo ha de considerarse que son
iguales dos objetos de tipos definidos por ellos. De hecho, muchos de los tipos
incluidos en la BCL cuentan con redefiniciones de este tipo, como es el caso de
string, quien aún siendo un tipo por referencia, sus objetos se consideran iguales
si apuntan a cadenas que sean iguales carácter a carácter (aunque referencien a
distintas direcciones de memoria dinámica)

El siguiente ejemplo muestra cómo hacer una redefinición de Equals() de manera

que aunque los objetos Persona sean de tipos por referencia, se considere que
dos Personas son iguales si tienen el mismo NIF:

public override bool Equals(object o)

if (o==null)

return this==null;

else

return (o is Persona) && (this.NIF == ((Persona) o).NIF);

Hay que tener en cuenta que es conveniente que toda redefinición del método
Equals() que hagamos cumpla con una serie de propiedades que muchos de los
métodos incluidos en las distintas clases de la BCL esperan que se cumplan.
Estas propiedades son:
  Reflexividad: Todo objeto ha de ser igual a sí mismo. Es decir, x.Equals(x)
siempre ha de devolver true.

 Simetría: Ha de dar igual el orden en que se haga la comparación. Es decir,

x.Equals(y) ha de devolver lo mismo que y.Equals(x) .

 Transitividad: Si dos objetos son iguales y uno de ellos es igual a otro,

entonces el primero también ha de ser igual a ese otro objeto. Es decir, si
x.Equals(y) e y.Equals(z) entonces x.Equals(z) .

 Consistencia: Siempre que el método se aplique sobre los mismos objetos

ha de devolver el mismo resultado.

 Tratamiento de objetos nulos: Si uno de los objetos comparados es nulo

(null), sólo se ha de devolver true si el otro también lo es.

Hay que recalcar que el hecho de que redefinir Equals() no implica que el operador
de igualdad (==) quede también redefinido. Ello habría que hacerlo de
independientemente como se indica en el Tema 11: Redefinición de operadores.

 public virtual int GetHashCode(): Devuelve un código de dispersión (hash) que

representa de forma numérica al objeto sobre el que el método es aplicado.
GetHashCode() suele usarse para trabajar con tablas de dispersión, y se cumple
que si dos objetos son iguales sus códigos de dispersión serán iguales, mientras
que si son distintos la probabilidad de que sean iguales es ínfima.

En tanto que la búsqueda de objetos en tablas de dispersión no se realiza

únicamente usando la igualdad de objetos (método Equals()) sino usando también
la igualdad de códigos de dispersión, suele ser conveniente redefinir
GetHashCode() siempre que se redefina Equals() De hecho, si no se hace el
compilador informa de la situación con un mensaje de aviso.

 public virtual string ToString(): Devuelve una representación en forma de

cadena del objeto sobre el que se el método es aplicado, lo que es muy útil para
depurar aplicaciones ya que permite mostrar con facilidad el estado de los objetos.

Object

El tipo object es un alias de Object en .NET Framework. En el sistema de tipos unificado

de C#, todos los tipos (tipos de valor y de referencia predefinidos y definidos por el
usuario) se heredan directa o indirectamente de Object. Las variables de tipo object
pueden recibir valores de cualquier tipo. Cuando una variable de un tipo de valor se
convierte en un objeto, se dice que se le ha aplicado la conversión boxing. Cuando una
variable de objeto de tipo se convierte en un tipo de valor, se dice que se le ha aplicado la
conversión unboxing. Para obtener más información, vea Boxing y Unboxing.

Ejemplo

En el siguiente ejemplo se muestra cómo las variables de tipo object pueden aceptar
valores de cualquier tipo de datos y cómo pueden utilizar métodos de Object procedentes
de .NET Framework.

// keyword_object.cs
using System;
class SampleClass
{
public int i = 10;
}

class MainClass
{
static void Main()
{
object a;
a = 1; // an example of boxing
Console.WriteLine(a);
Console.WriteLine(a.GetType());
Console.WriteLine(a.ToString());

a = new SampleClass();
SampleClass classRef;
classRef = (SampleClass)a;
Console.WriteLine(classRef.i);
}
}

Hilo de Ejecucion

Un hilo de ejecución, en sistemas operativos, es una característica que permite a una

aplicación realizar varias tareas a la vez(concurrentemente). Los distintos hilos de
ejecución comparten una serie de recursos tales como el espacio de memoria, los
archivos abiertos, situación de autenticación, etc. Esta técnica permite simplificar el diseño
de una aplicación que debe llevar a cabo distintas funciones simultáneamente.

Los hilos de ejecución que comparten los mismos recursos, sumados a estos recursos,
son en conjunto conocidos como un proceso. El hecho de que los hilos de ejecución de un
mismo proceso compartan los recursos hace que cualquiera de estos hilos pueda
modificar éstos. Cuando un hilo modifica un dato en la memoria, los otros hilos acceden a
ese dato modificado inmediatamente.
Lo que es propio de cada hilo es el contador de programa, la pila de ejecución y el estado
de la CPU (incluyendo el valor de los registros).

El proceso sigue en ejecución mientras al menos uno de sus hilos de ejecución siga
activo. Cuando el proceso finaliza, todos sus hilos de ejecución también han terminado.
Asimismo en el momento en el que todos los hilos de ejecución finalizan, el proceso no
existe más y todos sus recursos son liberados.

Algunos lenguajes de programación tienen características de diseño expresamente

creadas para permitir a los programadores lidiar con hilos de ejecución (como Java o
Delphi). Otros (la mayoría) desconocen la existencia de hilos de ejecución y éstos deben
ser creados mediante llamadas de biblioteca especiales que dependen del sistema
operativo en el que estos lenguajes están siendo utilizados (como es el caso del C y del
C++).

Un ejemplo de la utilización de hilos es tener un hilo atento a la interfaz gráfica (iconos,

botones, ventanas), mientras otro hilo hace una larga operación internamente. De esta
manera el programa responde de manera más ágil a la interacción con el usuario.
También pueden ser utilizados por una aplicación servidora para dar servicio a múltiples
clientes.

Funcionalidad de los hilos

Al igual que los procesos, los hilos poseen un estado de ejecución y pueden sincronizarse
entre ellos para evitar problemas de compartimiento de recursos. Generalmente, cada hilo
tiene una tarea especifica y determinada, como forma de aumentar la eficiencia del uso
del procesador.

 Informática
 Diseño Web
 Proyectos
 Ocio

Muchos lenguajes de programación permiten la creación de hilos o threads en un

programa. De forma resumida, los hilos son un mecanismo mediante el cual podemos
devidir una aplicación en diferentes partes que se pueden ejecutar de forma paralela,
existiendo mecanismos por los que pueden compartir información.

C# ofrece un mecanismo muy sencillo de implementar hilos, basado en la utilización de la

clase Thread. El constructor de esta clase recibe como parámetro el método o función que
hay que ejecutar en paralelo. Este parámetro se indica mediante la utilización de un
delegado, que es el mecanismo que, entre otras cosas, se utiliza en .NET para utilizar
punteros a funciones de forma segura. La firma del delegado no incluye ningún
parámetro, por lo que únicamente es posible crear hilos de forma directa sobre métodos y
funciones que no requieran parámetros de entrada ni de salida. En los siguientes
ejemplos muestro un caso sencillo de creación de un hilo y otro en el que explico una
forma de poder crear un hilo con entrada y salida de parámetros.
En el siguiente ejemplo se dispone de una clase con dos métodos que muestran
mensajes por pantalla. El objetivo es crear dos hilos, uno para cada uno de los métodos y
ejecutarlos de forma paralela, de forma que podamos ver como resultado cómo se van
intercalando los mensajes escritos por cada método.

using System;
using System.IO;
using System.Threading;

public class Mensajes{

public void Mostrar1()
{
for(int i=0;i<10;i++){
Console.WriteLine("Escribiendo desde ==> 1″);
Thread.Sleep(1000);
}
}

public void Mostrar2()

{
for(int i=0;i<10;i++){
Console.WriteLine("Escribiendo desde ==> 2″);
Thread.Sleep(1000);
}
}
}

public class Ejemplo{

public static void Main()

{
Mensajes msg = new Mensajes();

Thread th1 = new Thread(new ThreadStart(msg.Mostrar1));

Thread th2 = new Thread(new ThreadStart(msg.Mostrar2));

th1.Start();
th2.Start();

th1.Join();
th2.Join();
}

La creación de cada hilo se realiza mediante las líneas Thread th1 = new Thread(new
ThreadStart(msg.Mostrar1));. Esta línea indica que se crea una instancia de la clase
Thread, con nombre th1, a partir de un delegado de la clase ThreadStart, que apunta al
método Mostrar1 del objeto msg creado anteriormente.
Una vez creados los dos hilos hay que activarlos, para lo que se llama al método Start de
cada uno de ellos. Tras este punto cada hilo se ejecuta en paralelo entre si, y con el
programa principal, por lo que utilizamos el método Join de ambos hilos para esperar a
que terminen los hilos antes de finalizar el programa.

El delegado ThreadStart no acepta parámetros de entrada ni de salida, por lo que si

queremos crear un hilo sobre un método que los necesite, hay que utilizar algún
mecanismo auxiliar. Una posible forma de conseguir esto es crear una nueva clase con
los parámetros necesarios en la entrada y con un nuevo método sin parámetros que llame
al método que queremos hacer paralelo, enviándole estos parámetros. A partir de aquí
tendríamos que crear una instancia de dicha clase con los parámetros que queremos
enviar al método original, y hacer que el hilo se ejecutase sobre el nuevo método de la
clase. En el caso de que quisiéramos obtener el resultado de la ejecución, deberíamos
crear una función que acepte como parámetro de entrada el tipo del valor devuelto por el
método original, y hacer que la nueva clase creada disponga también de un delegado que
indique la función a la que llamar tras la ejecución.

Como esto puede parecer un poco lioso, vamos a ver otro ejemplo. En esta ocasión
disponemos de una clase de funciones matemáticas y queremos llamar de forma paralela
a una de ellas. Este método acepta un valor entero en la entrada y devuelve otro entero.

using System;
using System.Threading;
using System.IO;

public class EjemploMates{

public static int CalculoComplejo(int n)

{
// sumo uno y espero 5 segundos
n = n+1;
Thread.Sleep(5000);
return n;
}

public class HiloParaMates{

protected int n;
protected MatesCallback callback = null;
public HiloParaMates(int n, MatesCallback callback){
this.n = n;
this.callback = callback;
}
public void CalculoComplejo()
{
int result = EjemploMates.CalculoComplejo(n);
if(callback != null)
callback(result);
}
}
// creo un delegado con la firma necesaria para capturar
// el valor devuelto por el método CalculoComplejo
public delegate void MatesCallback(int n);

public class Ejemplo{

public static void Main()

{
HiloParaMates hpm = new HiloParaMates(1000, new MatesCallback(ResultCallback));

Thread th = new Thread(new ThreadStart(hpm.CalculoComplejo));

th.Start();
th.Join();

public static void ResultCallback(int n)

{
Console.WriteLine("Resultado de la operación: "+n);
}
}

En el anterior código la clase HiloParaMates es la que nos permite encapsular la llamada

al método EjemploMates.Calcular. Este método requiere un parámetro de tipo entero, por
lo que la clase requiere este parámetro en su constructor. Además se requiere en el
constructor otro parámetro más, un delegado MatesCallback, que acepta un entero en la
entrada. La idea es que tras realizar el cálculo se llame al método que se indique
proporcionándole el resultado.

Para hacer funcionar todo esto, en Main se crea una instancia de la clase HiloParaMates
indicándole que queremos utilizar el valor numérico 1000 y que se llame al método
(estático) ResultCallback cuando se obtenga el resultado. Para crear el hilo es suficiente
con indicar que se quiere hacer sobre el método CalculoComplejo de la instancia hpm.

Set

Define un método de descriptor de acceso en una propiedad o indizador que estableció el

valor de la propiedad o el elemento del indizador. Vea Propiedades e Indizadores para
obtener más información.

Éste es un ejemplo de un descriptor de acceso set para una propiedad denominada

Seconds:

class TimePeriod
{
private double _seconds;
public double Seconds
{
get { return _seconds; }
set { _seconds = value; }
}
}
Get (Referencia de C#)

Define un método de descriptor de acceso en una propiedad o indizador que recupera el

valor de la propiedad o el elemento del indizador. Vea Propiedades (Guía de
programación de C#) e Indizadores (Guía de programación de C#) para obtener más
información.

Éste es un ejemplo de un descriptor de acceso get para una propiedad denominada

Seconds:

class TimePeriod
{
private double _seconds;
public double Seconds
{
get { return _seconds; }
set { _seconds = value; }
}
}
 Unidad 2
Resumen de clases.

Lo visto en la primera clase es como se declara una cabecera en el cuerpo de un

programa y para que sirve esta, por consiguiente también se dijo para que y como era que
se declaraba un main en el código.

Otras de las cosas fue como era la cabecera de la clase vector y como era el comienzo de
una clase.

#include <vector>

También como era la sobre-carga de un operador como los siguientes:

cout<<x;//tipo ostream

cout<<"2001073";

cout.operator<<(char);

cout.operator<<(x);

cout.operator<<(string);

cin>>x;//tipo istream

lo visto en la segunda clase era que se declara dos archivos uno de tipo .h y otro de .cpp
en uno se declara el prototipo y en el otro sus funciones y como era la declaración de una
clase.

class persona{

public :

string nombre;

string apellido;

string curp; }

Otra de las clases iba declarada en el .h y su funcionalidad en el .cpp

codigo.h void intercambio (int* , int*)

#indef codigo_h //prototipos

#define codigo_h #endif

//siempre se declaran codigo.cpp

#include <oitream> *x=*y;//desreferencia

void intercambio (int* x,int* y) *y=temp;

int temp=*x;

int main ( ){

int x=2;

int y=3;

intercambio (&x;*y);//llamada a la función

También como se hace una referencia con dirección y el valor en memoria y se dijo que
los dos archivos facilitaban el manejo de declaración de variables.
 #include <vector>

La estructura de la clase vector está pensada para operar con arreglos unidimencionales
de datos, los elementos de un vector pueden ser manipulados de la misma manera en
que se hace con las estructuras de arreglos (arrays) tradicionales en C, C++; es decir, los
componentes de un vector pueden ser referenciados a travez de un índice numérico, de la
misma manera que en un arreglo cualquiera. Por ejemplo, si A es un objeto de vector,
entonces la instrucción: A[0]; se refiere al componente 0 (primer elemento) de A. El
resultado de todo esto es que usted puede navegar o iterar a travez de los componentes
de una lista haciendo uso de índices, o si lo prefiere a travez de punteros iteradores. Si
usted desea ver una lista completa de los métodos asociados a la clase vector siga éste
enlace pero recuerde que no todos ellos serán cubiertos aquí.

Para comenzar, vamos a presentar un ejemplo sencillo, el cual consistirá en crear un

vector de números de punto flotante. Al vector creado le agregaremos una serie de
valores los cuales posteriormente serán sumados y desplegados en la pantalla del
monitor. Para nuestro ejemplo vamos a emplear los métodos push_back (para agregar los
números), size (para obtener el número de componentes en el vector), e iteraremos por
medio de índices numéricos.

Para declarar una variable de tipo vector, podemos usar alguna de las siguientes tres
formas:

// vector <tipo> variable;

vector <int> v; // Crea un vector vacío
vector <int> v(n); // Crea un vector con n elementos
vector <int> v(n, t); // Crea un vector con n copias de t

Los métodos que podemos usar se muestran en la siguiente tabla, en ellos se supondrá
que se ha declarado lo siguiente:

vector <int> v;
vector <int>::iterator it;

ejemplo:
#include <cstdlib>
#include <iostream>
#include <vector>

using namespace std;

int main(int argc, char *argv[])

{
char buffer[80];
double suma;
vector<double> v;

v.push_back(999.25);
 v.push_back(888.50);
v.push_back(777.25);

suma = 0;
for(int i = 0; i < v.size(); i++)
{
suma += v[i];
sprintf(buffer, "%10.2f", v[i]);
cout << buffer << endl;
}

cout << "----------" << endl;

sprintf(buffer, "%10.2f", suma);
cout << buffer << endl;

cin.get();
return EXIT_SUCCESS;
}

De acuerdo con la referencia de ayuda de Dev-C++ es más seguro emplear el método at()
en lugar el eperador [] para leer o escribir componentes en un vector, ya que at() no
permite índices fuera del vector, y el operador [] sí. Por ejemplo, si V es un vector cuyo
número de componentes es de 3, entonces la instrucción V[5]; es sumamente peligrosa
ya que el índice 5 está fuera del rango (0 a 2 ) de los componentes de V; por otro lado, la
instrucción V.at(5); también está fuera de rango, salvo que at() en lugar de leer o escribir
el componente referenciado lanzará (throw) un error de excepción, de tal manera que en
el programa se pueda controlar la condición de error por medio de un catch. El método
at() actua de manera parecida al operador [], y para ver un ejemplo de su uso compile y
ejecute el siguiente programa.

#include <cstdlib>
#include <iostream>
#include <vector>

using namespace std;

int main(int argc, char *argv[])

{
vector<char> v;

// llenamos el vector v con valores desde la 'A' hasta la 'Z'

for (int x = 'A'; x <= 'Z'; x++) v.push_back(x);

// despliegue de los elementos del vector v

// mediante el operador [].
for(int i = 0; i < v.size(); i++)
cout << v[i] << " ";

// despliegue de los elementos del vector v

// mediante el método at().
for(int i = 0; i < v.size(); i++)
 cout << v.at(i) << " ";

cout << endl;

cin.get();
return EXIT_SUCCESS;
}

Tabla de métodos

Métodos de la clase vector

assign asignar elementos al vector
at regresa el componente de una posición específica
back regresa una referencia a el último componente del vector
begin regresa un iterator al principio del vector
regresa el número de elementos que pueden ser
capacity
contenidos por el vector
clear remueve todos los componentes del vector
empty true si el vector está vacio
end regresa un iterator al final del vector
erase remueve componentes del vector
front regresa una referencia al primer componente del vector
insert insertar componentes en el vector
regresa el número máximo de elementos soportados por
max_size
el vector
pop_back remueve el último componente del vector
push_back agrega un componente al final del vector
rbegin regresa un reverse_iterator hacia el final del vector
rend regresa un reverse_iterator hacia el inicio del vector
reserve establece la capacidad mínima del vector
resize cambia el tamaño del vector
size regresa el número de componentes en el vector
 swap intercambia el contenido de un vector con el de otro

Constructor de la clase Vector

Hay 3 constructores sobrecargados en la clase vector de exclusión de la predeterminada.

Vamos a discutir acerca de ellos uno por uno. Usted puede crear un objeto vectorial, con
un tamaño predefinido y los valores para ellos. Aquí es cómo usted puede hacer eso.
Suponga que desea crear un vector <int> objeto cuya capacidad inicial será de 10 y todos
los valores se establece en 2. Entonces usted puede crear ese objeto utilizando una de
las versiones sobrecargadas del constructor de vector

vector <int> nums (10,2);

Si sólo desea especificar la capacidad, pero no queremos asignar valores para ellos
entonces puede usar el otro constructor que acepta un entero para establecer la
capacidad del vector, como

vector <int> nums (100);

El último constructor le permite inicializar el vector con los datos de otros vectores o
matrices o de otras colecciones. Supongamos que desea copiar un vector a otro a
continuación, este constructor demuestra ser muy útil. Aquí está el fragmento de código.

vector <int> nums; for (int i = 1; i <5; i + +) nums.push_back (i); vector <int> códigos
(nums);

He aquí los códigos es un vector. Hemos copiado el contenido de nums en los códigos
con el constructor.

Los métodos de la clase de vectores

 _Destroy ()
 _Eq ()
 _Lt ()
 _Ucopy ()
 _Ufill ()
 assign ()
 at ()
 begin ()
 back ()
 capacidad ()
 clear ()
 empty ()
 final ()
 erase ()
 front ()
 get_allocator ()
 max_size ()
 insert ()
 operador =
 operador []
 pop_back ()
 push_back ()
 rbegin ()
 rend ()
 reserva ()
 cambiar el
tamaño ()
 size ()
 intercambio ()
 ~ Vector ()
 Aquí vamos a discutir acerca de cada método, le mostrará lo que hace y luego, al final
vamos a dar ejemplo en el que usted puede usar estos métodos a la vez ....

Los métodos que empiezan con un guión bajo protección de métodos y no se puede
acceder usando el objeto de la clase. Estos métodos son utilizados por otro método
internamente.

assign () y size ()

Este método se utiliza para asignar un tamaño inicial del vector. Este método tiene 2
versiones sobrecargadas. Aquí hemos utilizado el primer método sobrecargado. Este
método toma un argumento entero para inicializar el tamaño del vector.

# include <iostream>
# include <vector>
# include <conio.h>

using namespace std;

int main ()
(
Vector <char> códigos;
codes.assign (10); / / Asignar el tamaño a 10.
cout <<codes.size ();// imprime el tamaño del vector
getch ();
return 0;
)

El partido sobrecarga que asuma el próximo 2 de puntero como argumentos. Aquí

hay un código de ejemplo

# include <iostream>
# include <vector>
# include <conio.h>
using namespace std;

int main ()
(
char a [3] = ( 'a', 'b', 'c');
Vector <char> órdenes;
órdenes. asignar (a, a +3);
cout <<orders.size ();
getch ();
return 0;
)

Aquí el puntero utilizado no son sino el nombre de la matriz. Este concepto se debe al
nombre de C. Básicamente matriz es un puntero a la matriz.
 at ()
No importa cuán sofisticada herramienta que conseguimos, el acceso a la gama C de
estilo antiguo utilizando el índice es muy popular. Esta cosa se tuvo en cuenta cuando
se diseñó STL. Como se comporta como vector de una matriz abierta, la gente espera
que para mostrar otros comportamientos de la matriz. en () es un método que toma un
entero como argumento y devuelve el valor en ese lugar. Así, en una forma que
simula la edad de indexación de arrays de edad. Aquí está un fragmento de código.

# include <iostream>
# include <vector>
# include <conio.h>

using namespace std;

int main ()
(
vector <int> códigos;
for (int i = 0; i <10; i + +)
codes.push_back (i);
cout <<codes.at (9) <<endl;
getch ();

return 0;
)

La salida de este código será de 9.

begin (), end ()

En STL en los contenedores, los elementos son accesibles usando iteradores. Los
iteradores son algo así como punteros. begin () y final () devuelve el iterador al
principio y al final del contenedor. He aquí una cosa hay que señalar final () apunta a
una ubicación que es uno después del final físico del contenedor. Estos dos métodos
son los más utilizados en STL, porque para atravesar un contenedor, es necesario
crear un iterador. Y entonces para inicializar su valor al inicio del contenedor. Aquí
está el código para recorrer un vector <>. Este código de hacer uso de comenzar () y
final () métodos.

# include <iostream>
# include <vector>
using namespace std;

int main ()
(
vector <int> números;
for (int i = 0; i <10; i + +)
numbers.push_back (i);
/ / Assiging al principio
<int> vector:: iterator k = Numbers.begin ();
/ / Tenga en cuenta que K es inferior al que
 / / numbers.end (), porque los puntos finales () en algún lugar que está más allá del
final físico.
for (; k <numbers.end (); k + +)
cout <<* k <<endl;
return 0;
)

frente (), back ()

() frente método devuelve el elemento en la parte delantera del vector. Volver ()

devuelve el elemento en la parte posterior del vector. Aquí está el código para
comprender mejor sus operaciones.

# include <iostream>
# include <vector>
using namespace std;

int main ()
(
vector <int> m;
for (int i = 0; i <10; i + +)
m.push_back (i);
cout <<m.front () <<endl;
cout <<m.back () <<endl;
return 0;
)

La salida de este programa es

0
9

() capacidad, el tamaño ()

capacidad () devuelve el número de elementos del vector puede tener inicialmente

asignado. Para un vector aunque no es muy importante el método. Por otra parte, el
tamaño de método () devuelve el número de elementos que están actualmente en el
vector. Aquí está el código que le ayudará a entender la diferencia entre la capacidad
() y tamaño ().

# include <iostream>
# include <vector>
using namespace std;

int main ()
(
vector <int> m (100);
cout <<m.capacity () <<endl;
for (int i = 0; i <10; i + +)
m.push_back (i);
cout <<m.size () <<endl;
return 0;
)

STL

Antes de empezar a cavar hondo en STL, es obligatorio que aprendemos acerca de

las clases de contenedores.

Una clase de contenedor se define como una clase que te da el poder para almacenar
cualquier tipo de datos. Existen dos tipos de clases de contenedores disponibles en
STL en C + +, es decir, "Clases de simple contenedor" y "Clases de contenedores
asociativos". Un asociados clase asociativa Container una clave para cada objeto de
reducir al mínimo el tiempo de acceso promedio.

Clases simples contenedores

 vector <>
 listas de <>
 pila <>
 cola <>
 deque <>

Asociativa clases de contenedores

 Mapa <>
 se <>
 Multimap <>
 multiconjunto <>

Este artículo discutirá acerca de las clases simples contenedores en detalle. Esto
le mostrará cómo utilizar los diferentes métodos de estas clases para lograr su
objetivo. Vamos a empezar con vector <>

vector <> El Conjunto abierto

 cin y cout (entradas y salidas estándar en c++)

Un programa en C++ puede realizar operaciones de entrada y salida de varias formas

distintas. A continuación describiremos lo que se conoce como flujos. Un flujo de
entrada no es más que la serie de entradas que alimentan un ordenador para que el
programa las utilice. En esta sección supondremos que la entrada proviene del
teclado. Asimismo, un flujo de salida es la serie de salidas que el programa genera. En
esta sección supondremos que las salidas se envían a la pantalla de un terminal.
Salidas con cout
Los valores de variables se pueden enviar a la pantalla empleando cout. Es posible
enviar a la pantalla cualquier combinación de variables y cadenas.
Por ejemplo:
cout << num_dulces << “dulces\n”;
Esta instrucción le dice a la computadora que despliegue dos cosas: el valor de la
variable num_dulces y la cadena “dulces\n”. Esta instrucción es equivalente a:
cout << num_dulces ;
cout << “dulces\n”;
Se pueden incluir expresiones aritméticas, como se muestra en el siguiente ejemplo:
cout << “El precio total es: “ << (precio1 + precio2);
El doble símbolo << se conoce como operador de inserción.
En los ejemplos anteriores hemos utilizado una secuencia de carácteres especial „\n‟.
Esta secuencia indica al ordenador que salte a una nueva línea en la salida.
Existen otros secuencias especiales. Todas ellas empiezan con „\‟ y se les llama
secuencias de escape. No deben aparecer espacios entre „\‟ y el carácter.
Algunas secuencias de escape:
\n nueva línea
\t tabulación horizontal.
\\ diagonal invertida
\” comillas dobles
Ejemplo:
// Envia una línea en blanco a la salida estándar
//(pantalla)
cout << “\n”;
Otra forma de enviar un salto de línea es la utilización de endl.
// Envia una línea en blanco a la salida estándar (pantalla)
cout << endl;
Formateo de salidas con funciones de flujos
La organización de la salida de un programa en C++ es su formato. En C++ podemos
controlar el formato con órdenes que determinan detalles tales como el número de
espacios entre los elementos y el número de dígitos después del punto decimal
Veamos algunas funciones o métodos asociadas a los flujos de salida:
• precision: Fijar el número de cifras después de la coma: precision

cout.precision(2);
• width: Indica al flujo cuantos espacios debe usar al enviar un elemento a la
salida.

cout.width(4);
El método width solamente afecta a la siguiente salida por pantalla.
• fill: Indica el carácter con lo que completa los espacios en blanco cuando se
manda un elemento a la salida y se fija el número de espacios con la función
width.

cout.fill(„a‟);
 Al igual que el método width, el método fill solamente afecta a la siguiente
salida por pantalla.
• setf: es una abreviatura de set flags, que significa establecer banderas. Una
bandera es algo que indica que se debe efectuar algo de una de dos posibles
maneras. Si damos una determinada bandera como argumento de setf, dicha
bandera le dirá a la computadora que escriba las salidas en ese flujo de alguna
forma específica. El efecto sobre el flujo depende de la bandera.

Banderas:
ios::fixed : hace que el flujo envíe a la salida los número en formato de
punto fijo (no notación e).
ios::showpoint : le dice al flujo que siempre incluya un punto decimal
en los números en punto flotante.
ios::showpos : le dice al flujo que escribe un signo + para los números
positivos.
ios::left: si esta bandera está establecida y se da algún valor de
anchura de campo con una llamada a la función miembro width, el siguiente
número que se despliegue estará en el extremo derecho del espacio
especificado con width.
ios::rigth: igual que la bandera anterior pero a la derecha.
cout.setf(ios::fixed);
cout.setf(ios::showpos);
cout.setf(ios::showpoint);
cout.setf(ios::left);
cout.setf(ios::right);
• unsetf: Cualquier bandera establecida se puede desactivar con esta función
miembro. Por ejemplo:

cout.unsetf(ios::showpos);

Nota: una vez establecida una bandera o valor se mantiene en todo el programa a no
ser que se utilice la función miembro unsetf o se varie el valor con el método
adecuado.
Entrada con cin
cin es el flujo de entrada estandar. Supondremos que la entrada estandar es el
teclado.
Veamos un ejemplo:
cin >> num_pasteles;
En la sentencia anterior lo que hacemos es leer un dato introducido por teclado y
almacenarlo en una variable „num_pasteles‟.
Entrada y Salida de caracteres
Todos los datos se envian como caracteres. Cuando un programa envía a la salida el
número 10, en realidad lo que envía son los dos caracteres „1‟ y „0‟. Qué la
computadora interprete el número 10 o los caracteres „1‟ y „0‟ depende del programa.
C++ ofrece algunos recursos para la entrada y salida de datos de caracteres.
Funciones miembro o métodos:
get: permite a un programa leer un carácter de entrada y guardarlo en una
variable de tip char. Está función toma un argumento, que debe ser una
variable de tipo char. Por ejemplo:

char siguiente_simbolo;
cin.get(siguiente_simbolo);
Comparación de cin >> y cin.get:
char c1,c2,c3,c4,c5;
//Introduce 4 caracteres en 2 lineas diferentes
cin.get(c1);
cin.get(c2);
cin.get(c3);
cin.get(c4);
//Imprimo los caracteres leidos
cout << "Los 4 caracteres leidos son:\n";
cout.put(c1);
cout.put(c2);
cout.put(c3);
cout.put(c4);
Con cin >>:
//Prueba con cin
char c1, c2, c3, c4;
//Introduce 4 caracteres separados por espacios
cin >> c1;
cin >> c2;
cin >> c3;
cin >> c4;
cout << "Los 4 caracteres leidos son:\n";
cout << c1 << c2 << c3 << c4;
La diferencia consiste en que el primero lee los espacios y „\n‟ y los almacena en
las variables y el segundo ignora estos caracteres y los utiliza como carácteres
separadores.

• put: es análoga a la función miembro get sólo que se emplea para salida.
Mediante put un programa puede enviar a la salida un carácter. La función
miembro put recibe un argumento que debe ser una expresión de tipo char
(constante o variable). Por ejemplo:

char ch;
ch=‟a‟;
cout.put(ch);
• ignore: este método permite descartar caracteres existentes en el buffer de
entrada.

char ch1,ch2;
cout << “ Introduce 2 caracteres en líneas diferentes:\n”;
cin.get(ch1);
cin.ignore(); //Ignora „\n‟
cin.get(ch2);
cin.ignore(); // Ignora „\n‟
cout << “Los caracteres leídos son:\n”;
cout.put(ch1);
cout.put(„ „); //Escribo un espacio de separacion
cout.put(ch2);
 wxWidgets.

wxWidgets es un C + + marco que establecen GUI (Graphical User Interface) y otros

instalaciones en más de una plataforma. La versión 2 actualmente soporta todas las
versiones de escritorio de
MS Windows, Unix con GTK +, Unix con Motif, y MacOS. OS / 2 puerto está en
marcha.
wxWidgets fue originalmente desarrollado en el Instituto de Aplicaciones de
Inteligencia Artificial,
Universidad de Edimburgo, para uso interno, y por primera vez a disposición del
público en 1992.
La versión 2 es una versión ampliamente mejorada por escrito y mantenido por Julian
Smart, Robert
Roebling, Vadim Zeitlin, Vaclav Slavik y muchos otros.
Este manual contiene una referencia de clase y resúmenes tema. Para una selección
de wxWidgets
tutorías, por favor, consulte la página de documentación en el sitio web de wxWidgets
Tenga en cuenta que en el siguiente, "MS Windows" a menudo se refiere a todas las
plataformas relacionadas con la
Microsoft Windows, incluyendo 16-bit y 32-bit de variantes, a menos que se indique lo
contrario..

wxButton
Un botón es un control que contiene una cadena de texto, y es uno de los elementos
más comunes de los otra ventana.

Incluir archivos
<wx/button.h>
Estilos de ventanas
Izquierda wxBU_LEFT-justifica la etiqueta. Windows y GTK + solamente.
wxBU_TOP Alinea la etiqueta a la parte superior del botón. Windows y GTK +
solamente.
wxBU_RIGHT Haga justifica la etiqueta de mapa de bits. Windows y GTK + solamente.
wxBU_BOTTOM Alinea la etiqueta en la parte inferior del botón. Windows y
GTK + solamente.
wxBU_EXACTFIT Crea el botón tan pequeñas como sea posible en lugar de hacerlo
del tamaño estándar (que es el comportamiento por defecto).
wxNO_BORDER Crea un botón plano. Windows y GTK + solamente.

wxButton:: wxButton
wxButton ()
Default constructor.
(* wxButton wxWindow padre, wxWindowID id, const wxString & label =
wxPoint const wxEmptyString, & pos = wxDefaultPosition, const wxSize & size =
wxDefaultSize, long style = 0, wxValidator const validador = wxDefaultValidator, const
wxString & name = "botón")
wxButton:: ~ wxButton
~ wxButton ()
Destructor, destruyendo el botón.
wxButton:: Create
bool Crear (* wxWindow padres, wxWindowID id, const wxString & label =
wxPoint const wxEmptyString, & pos = wxDefaultPosition, const wxSize & size =
wxDefaultSize, long style = 0, const wxValidator validador, const wxString & name =
"botón")

wxButton:: getLabel
getLabel wxString () const

wxButton:: GetDefaultSize
GetDefaultSize wxSize ()
Devuelve el tamaño por defecto de los botones. Se recomienda hacer todos los
botones de diálogo de la
mismo tamaño y esta función permite recuperar la (plataforma y dependientes de
fuente actual
tamaño) que debe ser el más adecuado para ello.
wxButton::SetDefault
void SetDefault()

Esto establece el botón para ser el tema por defecto para el grupo especial o cuadro
de diálogo.
Comentarios
En Windows, los botones de cuadro de diálogo sólo responden a esta función. Como
normales en
Windows y Motif, el retorno pulsando el botón predeterminado causas a la depresión
cuando el
tecla de retorno es presionado. Véase también wxWindow:: SetFocus , que establece
el teclado
enfoque para las ventanas y elementos del panel de texto, y wxTopLevelWindow::
SetDefaultItem
Tenga en cuenta que en virtud de Motif, llamar a esta función inmediatamente después
de la creación de un botón y la
antes de la creación de otros botones hará que la desalineación de la fila de botones,
ya que
botones por defecto son más grandes. Para evitar esto, llame Por defecto después de
haber creado una fila de
de botones: wxWidgets continuación, establecer el tamaño de todos los botones en la
actualidad en el panel a la
mismo tamaño.
wxButton:: SetLabel
void setLabel (const wxString & etiqueta)
wxButton:: getLabel

wxString
wxString es una clase que representa una cadena de caracteres. Por favor vea la
información general wxString.
Como se explica allí, wxString implementa la mayoría de los métodos de la std:: clase
de cadena.
Estas funciones estándar no están documentadas en este manual, por favor, consulte
theSTL
documentación. El comportamiento de las todas estas funciones es idéntico al
comportamiento descrito allí.

Incluir archivos
<wx/string.h>
Objetos predefinidos
Objetos:
wxEmptyString

wxString ()
Default constructor. Inicializa la cadena "" (cadena vacía).
wxString (const wxString & x)
Constructor de copia.
wxString (wxChar ch, size_t n = 1)
Construye una cadena de n copias de carácter ch.
wxString (wxChar const char * psz, size_t nLength = wxSTRING_MAXLEN)
Toma nLength primeros caracteres de la cadena de C PSZ. El valor predeterminado
de
wxSTRING_MAXLEN significa tomar todas las cadenas.

wxString(const unsigned char* psz, size_t nLength = wxSTRING_MAXLEN)

wxString(const wchar_t* psz, wxMBConv& conv, size_t nLength =

wxSTRING_MAXLEN)

wxString:: ~ wxString
~ wxString ()

Destructor de cuerdas. Tenga en cuenta que esto no es virtual, por lo que wxString no
debe ser heredado.

wxString::Alloc
void Alloc(size_t nLen)
wxString::Append
wxString& Append(const wxChar* psz)
wxString& Append(wxChar ch, int count = 1)
wxString::AfterFirst
wxString AfterFirst(wxChar ch) const
wxString::AfterLast
wxString AfterLast(wxChar ch) const
wxString::BeforeFirst
wxString BeforeFirst(wxChar ch) const
wxString::BeforeLast
wxString BeforeLast(wxChar ch) const
wxString::c_str
const wxChar * c_str() const
wxString::char_str
wxWritableCharBuffer char_str(wxMBConv& conv = wxConvLibc) const
wxString::Cmp
int Cmp(const wxString& s) const
int Cmp(const wxChar* psz) const
wxString::CmpNoCase
int CmpNoCase(const wxString& s) const
int CmpNoCase(const wxChar* psz) const
wxString::Contains
bool Contains(const wxString& str) const
wxString::CompareTo
enum wxString::caseCompare {exact, ignoreCase};
int CompareTo(const wxChar* psz, caseCompare cmp = exact) const
wxString::Empty
void Empty()
wxString::Find
int Find(wxChar ch, bool fromEnd = false) const
wxString::First
int First(wxChar c)
int First(const wxChar* psz) const
int First(const wxString& str) const
wxString::fn_str
const wchar_t* fn_str() const
const char* fn_str() const
const wxCharBuffer fn_str() const
wxString::FromAscii
static wxString FromAscii(const char* s)
static wxString FromAscii(const char c)

wxTextCtrl
Un control de texto permite que el texto que se mostrará y editado. Puede ser de una
sola línea o de varias líneas.
Derivado de streambuf

<wx/textctrl.h>
Estilos de ventanas
wxTE_PROCESS_ENTER El control va a generar el evento
wxEVT_COMMAND_TEXT_ENTER (de otro modo pulsando
Tecla Enter o es procesado internamente por el control o
utilizados para la navegación entre los controles de diálogo).
wxTE_PROCESS_TAB El control recibirá eventos

wxEVT_CHAR

wxTE_MULTILINE El texto permite el control de varias líneas.

wxTE_PASSWORD El texto se hizo eco como asteriscos.
wxTE_READONLY El texto no será fácil de modificar.
wxTE_RICH Utilice el control de texto enriquecido en Win32, lo que permite disponer
de más
de 64KB de texto en el control, incluso bajo Win9x. Este estilo
se ignora en virtud de otras plataformas.
wxTE_RICH2 ricos utilizar la versión de texto del control 2.0 o 3.0 en Win32, este
el estilo es ignorado en otras plataformas
Resalte wxTE_AUTO_URL las direcciones URL y generar el wxTextUrlEvents cuando
ocurren los eventos de ratón sobre ellos. Este estilo sólo se admite
wxTE_RICH para Win32 y de varias líneas wxGTK2 controles de texto.
wxTE_NOHIDESEL De forma predeterminada, el control de texto de Windows no
muestra el
selección, cuando no tiene el foco - el uso de este estilo a la fuerza
para que siempre demostró. No hace nada en virtud de otros
plataformas.
wxHSCROLL una barra de desplazamiento horizontal se crea y utiliza, de manera que
el texto de
no será envuelto. No tiene efecto en virtud de wxGTK1.
wxTE_LEFT El texto en el control será justificado a la izquierda (por defecto).
wxTE_CENTRE El texto en el control se centrará (actualmente wxMSW
y wxGTK2 solamente).
wxTE_RIGHT El texto en el control se alinea a la derecha (en la actualidad
wxMSW y wxGTK2 solamente).
wxTE_DONTWRAP Igual que el estilo wxHSCROLL: No envuelva a todos, mostrar
barra de desplazamiento horizontal en su lugar.
wxTE_CHARWRAP ajustar las líneas demasiado largo para ser mostrado en cualquier
posición totalmente
(wxUniv y wxGTK2 solamente).
xTE_WORDWRAP ajustar las líneas demasiado largo para ser mostrado totalmente
en la palabra
fronteras (wxUniv y wxGTK2 solamente).
wxTE_BESTWRAP ajustar las líneas en los límites de palabra o en cualquier otro
carácter
si hay palabras más que la anchura de la ventana (esta es la
por defecto).
El wxTE_CAPITALIZE PocketPC y Smartphone, hace que la primera carta que se
capitalizados.
text-> AppendText ( "Red de texto \ n");
text-> SetDefaultStyle (wxTextAttr (wxNullColour,
* wxLIGHT_GREY));
text-> AppendText ( "Rojo en el texto gris \ n");
text-> SetDefaultStyle (wxTextAttr (* wxBLUE);
text-> AppendText ( "Azul sobre el texto gris \ n");
corrientes wxTextCtrl y C + +

Template

Nos permite escribir codigo generico que puede ser usado con varios tipos de datos.
Sin templates, se tendrian que reescribir muchas funciones y clases. Tomemos el
siguiente ejemplo de una funcion que retorna el maximo de dos valores.

int max(int x, int y)

{
return (x < y) ? y : x;
}

float max(float x, float y)

{
return (x < y) ? y : x;
}

Como podemos ver, sin templates dos funciones que tienen el mismo cuerpo se tienen
que reescribir para que funcione con varios tipos. Veamos la misma funcion usando
templates.

template <typename T>

T max(T x, T y)
{
return (x < y) ? y : x;
}

Esta funcion funciona con cualquier tipo que se pueda comparar con el operador <.
Funciona hasta con tu propia clase si ella tiene el operador < implementado. Tambien
se puede tener templates para clases. Clases como std::vector y std::list son
templates y nos permiten usarlas para cualquier tipo que querramos.

Las plantillas de clases o clases genéricas tienen la siguiente sintaxis:

Template<lista_de_tipos_genericos>

Class nombre{

//cuerpo de la clase

};

La palabra template indica que se va a declarar una plantilla.

Las plantillas se declaran normalmente en un archivo de cabecera.

Plantillas de función:

Pueden operar con los tipo genéricos esto nos permite crear una plantilla de función
cuya funcionalida puede ser adoptada por mas de un tipo o clase, sin repetir el codigo
completo para cada tipo

El formato para la función que se declara en los parámetros de tipo es:

Template<class identific>

Funtion-declaration

Template<typename indentofic>

Funtion-declartion;
La única diferencia entre ambos prototipos es el uso de cualquiera de la clase de
palabra o clase.

Listas

Las listas son secuencias de elementos almacenados en una lista enlazada. En

comparación con los vectores, que permiten la inserción rápida y eliminaciones, pero
el acceso más lento al azar.

Constructores crear listas de e inicializar con algunos datos

Operadores asignar y comparar las listas
asignar asignar elementos a una lista
espalda devuelve una referencia al último elemento de una lista de
empezar devuelve un iterador al principio de la lista de
claro Elimina todos los elementos de la lista de
vacío true si la lista no tiene elementos
devuelve un iterador justo después del último elemento de una
final
lista de
borrar elimina los elementos de una lista de
frente devuelve una referencia al primer elemento de una lista de
insertar inserta elementos en la lista
devuelve el número máximo de elementos que la lista puede
max_size
contener
fusionar fusionar dos listas
pop_back Elimina el último elemento de una lista de
pop_front quita el primer elemento de la lista de
push_back agregar un elemento al final de la lista
push_front agregar un elemento al frente de la lista de
rbegin devuelve un reverse_iterator al final de la lista de
eliminar elimina los elementos de una lista de
remove_if elimina los elementos condicional
rend devuelve un reverse_iterator al principio de la lista de
cambiar el tamaño
cambiar el tamaño de la lista de
de
inversa invertir la lista
tamaño devuelve el número de elementos en la lista
tipo Ordena una lista en orden ascendente
empalme combinar dos listas en la constante de tiempo
swap intercambiar el contenido de esta lista con otro
único consecutivos elimina elementos duplicados

Lista de constructores
Sintaxis:
# include <list>
lista ();
 lista (lista const & c);
lista explícita (num size_type, const TIPO & val = TIPO ());
lista (inicio input_iterator, final input_iterator);
~ list ();
El constructor de la lista por defecto no tiene argumentos, crea una nueva instancia de
la lista.
El segundo constructor es un constructor de copia por defecto que se puede utilizar
para crear una nueva lista que es una copia de la lista que figura C.
El tercer constructor crea una lista con espacio para objetos num. Si no se especifica
Val, cada uno de esos objetos se dará ese valor. Por ejemplo, el siguiente código crea
una lista compuesta por cinco ejemplares de los 42 entero:
lista <int> L1 (5, 42);
El último constructor crea una lista que se inicia para contener los elementos entre el
comienzo y final. Por ejemplo:
/ / Crear un vector de corte aleatorio enteros << "lista original:"; lista <int> l; for
(int i = 0; i <20; i + +) (int num = (int) rand ()% 10 ; tribunal <<num << ""; L.
push_back (NUM);) tribunal <<endl; / / eliminar 5 y 7 de la lista <int>:: iterator iter1
= L. begin (), mientras que (iter1! = l . final ()) (list <int>:: thisone iterador = iter1; +
+ iter1, si (* thisone == 5 | | * thisone == 7) (tribunal << "borrar" <<* thisone <<endl
; L. borrar (thisone);)) / / Buscar el primer elemento de l que es aún lista <int>::
iterator iter2 = L. begin (), mientras que (iter2! l. = end () & & *% iter2 2! = 0) (+ +
iter2;) / / buscar el último elemento de l que es aún lista <int>:: iterator iter3 l. = end
(); do (- iter3;) while (iter3! = l . begin () & & * iter3% 2! = 0); tribunal << "incluso el
primer número:" <<* iter2 << ", número par pasada:" <<* iter3 <<endl; tribunal <<
"nueva lista "; lista <int> L2 (iter2, iter3); lista <int>:: iterator iter4 = L2. begin (),
mientras que (iter4! = L2. final ()) (tribunal <<* iter4 <<" " ; iter4 + +;) tribunal
<<endl;
Cuando se ejecuta, este código muestra el resultado siguiente:
lista original: 7 9 3 8 0 2 4 8 3 9 0 5 2 2 7 3 7 9 0 2
borrar 7
Borrar 5
borrar 7
borrar 7
número par primero: 8, último número par: 2
nueva lista: 8 0 2 4 8 3 9 0 2 2 3 9 0
Todos estos constructores se ejecutan en un tiempo lineal, excepto la primera, que se
ejecuta en tiempo constante.
El destructor por defecto llama al destructor para cada objeto en la lista con la
complejidad lineal.

Lista de operadores de
Sintaxis:
# include <list>
Lista & operator = (const Lista & c2);
bool operator == (const Lista & c1, const Lista & c2);
bool operator! = (const Lista & c1, const Lista & c2);
bool operator <(const Lista & c1, const Lista & c2);
bool operator> (const Lista & c1, const Lista & c2);
bool operator <= (const Lista & c1, const Lista & c2);
bool operator> = (const Lista & c1, const Lista & c2);
Todos los contenedores de C + + se pueden comparar y asignados con los operadores
de comparación estándar: ==,! =, <=,> =, <,>, Y =. Realizar una comparación o
asignación de una lista a otra toma tiempo lineal.
Dos listas son iguales si:
1. Su tamaño es el mismo, y
2. Cada miembro de i ubicación en una lista es igual a miembros de la i en la
ubicación en la otra lista.
Las comparaciones entre las listas se hacen lexicográficamente.

asignar
Sintaxis:
# include <list>
void assign (num size_type, const TIPO & val);
void assign (inicio input_iterator, final input_iterator);
La función assign () o bien da la lista actual de los valores de principio a fin, o le da
copias de val num.
Esta función va a destruir el contenido anterior de la lista.
Por ejemplo, el uso de código siguiente asignar () para poner 10 copias de el entero 42
en una lista:
lista <int> l;
L. asignar (10, 42);
de (lista <int>:: size_type i = 0; i <l. size (); i + +) (
tribunal <<l [i] << "";
)
<tribunal <endl;
El código anterior muestra el resultado siguiente:
42 42 42 42 42 42 42 42 42 42
El siguiente ejemplo muestra cómo asignar () se puede usar para copiar una lista a
otra:
lista <int> L1;
for (int i = 0; i <10; i + +) (
l1. push_back (i);
)

lista <int> L2;

L2. assign (l1. begin (), L1. final ());

de (lista <int>:: size_type i = 0; i <l2. size (); i + +) (

tribunal <<L2 [i] << "";
)
<tribunal <endl;
Cuando se ejecuta, el código de arriba muestra el resultado siguiente:
0123456789

empezar
Sintaxis:
# include <list>
iterator begin ();
const_iterator begin () const;
La función de comenzar () devuelve un iterador al primer elemento de la lista. Begin ()
debe ejecutar en tiempo constante.
Por ejemplo, el código siguiente se utiliza comenzar () para inicializar un iterador que
se utiliza para recorrer una lista:
/ / Crear una lista de caracteres
 <char lista> my_list;
for (int i = 0; i <10; i + +) (
my_list. push_front (i + 'a');
)

/ / Mostrar la lista de
lista <char>:: iterator it;
for (it = my_list. begin (); it! = my_list. end (); + + que) (
tribunal <<* it;
)

espalda
Sintaxis:
# include <list>
TIPO & back ();
TIPO const & back () const;
La parte de atrás () devuelve una referencia al último elemento de la lista.
Por ejemplo:
lista <int> l;
for (int i = 0; i <5; i + +) (
L. push_back (i);
)
tribunal << "El primer elemento es" <<L. delante ()
<< "Y el último elemento es" <<Volver L. () <<endl;
Este código genera el siguiente resultado:
El primer elemento es 0 y el último elemento es de 4
La parte de atrás () la función se ejecuta en tiempo constante.

claro
Sintaxis:
# include <list>
void clear ();
La función Clear () elimina todos los elementos en la lista. clear () se ejecuta en tiempo
lineal.

vacío
Sintaxis:
# include <list>
bool empty () const;
El vacío () devuelve true si la lista no tiene elementos, false en caso contrario. Por
ejemplo, el código siguiente se utiliza vacío () como la condición de parada en un
bucle, mientras quepara borrar una lista y mostrar su contenido en orden inverso:
lista <int> v; for (int i = 0; i <5; i + +) (v. push_back (i);) while (! v. vacío ())
(tribunal <<Volver v. () << endl; v. pop_back ();)

final
Sintaxis:
# include <list>
iterator end ();
const_iterator end () const;
El final () devuelve un iterador justo después del final de la lista.
Tenga en cuenta que antes de poder acceder al último elemento de la lista con un
iterador que usted obtiene de un llamado a terminar con (), que tendrá que disminuir el
repetidor primero.
Por ejemplo, el código siguiente se utiliza begin () y final () para recorrer todos los
miembros de una lista:
lista <int> v1 (5, 789);
lista <int>:: iterator it;
for (it = v1. begin (); it! = v1. end (); + + que) (
<tribunal <* it <<endl;
)
El repetidor se inicia con una llamada para comenzar (). Después de que el cuerpo del
bucle se ha ejecutado, se incrementa el iterador y probado para ver si es igual al
resultado de la llamada final (). Desde finales () devuelve un iterador que apunta a un
elemento justo después del último elemento del vector, el ciclo sólo se detendrá una
vez que todos los elementos del vector se han exhibido.
end () se ejecuta en tiempo constante.

borrar
Sintaxis:
# include <list>
iterator erase (loc iterador);
iterator erase (iterator inicio, iterator final);
El método de borrado o bien elimina el elemento en loc ubicación o elimina los
elementos entre el start y end (incluyendo start pero no como end El valor de retorno
es el elemento después de que el último elemento borrado.
La primera versión de borrar (la versión que elimina un elemento único en la
ubicación loc se ejecuta en tiempo constante. La versión de múltiples elementos de
borrar siempre tomaun tiempo lineal.
Las listas tienen la importante propiedad de que la inserción y el empalme no invalidan
los iteradores a elementos de la lista, y que incluso la eliminación sólo invalida los
iteradores que apuntan a los elementos que se eliminan.
El orden de los iteradores se puede cambiar (es decir, <T> lista:: iterador podría tener
un predecesor o sucesor diferentes después de una operación de la lista que antes),
pero los iteradores mismos no serán invalidadas o puesto a punto a diferentes
elementos a menos que la anulación o la mutación es explícita.
Por ejemplo:
/ / Crear una lista, cargar con los diez primeros caracteres del alfabeto
<char lista> alphaList;
for (int i = 0; i <10; i + +) (
alphaList. push_back (I + 65);
)
int size = alphaList. size ();
lista <char>:: startIterator repetidor;
lista <char>:: tempIterator repetidor;
for (int i = 0; i <size; i + +) (
startIterator = alphaList. begin ();
alphaList. erase (startIterator);
/ / Mostrar la lista de
copia (alphaList. begin (),. alphaList final (), <ostream_iterator char>
(tribunal));
<tribunal <endl;
)
Ese código se mostrará el resultado siguiente:
 BCDEFGHIJ
CDEFGHIJ
DEFGHIJ
Efghij
FGHIJ
GHIJ
HIJ
IJ
J
En el siguiente ejemplo, borrar () se llama con dos iteradores para eliminar una serie
de elementos de una lista:
/ / Crear una lista, cargar con los diez primeros caracteres del alfabeto
<char lista> alphaList;
for (int i = 0; i <10; i + +) (
alphaList. push_back (I + 65);
)
/ / Mostrar la lista completa
copia (alphaList. begin (),. alphaList final (), <ostream_iterator char> (tribunal));
<tribunal <endl;

/ / Uso de borrar para eliminar todos menos los dos primeros y tres últimos
elementos
/ / De la lista de
alphaList. borrar (anticipo (alphaList. begin (), 2), (anticipo alphaList. final (), -
3));
/ / Mostrar la lista modificada
copia (alphaList. begin (),. alphaList final (), <ostream_iterator char> (tribunal));
<tribunal <endl;
Cuando se ejecuta, se muestra el código de arriba:
ABCDEFGHIJ
ABHIJ

frente
Sintaxis:
# include <list>
TIPO & front ();
TIPO const & front () const;
La parte delantera () devuelve una referencia al primer elemento de la lista, y se
ejecuta en tiempo constante.

insertar
Sintaxis:
# include <list>
insertar iterador (loc iterador, const TIPO & val);
void insert (loc iterador, num size_type, const TIPO & val);
template <Tipo> void insert (loc iterador, inicie input_iterator, final
input_iterator);
El inserto () funciona bien:
 val inserta antes de loc, devuelve un iterador al elemento insertado,
 num inserta copias de val antes de loc, o
  introduce los elementos de principio a fin antes de loc.
Por ejemplo:
/ / Crear una lista, lo carga con los primeros 10 caracteres del alfabeto
<char lista> alphaList;
for (int i = 0; i <10; i + +) (
alphaList. push_back (I + 65);
)

/ / Inserte cuatro C's en la lista

lista <char>:: theIterator iterador = alphaList. begin ();
alphaList. insert (theIterator, 4, 'C');

/ / Mostrar la lista de
for (theIterator = alphaList. begin (); theIterator! = alphaList. end ();
TheIterator + +) (
<tribunal <* theIterator;
)
Este código se muestra:
CCCCABCDEFGHIJ

max_size
Sintaxis:
# include <list>
max_size size_type () const;
El max_size () devuelve el número máximo de elementos que la lista puede
contener. El max_size () no debe confundirse con la función de tamaño, que devuelven
el número de elementos que están actualmente en la lista.

fusionar
Sintaxis:
# include <list>
void mezcla (la lista y otros);
void mezcla (la lista y otros, compfunction BinPred);
La función de combinación de correspondencia () combina todos los elementos
de other en *this lo vacía other La lista resultante se ordena en relación con el
operador <. Si no se especifica compfunction, entonces se utiliza como la función de
comparación de las listas en lugar de <.
merge () se ejecuta en tiempo lineal.

pop_back
Sintaxis:
# include <list>
pop_back void ();
La pop_back () La función elimina el último elemento de la lista.
pop_back () se ejecuta en tiempo constante.

pop_front
Sintaxis:
 # include <list>
pop_front void ();
La pop_front function () elimina el primer elemento de la lista.
El pop_front () la función se ejecuta en tiempo constante.

rbegin
Sintaxis:
# include <list>
reverse_iterator rbegin ();
const_reverse_iterator rbegin () const;
La rbegin () devuelve un reverse_iterator hasta el final de la lista actual (la posición del
último elemento).
rbegin () se ejecuta en tiempo constante.

Eliminar

Sintaxis:
# include <list>
void remove (const TIPO & val);
La función remove () elimina todos los elementos que son iguales a val de la lista. Por
ejemplo, el siguiente código crea una lista de los primeros 10 caracteres del alfabeto, a
continuación, utiliza remove () para eliminar la letra «E» de la lista :
/ / Crear una lista que tiene las primeras 10 letras del alfabeto lista <> char
charlist; for (int i = 0; i <10; i + +) charlist. Push_front (I + 65) / / Eliminar todas las
instancias de 'charlist E'. remove ( 'E');
Eliminar ejecuta en tiempo lineal.

remove_if
Sintaxis:
# include <list>
void remove_if (PR UnPred);
La remove_if () La función elimina todos los elementos de la lista para que el pr
predicado unario es cierto.
remove_if () se ejecuta en tiempo lineal.

rend
Sintaxis:
# include <list>
reverse_iterator rend ();
const_reverse_iterator rend () const;
El rend function () devuelve un reverse_iterator a un elemento justo antes del primer
elemento de la lista actual.
rend () se ejecuta en tiempo constante.

cambiar el tamaño de
Sintaxis:
 # include <list>
void cambiar el tamaño (tamaño size_type, TIPO val = TIPO ());
Los cambios de método de cambiar el tamaño el tamaño de la lista para size Si val se
especifica a continuación, los elementos recién creado será inicializado a tener un
valor de val
Esta función se ejecuta en tiempo lineal.

inversa
Sintaxis:
# include <list>
void reverse ();
El reverso de la función () invierte la lista, y toma tiempo lineal.

tamaño
Sintaxis:
# include <list>
size_type size () const;
El tamaño () devuelve el número de elementos en la lista actual.

tipo
Sintaxis:
# include <list>
void ordenar ();
void (tipo P BinPred);
La función sort () se utiliza para ordenar las listas en orden ascendente. Pedido se
realiza mediante el operador <, a menos que p se ha especificado, en cuyo caso se
utiliza para determinar si un elemento es menor que otro.
Clasificación N toma el tiempo de registro N.
Temas relacionados: invertir
Código de ejemplo simple: # include # include <iostream> <list> using namespace
std; / / Asume Tipo T; cout <<t; es válido. Plantilla <tipo de clase> inline ostream &
operator <<(ostream & theOstream, la lista de const <TIPO> & theList) (list class
<Tipo>:: = ListIterator const_iterator theList. begin (); for (int i = 0; ListIterator! =
theList. end (); ListIterator + +, i + +) theOstream << "[" <<i << "]: \" "<<(* ListIterator)
<<" \ "" <<endl; theOstream return;) (struct funtor bool operator () (const char * const
char a, * b) (return strcmp (a, b) <0;)) int main () (list <char *> l / * Cargue algunos
datos de ejemplo de la prueba ... * / Char s [3], s [2] = '\ 0'; for (s [0] = 'c', s [0]> = 'a',
s [0] -) para la (s [ 1] = 'c', s [1]> = 'a', s [1] -) L. push_back (strdup (s)); / * Mostrar los
datos de prueba de que nosotros ... * / Tribunal <<<l <endl; / * Ordenar la lista. * /
Funtor f; L. tipo (f); / * Mostrar nosotros lo que tenemos ahora ... * / Tribunal <<<l
<endl;)

empalme
Sintaxis:
# include <list>
empalme void (POS iterador, la lista y LST);
empalme void (POS iterador, la lista y LST, del iterador);
empalme void (POS iterador, la lista y LST, inicie iterator iterator end);
La función de empalme se mueve uno o más elementos de
derecho lst antes pos ubicación. La sobrecarga se mueve primero todos los elementos
a lst el segundo sólo se mueve el tema en del y el tercio se mueve todos los artículos
incluidos en el rango de start y exclusiva de end
de empalme se mueve simplemente elementos de una lista a otra, y realmente no
hace ninguna copia o eliminación. Debido a esto, se ejecuta en el empalme de tiempo
constante,excepto por la sobrecarga de terceros que no necesita más que el tiempo
lineal en el caso de que lst no es la misma que this Sin embargo, si es de
tamaño complejidad lineal de tiempo después de empalme es constante para los tres.

swap
Sintaxis:
# include <list>
void intercambio (la lista y desde);
El intercambio () intercambios función de los elementos de la lista actual con los de
de. Esta función opera en tiempo constante.
Por ejemplo, el código siguiente se utiliza el swap () para intercambiar los valores de
dos listas:
lista <string> L1;
l1. push_back ( "Estoy en L1!");

lista <string> L2;

L2. push_back ( "Y yo estoy en L2");

l1. swap (L2);

tribunal << "El primer elemento de L1 es" <<l1. frontal () <<endl;

tribunal << "El primer elemento de L2 es" <<L2. frontal () <<endl;
Aparece el código de arriba:
El primer elemento de L1 es y estoy en L2!
El primer elemento de L2 es que estoy en L1!

único
Sintaxis:
# include <list>
void () exclusiva;
void única (pr BinPred);
La función única () elimina todos los elementos consecutivos duplicados de la lista.
Tenga en cuenta que sólo se eliminan duplicados consecutivos, lo que puede requerir
que sort () de la primera lista.
La igualdad es probada usando el operador ==, a menos que pr se especifica como un
reemplazo. El orden de los elementos en una lista no debe cambiar después de una
llamada a la única ().
() exclusiva se ejecuta en tiempo lineal.

stack

El C + + es un adaptador de pila de contenedores que proporciona al programador de

la funcionalidad de una pila - específicamente, un FILO (primero en entrar, último out)
la estructura de datos.
Constructores construcción de una nueva pila
vacío true si la pila no tiene elementos
pop elimina el elemento superior de una pila de
empujar añade un elemento a la parte superior de la pila
tamaño devuelve el número de elementos de la pila de
superior devuelve una referencia al elemento superior de la pila de

Constructores de la pila
Sintaxis:
# include <stack>
pila ();
pila explícita (const Container & con);
Las pilas tienen un constructor vacío y un constructor que se puede utilizar para
especificar un tipo de contenedor.

vacío
Sintaxis:
# include <stack>
bool empty () const;
El vacío () devuelve true si la pila no tiene elementos, false en caso contrario.
Por ejemplo, el código siguiente se utiliza vacío () como la condición de parada en un
bucle while para eliminar un montón y mostrar su contenido en orden inverso:
Pila <int> s;
for (int i = 0; i <5; i + +) (
s. push (i);
)
while (! s. vacío ()) (
<tribunal <s. superior () <<endl;
s. pop ();
)

pop
Sintaxis:
# include <stack>
pop void ();
El pop function () elimina el elemento superior de la pila y lo elimina.

empujar
Sintaxis:
# include <stack>
void push (const TIPO & val);
El impulso de la función () agrega val a la parte superior de la pila actual.
Por ejemplo, el código siguiente se utiliza el push () para sumar diez números enteros
a la parte superior de una pila:
Pila <int> s;
for (int i = 0; i <10; i + +) s. push (i);
 tamaño
Sintaxis:
# include <stack>
size_type size () const;
El tamaño () devuelve el número de elementos en la pila actual.

superior
Sintaxis:
# include <stack>
TIPO Y arriba ();
TIPO const & top () const;
La parte superior function () devuelve una referencia al elemento superior de la pila.
Por ejemplo, el código siguiente elimina todos los elementos de una pila y los usos
arriba () para mostrarlas:
while (! s. vacío ()) (
tribunal <<s. superior () << "";
s. pop ();
)

Iteradores

Nota: el diseño de la STL permite que cualquier función genérica que acepte un
iterador funcione igualmente bien aceptando un puntero ordinario.

Nota: los iteradores no solo sirven para señalar elementos dentro de los contenedores
de la STL, también se utilizan para señalar elementos dentro de otras estructuras:
flujos ("Streams") y bufers de flujo ("Buffers streams") [4]. Además se han definido de
modo que cuando los elementos de matriz están definidos mediante subíndices son
también iteradores. La consecuencia es que ciertos algoritmos pueden aplicarse
también sobre las matrices (recuerde las matrices son un tipo de estructura de datos, y
que el operador elemento de matriz [] se define como la indirección de un puntero
4.9.16).

La cosa funciona más o menos según el siguiente esquema (observe su paralelismo

con los punteros):

vector<int> cInt; // contenedor tipo vector para enteros

... // introducimos algunos enteros en cInt

std::vector<int>::iterator iT1; // iterador-a-vector-de-int

...
iT1 = cInt.begin(); // iT1 señala al primer miembro de cInt

...

std::cout << *iT1; // muestra el primer miembro de cInt

...

++iT1; // desplaza iT1 al segundo miembro

std::cout << *iT1; // muestra el segundo miembro de cInt

La clase iterator

La sentencia anterior, donde se declara un iterador iT1 de la clase vector<int> es

fundamental para entender la naturaleza de los iteradores

std::vector<int>::iterator iT1;

En efecto: esta sentencia intancia un objeto iT1 de la clase iterator que pertenece al
espacio de una instanciación concreta, vector<int>, de una clase genérica vector<T>.
Esto significa que la clase iterator para vectores-de-int está definida en el ámbito de
la clase genérica vector<T>. Es decir, la definición de la clase vector es algo como:

template <class T, ...> vector {

public:

class iterator;

};

A su vez esta clase iterator debe dispone de su propia definición en algún punto de la
cabecera <vector>:

class vector<T>::iterator {

/* definición dependiente de la implementación */

};

Esta es la razón por la que coloquialmente se dice que un contenedor puede generar
un iterador adecuado. Como puede verse, existen tantas clases iterator como
contenedores distintos; todas ellas son distintas e independientes. Aunque comparten
el mismo nombre y están definidas en subespacio distintos de std (recuerde que las
clases constituyen ámbitos en sí mismas).
typedef implementation defined iterator;
typedef implementation defined const_iterator;
typedef implementation defined size_type;
typedef implementation defined difference_type;

typedef std::reverse_iterator<iterator> reverse_iterator;

typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

Características

Existen diversas características principales que distinguen unos iteradores de otros.

Podemos resumirlas como sigue:

 Capacidad de modificar los datos subyacentes. En este sentido pueden ser de

solo lectura; solo escritura, o lectura/escritura.
 Tipo de desplazamiento que puede realizarse con ellos para recorrer el
contenedor. Puede ser de avance secuencial; avance y retroceso secuencial, o
acceso aleatorio.
 Otras características adicionales. Por ejemplo, la posibilidad de ser utilizados
por algoritmos que permiten insertar o borrar elementos del contenedor
asociado.

La tabla siguiente muestra los modos en que son generadas las diversas categorías
de iteradores por los contenedores STL.

Categoría Generado por

Iterador de
istream_iterator
entrada

Iterador de ostream_iterator
salida insert_iterator
front_insert_iterator
back_insert_iterator
Iterador list
bidireccional set y multiset
map y multimap