Aplicaciones del Circuito TTL

aplicaciones del Circuito TTL

1. Aplicaciones
 Microprocesadores, como el 8X300, de Signetics, la familia 2900 de AMD y otros.
 Memorias RAM
 Memorias PROM
 PAL, Programmable Array Logic, consistente en una PROM que interconecta las entradas y cierto
número de puertas lógicas.
Implementación
Fundamental compuerta TTL
Entradas TTL son los emisores de un transistor de emisor múltiple. Esta estructura IC es
funcionalmente equivalente a múltiples transistores en las bases y los coleccionistas están
vinculados entre sí. La salida está amortiguada por un amplificador de emisor común.
Entradas tanto los lógicos. Cuando todas las entradas se llevan a cabo en alta tensión, las
uniones base-emisor del transistor de emisor múltiple son en polarización inversa. A diferencia
de DTL, una pequeña corriente "colector" es dibujado por cada una de las entradas. Esto es
debido a que el transistor está en modo inverso-activo. Un aproximadamente constante la
corriente fluye desde el carril positivo, a través de la resistencia y en la base del transistor de
emisor múltiple. Esta corriente pasa a través de la unión base-emisor del transistor de salida,
lo que le permite llevar a cabo y tirando de la baja tensión de salida.
Un cero lógico de entrada. Tenga en cuenta que la unión base-colector del transistor de
emisor múltiple y la unión base-emisor del transistor de salida están en serie entre la parte
inferior de la resistencia y tierra. Si una tensión de entrada se convierte en cero, la
correspondiente unión base-emisor del transistor de emisor múltiple es en paralelo con estos
dos uniones. Un fenómeno llamado actual de la dirección significa que cuando dos elementos
de tensión-estables con diferentes voltajes de umbral están conectados en paralelo, la
corriente fluye a través de la ruta de acceso con la tensión de umbral más pequeño. Como
resultado de ello, no fluye corriente a través de la base del transistor de salida, haciendo que
se detenga la realización y la tensión de salida se convierte en alta. Durante la transición del
transistor de entrada es brevemente en su región activa, por lo que atrae a una gran cantidad
de corriente lejos de la base del transistor de salida y se descarga por lo tanto, directamente a
su base. Esta es una ventaja crítica de TTL sobre DTL que acelera la transición sobre una
estructura de entrada de diodos.
La principal desventaja de TTL con una etapa de salida simple es la relativamente alta
resistencia de salida en la salida lógica "1" que está completamente determinada por la
resistencia del colector de salida. Limita el número de entradas que se pueden conectar.

2. Algunos ventaja de la etapa de salida simple es el nivel de alta tensión de la salida lógica "1"
cuando no se ha cargado la salida.
La lógica de este tipo se encuentra con más frecuencia con la resistencia de colector del
transistor de salida se omite, toma de una salida de colector abierto. Esto permite al diseñador
de fabricar la lógica mediante la conexión de las salidas de colector abierto de varias puertas
lógicas, y brindar una resistencia pull-up externa. Si alguna de las puertas de la lógica se
vuelve lógico bajo, la salida combinada será baja. Ejemplos de este tipo de puerta son el 7401
y 7403 series.
TTL con una etapa de salida "tótem"
Para resolver el problema con la alta resistencia de salida de la etapa de salida sencilla la
segunda esquemática añade a esto una salida "tótem". Se compone de los dos transistores
npn V3 y V4, el "trabajo" diodo V5 y la resistencia de limitación de corriente R3. Es impulsado
por la aplicación de la misma idea actual de la dirección que el anterior.
Cuando V2 es "off", V4 es "off", así y V3 opera en la región activa como un seguidor de
tensión produce alta tensión de salida. Cuando V2 es "on", se activa V4, la conducción bajo
voltaje a la salida. Uniones colector-emisor V2 y V4 V4 conectan unión base-emisor en
paralelo a la serie V3-conectado base-emisor y V5 uniones ánodo-cátodo. Corriente de base
V3 es privado, el transistor se pone en "off" y no tiene impacto en el resultado. En el medio de
la transición, la resistencia R3 limita la corriente que fluye directamente a través de la serie V3
conectado transistor, diodo y el transistor V4 V5 que están llevando a cabo todo. También
limita la salida de corriente en el caso de salida de conexión lógica "1" y corta al suelo. La
fuerza de la puerta se puede incrementar sin afectar proporcionalmente el consumo de
energía mediante la eliminación de la pull-up y pull-down resistencias de la etapa de salida.
La principal ventaja de la TTL con una etapa de salida "tótem" es la baja resistencia de salida
en salida lógica "1". Está determinada por la parte superior del transistor de salida V3 de
funcionamiento en la región activa como un seguidor de tensión. La resistencia R3 no
aumenta la resistencia de salida, ya que está conectada en el colector V3 y su influencia se
compensa por la retroalimentación negativa. Una desventaja de la etapa de salida "tótem" es
la disminución del nivel de tensión de la salida lógica "1". La razón de esta reducción son las
caídas de voltaje en la base-emisor V3 y V5 uniones ánodo-cátodo.
Consideraciones Interfacing
Como DTL, TTL es una lógica de sumidero de corriente ya una corriente deben extraerse de
las entradas para llevarlos a un nivel de 0 lógico. En bajo voltaje de entrada, la entrada de

