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.

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

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.

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.

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.

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

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;}

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>#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^

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 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'; } } 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;}

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; 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.

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() {char cadena[3128];char linea[50][3000];string texto;string lineacadena;int a=0;int b=0;// Crea un fichero de salidacout <<"-------------------------------------\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 entradaifstream 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 cadenatexto +=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];cout << "\n";}cout <<"----------------------------------------\n";cout <<"imprimo una cadena\n";cout <<"----------------------------------------\n";cout << texto;//system ("PAUSE");//EXIT_SUCCESS;return 0;}