3. corriente fuentes TTL que debe ser absorbida por la etapa anterior. El valor máximo de esta
corriente es aproximadamente 1,6 mA para una compuerta TTL estándar. La fuente de
entrada tiene que ser de baja resistencia suficiente para que la corriente que fluye crea sólo
una caída de tensión insignificante a través de ella, para la entrada para ser considerado como
un "0" lógico. Entradas TTL a veces se dejan simplemente flotando para proporcionar un "1"
lógico, aunque no se recomienda este uso.
Circuitos TTL estándar funcionan con una fuente de alimentación de 5 voltios. Una señal de
entrada TTL se define como "bajo" cuando entre 0 V y 0,8 V con respecto al terminal de tierra,
y "alta" cuando entre 2,2 V y 5 V. salidas TTL son típicamente restringido a los límites más
estrechos de entre 0 V y 0,4 V para una "baja" y entre 2,6 V y 5 V para un "alto",
proporcionando 0,4 V de inmunidad al ruido. Normalización de los niveles TTL era tan
omnipresente que las placas de circuitos complejos a menudo contenían chips TTL hechas
por muchos fabricantes diferentes seleccionados disponibilidad y coste, la compatibilidad está
asegurada, dos unidades de placa de circuito fuera de la misma línea de montaje en diferentes
días o semanas sucesivas pueden tener un diferente mezcla de las marcas de fichas en las
mismas posiciones en el tablero, de la reparación era posible con chips fabricados años más
tarde que los componentes originales. Dentro de los límites útil amplios, puertas lógicas
podían ser tratadas como dispositivos booleanas ideales sin preocuparse por las limitaciones
eléctricas.
En algunos casos, el nivel de tensión de la etapa de salida "tótem" en la salida lógica "1" se
puede aumentar hasta a VCC mediante la conexión de una resistencia externa entre el
colector V3 y el carril positivo. Se detiene en el cátodo V5 y los recortes-off del diodo. Sin
embargo, esta técnica se convierte en realidad el sofisticado salida "tótem" en una etapa de
salida sencilla que tiene una resistencia de salida importante cuando se conduce un alto nivel.
Embalaje
Al igual que la mayoría de los circuitos integrados del período 1965-1990, los dispositivos TTL
suelen ser envasados en orificio pasante, paquetes duales en línea con entre 14 y 24 hilos
conductores, por lo general de plástico o epoxi veces de cerámica. Beam-dados de chips sin
plomo paquetes se hicieron para el montaje en matrices más grandes como los circuitos
integrados híbridos. Piezas para aplicaciones militares y aeroespaciales fueron empaquetados
en paquetes planos, una forma de paquete de montaje en superficie, con conduce adecuado
para la soldadura o soldadura para placas de circuito impreso. Hoy en día, muchos
dispositivos compatibles con TTL están disponibles en paquetes de montaje en superficie, que
están disponibles en una gama más amplia de tipos de paquetes a través del agujero.

4. TTL se adapta particularmente bien a los circuitos integrados bipolares porque entradas
adicionales a una puerta sólo se pide emisores adicionales en una región de base compartido
del transistor de entrada. Si se utilizan transistores empaquetados individualmente, el coste de
todos los transistores desanimaría a uno del uso de una estructura de este tipo de entrada.
Pero en un circuito integrado, los emisores adicionales para entradas de la puerta adicionales
añaden sólo un área pequeña.
Comparación con otras familias lógicas
Dispositivos TTL consumen mucho más energía que los dispositivos CMOS equivalente en
reposo, pero el consumo de energía no aumenta con la velocidad de reloj mayor rapidez para
dispositivos CMOS. En comparación con los circuitos ECL contemporáneos, TTL utiliza menos
energía y tiene reglas de diseño más fácil, pero es sustancialmente más lenta. Los
diseñadores pueden combinar dispositivos TTL ECL y en el mismo sistema para lograr el
mejor rendimiento global y la economía, pero se requiere que los dispositivos de
desplazamiento de nivel entre las dos familias lógicas. TTL es menos sensible a los daños
causados por la descarga electrostática que los dispositivos de primeros CMOS.
Debido a la estructura de salida de los dispositivos TTL, la impedancia de salida es asimétrico
entre el estado alto y bajo, que los hace inadecuados para la conducción de líneas de
transmisión. Este inconveniente se suele superar al amortiguar las salidas con dispositivos de
controlador de línea especiales donde deben enviarse a través de cables de señales. ECL, en
virtud de su estructura de salida de baja impedancia simétrica, no tiene este inconveniente.
La estructura de salida TTL "tótem" a menudo tiene un solapamiento momentáneos cuando
tanto los transistores superior e inferior están llevando a cabo, lo que resulta en un impulso
sustancial de corriente extraída de la fuente de alimentación. Estos pulsos se puede acoplar
de manera inesperada entre varios paquetes de circuitos integrados, lo que resulta en una
reducción de margen de ruido y menor rendimiento. Sistemas TTL por lo general tienen un
condensador de desacoplamiento para cada uno o dos paquetes de circuitos integrados, de
modo que un impulso de corriente de un chip TTL no reduce momentáneamente la tensión de
alimentación a otra.
Varios fabricantes ya suministran CMOS equivalentes lógicos con los niveles de entrada
compatible con TTL y la salida, generalmente teniendo referencias similares al componente
TTL equivalente y con la misma asignación de señales. Por ejemplo, la serie 74HCT00 ofrece
muchos reemplazos directos para piezas bipolares serie 7400, pero utiliza la tecnología
CMOS.

5. Sub-tipos
Las sucesivas generaciones de la tecnología producen piezas compatibles con la mejora de
consumo de energía o velocidad de conmutación, o ambos. Aunque los vendedores
uniformemente comercializan estas diversas líneas de productos como TTL con diodos
Schottky, algunos de los circuitos subyacentes, tales como las usadas en la familia LS, en
lugar podría considerarse DTL.
Las variaciones de y sucesores a la familia TTL básica, que tiene un retardo de propagación
típica puerta de 10 ns y una disipación de potencia de 10 mW por puerta, para un producto de
alimentación de retardo o de la energía de conmutación de aproximadamente 100 PJ,
incluyen:
 Baja potencia TTL, que cambió la velocidad de conmutación para una reducción en el
consumo de energía
 De alta velocidad TTL, con cambio rápido que el estándar TTL, pero significativamente
mayor disipación de potencia
 Schottky TTL, introducido en 1969, que utiliza diodos Schottky abrazaderas en
entradas de la puerta para evitar el almacenamiento de carga y mejorar el tiempo de
conmutación. Estas puertas operado más rápidamente, pero tuvieron mayor disipación
de potencia
 Baja potencia Schottky TTL - utilizado los valores de resistencia más altas de baja
potencia TTL y los diodos de Schottky para proporcionar una buena combinación de
velocidad y menor consumo de energía, y PDP de 20 PJ. Probablemente el tipo más
común de TTL, éstos se utilizaron como lógica de cola en microordenadores, en
sustitución de esencialmente la antigua H, L, y S sub-familias.
 Variantes Rápido y Avanzado-Schottky de LS de Fairchild y TI, respectivamente,
alrededor de 1985, con circuitos de "Miller-killer" para acelerar la transición baja a alta.
Estas familias lograron PDP de 10 PJ y 4 PJ, respectivamente, el más bajo de todas
las familias TTL.
 TTL de baja tensión para fuentes de alimentación de 3,3 voltios, interfaces de memoria.
La mayoría de los fabricantes ofrecen gamas de temperaturas comerciales e extendido: por
ejemplo, piezas de la serie de Texas Instruments 7400 se han valorado de 0 a 70 º C, y los
dispositivos de la serie 5400 en el rango de temperatura militar especificación de -55 a 125 C.
Niveles especiales de calidad y piezas de alta fiabilidad están disponibles para aplicaciones
militares y aeroespaciales.

6. Dispositivos endurecidas a las radiaciones se ofrecen para aplicaciones espaciales.
Aplicaciones
Antes de la llegada de los dispositivos VLSI, circuitos integrados TTL eran un método estándar
de construcción para los procesadores de los procesadores de mini-ordenador y la unidad
central, tales como el DEC VAX y Data General Eclipse, y por equipos, tales como controles
de máquina herramienta numéricos, impresoras y video mostrar terminales. Como
microprocesadores hicieron más funcional, los dispositivos TTL se volvieron importantes para
aplicaciones de "pegamento" de lógica, como los conductores de autobuses rápidos en una
placa base, que unen a los bloques de funciones realizadas en elementos VLSI.
Aplicaciones analógicas
Aunque originalmente diseñado para manejar señales digitales de nivel lógico, un inversor TTL
puede estar sesgada como un amplificador analógico. Conexión de una resistencia entre la
salida y los sesgos de entrada del elemento TTL como amplificador de retroalimentación
negativa. Estos amplificadores pueden ser útiles para convertir las señales analógicas al
dominio digital, pero no se utiliza normalmente donde la amplificación analógica es el
propósito principal. Inversores TTL también pueden ser utilizados en los osciladores de cristal
en los que su capacidad de amplificación analógica es significativa.

 Corrección de errores, ¿Cómo funciona?, Un promedio de ruido para reducir los
errores, Tipos de FEC, Códigos FEC concatenados para mejorar el rendimiento, Baja
densidad de comprobación de paridad, Códigos de Turbo, Decodificación y pruebas de
los códigos locales, Intercalado, Lista de códigos correctores de errores
 Batalla de Sagrajas, Preparativos, Batalla, Secuelas
 Hidruro de uranio, Propiedades, Formación de uranio metálico, Otras reacciones
químicas, Historia, Aplicaciones
 Jerome Isaac Friedman, Vida y carrera, Publicaciones
 Heinrich Otto Wieland, Familia, Premio Heinrich Wieland
 McDonnell Douglas F/A-18 Hornet, Desarrollo, Diseño, Historia operacional, Variantes,
Operadores, Aviones en exhibición, Accidentes, Especificaciones, Apariciones notables
en los medios de comunicación
 Yevgeny Pepelyaev, Inicios de su carrera y la Segunda Guerra Mundial, Corea

7.  Imagen de alto rango dinámico, Fotografía, Escaneo de película, En representación de
imágenes HDR a LDR pantallas, Comparación con imágenes digitales tradicionales,
Historia de la fotografía HDR, Vídeo, Ejemplos, Galería
 Sulfuro de cadmio, Producción, Reacciones, Estructura y propiedades físicas,
Aplicaciones, Biológico
 Roundhay Garden Scene, Imágenes Remastered
 Philip Showalter Hench, Primeros años y educación, Carrera médica, Familia
 La Facultad, Parcela, Emitir, Producción, Recepción, Banda sonora, Locaciones de
Filmación, Lanzamiento en DVD, Blu-ray
 Filtro de densidad neutra, Mecanismo, Utiliza, Variedades, Tipos de filtros ND
 Los sellos y la historia postal de Heligoland, Enteros postales
 Motor Retroceso,

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

int main() {
char cadena[128];
// Crea un fichero de salida
ofstream fs("nombre.txt");

// Enviamos una cadena al fichero de salida:
fs << "Hola, mundo" << endl;
// Cerrar el fichero,
// para luego poder abrirlo para lectura:
fs.close();

// Abre un fichero de entrada
ifstream fe("nombre.txt");

// Leeremos mediante getline, si lo hiciéramos
// mediante el operador << sólo leeríamos
// parte de la cadena:
fe.getline(cadena, 128);

cout << cadena << endl;

return 0;
}

8. Este sencillo ejemplo crea un fichero de texto y después visualiza su contenido en
pantalla.
Veamos otro ejemplo sencillo, para ilustrar algunas limitaciones del operador >> para
hacer lecturas, cuando no queremos perder caracteres.
Supongamos que llamamos a este programa "streams.cpp", y que pretendemos que se
autoimprima en pantalla:
#include <iostream>
#include <fstream>
using namespace std;

int main() {
char cadena[128];
ifstream fe("streams.cpp");

while(!fe.eof()) {
fe >> cadena;
cout << cadena << endl;
}
fe.close();

return 0;
}

Muchos sistemas operativos distinguen entre ficheros de texto y ficheros binarios. Por
ejemplo, en MS-DOS, los ficheros de texto sólo permiten almacenar caracteres.
En otros sistemas no existe tal distinción, todos los ficheros son binarios. En esencia
esto es más correcto, puesto que un fichero de texto es un fichero binario con un rango
limitado para los valores que puede almacenar.
En general, usaremos ficheros de texto para almacenar información que pueda o deba
ser manipulada con un editor de texto. Un ejemplo es un fichero fuente C++. Los
ficheros binarios son más útiles para guardar información cuyos valores no estén
limitados. Por ejemplo, para almacenar imágenes, o bases de datos. Un fichero binario
permite almacenar estructuras completas, en las que se mezclen datos de cadenas con
datos numéricos.
En realidad no hay nada que nos impida almacenar cualquier valor en un fichero de
texto, el problema surge cuando se almacena el valor que el sistema operativo usa para
marcar el fin de fichero en un archivo de texto. En MS-DOS ese valor es 0x1A. Si
abrimos un fichero en modo de texto que contenga un dato con ese valor, no nos será
posible leer ningún dato a partir de esa posición. Si lo abrimos en modo binario, ese
problema no existirá.
Los ficheros que hemos usado en los ejemplos anteriores son en modo texto, veremos
ahora un ejemplo en modo binario:
#include <iostream>
#include <fstream>

9. #include <cstring>

using namespace std;

struct tipoRegistro {
char nombre[32];
int edad;
float altura;
};

int main() {
tipoRegistro pepe;
tipoRegistro pepe2;
ofstream fsalida("prueba.dat",
ios::out | ios::binary);

strcpy(pepe.nombre, "Jose Luis");
pepe.edad = 32;
pepe.altura = 1.78;

fsalida.write(reinterpret_cast<char *>(&pepe),
sizeof(tipoRegistro));
fsalida.close();

ifstream fentrada("prueba.dat",
ios::in | ios::binary);

fentrada.read(reinterpret_cast<char *>(&pepe2),
sizeof(tipoRegistro));
cout << pepe2.nombre << endl;
cout << pepe2.edad << endl;
cout << pepe2.altura << endl;
fentrada.close();

return 0;
}
Al declarar streams de las clases ofstream o ifstream y abrirlos en modo binario,
tenemos que añadir el valor ios::out e ios::in, respectivamente, al valor ios::binary.
Esto es necesario porque los valores por defecto para el modo son ios::out e ios:in,
también respectivamente, pero al añadir el flag ios::binary, el valor por defecto no se
tiene en cuenta.
Cuando trabajemos con streams binarios usaremos las funciones write y read. En este
caso nos permiten escribir y leer estructuras completas.
En general, cuando usemos estas funciones necesitaremos hacer un casting, es
recomendable usar el operador reinterpret_cast.

Ficheros de acceso aleatorio
^

10. Hasta ahora sólo hemos trabajado con los ficheros secuencialmente, es decir,
empezamos a leer o a escribir desde el principio, y avanzamos a medida que leemos o
escribimos en ellos.
Otra característica importante de los ficheros es la posibilidad de trabajar con ellos
haciendo acceso aleatorio, es decir, poder hacer lecturas o escrituras en cualquier
punto del fichero. Para eso disponemos de las funciones seekp y seekg, que permiten
cambiar la posición del fichero en la que se hará la siguiente escritura o lectura. La 'p'
es de put y la 'g' de get, es decir escritura y lectura, respectivamente.
Otro par de funciones relacionadas con el acceso aleatorio son tellp y tellg, que sirven
para saber en qué posición del fichero nos encontramos.
#include <fstream>
using namespace std;

int main() {
int i;
char mes[][20] = {"Enero", "Febrero", "Marzo",
"Abril", "Mayo", "Junio", "Julio", "Agosto",
"Septiembre", "Octubre", "Noviembre",
"Diciembre"};
char cad[20];

ofstream fsalida("meses.dat",
ios::out | ios::binary);

// Crear fichero con los nombres de los meses:
cout << "Crear archivo de nombres de meses:" << endl;
for(i = 0; i < 12; i++)
fsalida.write(mes[i], 20);
fsalida.close();

ifstream fentrada("meses.dat", ios::in | ios::binary);

// Acceso secuencial:
cout << "\nAcceso secuencial:" << endl;
fentrada.read(cad, 20);
do {
cout << cad << endl;
fentrada.read(cad, 20);
} while(!fentrada.eof());

fentrada.clear();
// Acceso aleatorio:
cout << "\nAcceso aleatorio:" << endl;
for(i = 11; i >= 0; i--) {
fentrada.seekg(20*i, ios::beg);
fentrada.read(cad, 20);
cout << cad << endl;
}

// Calcular el número de elementos
// almacenados en un fichero:
// ir al final del fichero

11. fentrada.seekg(0, ios::end);
// leer la posición actual
pos = fentrada.tellg();
// El número de registros es el tamaño en
// bytes dividido entre el tamaño del registro:
cout << "\nNúmero de registros: " << pos/20 << endl;
fentrada.close();

return 0;
}
La función seekg nos permite acceder a cualquier punto del fichero, no tiene por qué
ser exactamente al principio de un registro, la resolución de la funciones seek es de un
byte.
Cuando trabajemos con nuestros propios streams para nuestras clases, derivándolas
de ifstream, ofstream o fstream, es posible que nos convenga sobrecargar las
funciones seek y tell para que trabajen a nivel de registro, en lugar de hacerlo a nivel de
byte.
La función seekp nos permite sobrescribir o modificar registros en un fichero de acceso
aleatorio de salida. La función tellp es análoga a tellg, pero para ficheros de salida.

Ficheros de entrada y salida
^
Ahora veremos cómo podemos trabajar con un stream simultáneamente en entrada y
salida.
Para eso usaremos la clase fstream, que al ser derivada de ifstream y ofstream,
dispone de todas las funciones necesarias para realizar cualquier operación de entrada
o salida.
Hay que tener la precaución de usar la opción ios::trunc de modo que el fichero sea
creado si no existe previamente.
#include <fstream>
using namespace std;

int main() {
char l;
long i, lon;
fstream fich("prueba.dat", ios::in |
ios::out | ios::trunc | ios::binary);

fich << "abracadabra" << flush;

fich.seekg(0L, ios::end);
lon = fich.tellg();
for(i = 0L; i < lon; i++) {
fich.seekg(i, ios::beg);
fich.get(l);
if(l == 'a') {
fich.seekp(i, ios::beg);
fich << 'e';
}

12. }
cout << "Salida:" << endl;
fich.seekg(0L, ios::beg);
for(i = 0L; i < lon; i++) {
fich.get(l);
cout << l;
}
cout << endl;
fich.close();

return 0;
}
Este programa crea un fichero con una palabra, a continuación lee todo el fichero e
cambia todos los caracteres 'a' por 'e'. Finalmente muestra el resultado.
Básicamente muestra cómo trabajar con ficheros simultáneamente en entrada y salida.
Sobrecarga de operadores << y >>
^
Una de las principales ventajas de trabajar con streams es que nos permiten
sobrecargar los operadores << y >> para realizar salidas y entradas de nuestros
propios tipos de datos.
Por ejemplo, tenemos una clase:
#include <iostream>
#include <cstring>
using namespace std;

class Registro {
public:
Registro(char *, int, char *);
const char* LeeNombre() const {return nombre;}
int LeeEdad() const {return edad;}
const char* LeeTelefono() const {return telefono;}

private:
char nombre[64];
int edad;
char telefono[10];
};

Registro::Registro(char *n, int e, char *t) : edad(e) {
strcpy(nombre, n);
strcpy(telefono, t);
}

ostream& operator<<(ostream &os, Registro& reg) {
os << "Nombre: " << reg.LeeNombre() << " \nEdad: " <<
reg.LeeEdad() << "\nTelefono: " << reg.LeeTelefono();

return os;
}

13. int main() {
Registro Pepe((char*)"José", 32, (char*)"61545552");

cout << Pepe << endl;

return 0;
}

Comprobar estado de un stream
^
Hay varios flags de estado que podemos usar para comprobar el estado en que se
encuentra un stream.
Concretamente nos puede interesar si hemos alcanzado el fin de fichero, o si el stream
con el que estamos trabajando está en un estado de error.
La función principal para esto es good(), de la clase ios.
Después de ciertas operaciones con streams, a menudo no es mala idea comprobar el
estado en que ha quedado el stream. Hay que tener en cuenta que ciertos estados de
error impiden que se puedan seguir realizando operaciones de entrada y salida.
Otras funciones útiles son fail(), eof(), bad(), rdstate() o clear().
En el ejemplo de archivos de acceso aleatorio hemos usado clear() para eliminar el bit
de estado eofbit del fichero de entrada, si no hacemos eso, las siguientes operaciones
de lectura fallarían.
Otra condición que conviene verificar es la existencia de un fichero. En los ejemplos
anteriores no ha sido necesario, aunque hubiera sido conveniente, verificar la
existencia, ya que el propio ejemplo crea el fichero que después lee.
Cuando vayamos a leer un fichero que no podamos estar seguros de que existe, o que
aunque exista pueda estar abierto por otro programa, debemos asegurarnos de que
nuestro programa tiene acceso al stream. Por ejemplo:
#include <fstream>
using namespace std;

int main() {
char mes[20];
ifstream fich("meses1.dat", ios::in | ios::binary);

// El fichero meses1.dat no existe, este programa es
// una prueba de los bits de estado.

if(fich.good()) {
fich.read(mes, 20);
cout << mes << endl;
}
else {
cout << "Fichero no disponible" << endl;
if(fich.fail()) cout << "Bit fail activo" << endl;
if(fich.eof()) cout << "Bit eof activo" << endl;

14. if(fich.bad()) cout << "Bit bad activo" << endl;
}
fich.close();

return 0;
}
Ejemplo de fichero previamente abierto:
#include <fstream>
using namespace std;

int main() {
char mes[20];
ofstream fich1("meses.dat", ios::out | ios::binary);
ifstream fich("meses.dat", ios::in | ios ::binary);

// El fichero meses.dat existe, pero este programa
// intenta abrir dos streams al mismo fichero, uno en
// escritura y otro en lectura. Eso no es posible, se
// trata de una prueba de los bits de estado.

fich.read(mes, 20);
if(fich.good())
cout << mes << endl;
else {
cout << "Error al leer de Fichero" << endl;
if(fich.fail()) cout << "Bit fail activo" << endl;
if(fich.eof()) cout << "Bit eof activo" << endl;
if(fich.bad()) cout << "Bit bad activo" << endl;
}
fich.close();
fich1.close();

return 0;
}
Comentarios de los usuarios (18)

aJ
2011-03-21 19:31:45
Buenas,
En el ejemplo de Ficheros de acceso aleatorio me lanza error copilando con GNU GCC
Compliler y Visual C++ 2010, en la siguiente parte :
pos = fentrada.tellg();
Si alguien sabe la solución admin o cualquier otra persona estaré atento a los comentarios.

15. Saludos.

Steven
2011-03-21 22:48:14
Hola aJ,
Si el compilador te lanza un error, siempre ayuda escribir el mensaje, para los demás.
Hay dos errores y los mensajes lanzados son:
- 'cout' no fue declarado en este ámbito
- 'pos' no fue declarado en este ámbito
Para solucionar el problema de 'cout', incluimos <iostream> al principio:
#include <iostream>
Para 'pos', se nos ha olvidado definirla. Técnicamente, el tipo de dato correcto es 'streampos'.
Por lo tanto, escribimos lo siguiente:
streampos pos = fentrada.tellg();
En cuanto podamos, lo corregiremos. Espero haber aclarado la duda.
Steven

aJ
2011-03-22 01:17:45
Gracias otra ves Steven, ya aclare las dudas jejeje.
En esta parte se equivocaron con la tilde de la ú :
cout << "\nNúmero de registros: " << pos/20 << endl;
Aunque no entorpece la funcionalidad del programa, aquí incluyo mi corrección :
cout << "\nN\xa3mero de registros : " << pos/20 << endl;

#include <iostream>
#include <fstream>
#include <string.h>
using namespace std;
int main() {

16. char cadena[3128];
char linea[50][3000];
string texto;
string lineacadena;
int a=0;
int b=0;
// Crea un fichero de salida
cout <<"------------------------------------- \n";
cout <<"Escribiendo y leyendo un fichero\n";
cout <<"------------------------------------- \n";
ofstream fs("nombre.txt");
char* mensaje="hola esto es un mensaje \0";
char* mensaje2="hola 2\0";
char* mensaje3="un mensaje3\0";
cout << mensaje<<"\n";
cout <<mensaje2<<"\n";
cout <<mensaje3<<"\n";
// Enviamos una cadena al fichero de salida:
fs << mensaje << endl;
fs << mensaje2 << endl;
fs << mensaje3 << endl;
// Cerrar el fichero,
// para luego poder abrirlo para lectura:
fs.close();
// Abre un fichero de entrada
ifstream fe("nombre.txt");
// Leeremos mediante getline, si lo hiciéramos
// mediante el operador << sólo leeríamos
// parte de la cadena:
cout <<"-------------------------------- -----\n";
cout <<"\nContenido del fichero:\n";
cout <<"------------------------------------- \n";
a=-1;
while (!fe.eof()){
fe.getline(cadena,3000);
a++;
string lineacadena (cadena); // añadido: convierto array de char a cadena
texto +=lineacadena + '\n'; // añado a la cadena texto.
strcat(linea[a],cadena); //añadido trabajando con cadenas
cout << cadena << endl; // añadido: escribo.
}
cout <<"------------------------------------- \n";
cout <<"Contenido del fichero, en un array guardado \n";
cout <<"------------------------------------- \n";
for(b=0;b<=a;b++){
cout << linea[b];

17. cout << "\n";
}
cout <<"---------------------------------------- \n";
cout <<"imprimo una cadena \n";
cout <<"---------------------------------------- \n";
cout << texto;
//system ("PAUSE");
//EXIT_SUCCESS;
return 0;
}