Este documento proporciona una guía sobre conceptos básicos de programación en C/C++. Explica identificadores y tipos de datos comunes como char, int y float. También cubre operadores, arreglos unidimensionales y bidimensionales, estructuras, funciones, variables locales y globales, e instrucciones de control como if/else y bucles for y while. El objetivo es servir como manual de referencia para el curso de Laboratorio de Programación 1.
Este documento presenta una introducción al lenguaje de programación C. Explica que C es un lenguaje estructurado desarrollado en 1972 y que es ampliamente usado para programar sistemas. Incluye secciones sobre la estructura básica de los programas en C, variables, constantes, funciones, y ejemplos simples. El objetivo es proporcionar una guía para principiantes y avanzados sobre los conceptos fundamentales de la programación en C.
Este documento proporciona una introducción al lenguaje de programación C. Explica las características generales del lenguaje, el proceso de compilación, la estructura de los archivos fuente y de encabezado, el uso del preprocesador, los sistemas numéricos, los tipos de datos básicos como enteros y reales, la declaración de variables y constantes, y los modificadores como static y const.
Un algoritmo es un conjunto de pasos ordenados para resolver un problema. Debe ser finito, definible, aceptar datos de entrada y producir una salida. Existen algoritmos cualitativos y cuantitativos. Los algoritmos se pueden representar mediante narrativa, diagrama de flujo, diagrama N-S o pseudocódigo.
Este documento presenta un tutorial de C++ dividido en 23 capítulos. El tutorial utiliza ejemplos sencillos de código para explicar conceptos básicos como funciones, tipos de datos, clases, herencia, entre otros. Cada capítulo contiene uno o más fragmentos de código con comentarios que describen su funcionalidad. El objetivo del tutorial es servir como referencia rápida para aprender los fundamentos del lenguaje C++.
Este documento introduce los conceptos básicos de tipos de datos y variables en Java. Explica los tipos primitivos como enteros, flotantes y caracteres, así como la clase String. Describe cómo declarar y asignar valores a variables, incluyendo las reglas básicas y el ámbito de vida. También cubre la conversión de tipos, operadores aritméticos y relacionales, y cómo comparar cadenas String.
El documento describe los elementos básicos de un programa en C++. Un programa está definido por funciones, donde la función principal es main. La estructura general de un programa incluye directivas de preprocesamiento, declaraciones globales, la función main y funciones definidas por el usuario, así como comentarios. El documento también explica conceptos como tipos de datos, estatutos de lectura y escritura.
Este documento presenta un resumen de 3 conceptos clave de C++:
1) Define los tipos de datos fundamentales como enteros, flotantes, caracteres y booleanos, y explica el tipo void.
2) Explica el concepto de clase en programación orientada a objetos y provee un ejemplo de clase Punto con atributos y métodos.
3) Introduce los constructores como métodos especiales que se ejecutan al crear un objeto y pueden inicializar sus atributos.
El documento describe el lenguaje de programación C. C fue creado a mediados de los años 70 y es un lenguaje estructurado pero no por bloques. El lenguaje proporciona flexibilidad pero deja la responsabilidad de comprobaciones al programador. C consta de funciones, con la función main ejecutándose primero.
Este documento presenta una introducción al lenguaje de programación C. Explica que C es un lenguaje estructurado desarrollado en 1972 y que es ampliamente usado para programar sistemas. Incluye secciones sobre la estructura básica de los programas en C, variables, constantes, funciones, y ejemplos simples. El objetivo es proporcionar una guía para principiantes y avanzados sobre los conceptos fundamentales de la programación en C.
Este documento proporciona una introducción al lenguaje de programación C. Explica las características generales del lenguaje, el proceso de compilación, la estructura de los archivos fuente y de encabezado, el uso del preprocesador, los sistemas numéricos, los tipos de datos básicos como enteros y reales, la declaración de variables y constantes, y los modificadores como static y const.
Un algoritmo es un conjunto de pasos ordenados para resolver un problema. Debe ser finito, definible, aceptar datos de entrada y producir una salida. Existen algoritmos cualitativos y cuantitativos. Los algoritmos se pueden representar mediante narrativa, diagrama de flujo, diagrama N-S o pseudocódigo.
Este documento presenta un tutorial de C++ dividido en 23 capítulos. El tutorial utiliza ejemplos sencillos de código para explicar conceptos básicos como funciones, tipos de datos, clases, herencia, entre otros. Cada capítulo contiene uno o más fragmentos de código con comentarios que describen su funcionalidad. El objetivo del tutorial es servir como referencia rápida para aprender los fundamentos del lenguaje C++.
Este documento introduce los conceptos básicos de tipos de datos y variables en Java. Explica los tipos primitivos como enteros, flotantes y caracteres, así como la clase String. Describe cómo declarar y asignar valores a variables, incluyendo las reglas básicas y el ámbito de vida. También cubre la conversión de tipos, operadores aritméticos y relacionales, y cómo comparar cadenas String.
El documento describe los elementos básicos de un programa en C++. Un programa está definido por funciones, donde la función principal es main. La estructura general de un programa incluye directivas de preprocesamiento, declaraciones globales, la función main y funciones definidas por el usuario, así como comentarios. El documento también explica conceptos como tipos de datos, estatutos de lectura y escritura.
Este documento presenta un resumen de 3 conceptos clave de C++:
1) Define los tipos de datos fundamentales como enteros, flotantes, caracteres y booleanos, y explica el tipo void.
2) Explica el concepto de clase en programación orientada a objetos y provee un ejemplo de clase Punto con atributos y métodos.
3) Introduce los constructores como métodos especiales que se ejecutan al crear un objeto y pueden inicializar sus atributos.
El documento describe el lenguaje de programación C. C fue creado a mediados de los años 70 y es un lenguaje estructurado pero no por bloques. El lenguaje proporciona flexibilidad pero deja la responsabilidad de comprobaciones al programador. C consta de funciones, con la función main ejecutándose primero.
Lenguaje C para Administradores de Red - Script II Punterossirfids
2da entrega que abarca el uso de punteros en el Lenguaje C de una forma muy sencilla. Dirigido a Administradores de Red que desean incursionar en la programación de este poderoso lenguaje
Para convertir un algoritmo en un programa, se deben seguir varias fases: 1) edición del código fuente, 2) preprocesado del código, 3) compilación del código preprocesado que genera el código objeto, y 4) enlace del código objeto con bibliotecas para crear el programa ejecutable.
Si quiere descargar la presentación y los códigos fuente, dirijase a:
http://programaciondecomputadoresunalmzl.wikispaces.com/codigos_y_diapositivas
Le agradecería si me reporta los errores que encuentre en la diapositiva (daalvarez arroba unal punto edu punto co)
El documento describe los conceptos básicos de la programación en C, incluyendo la estructura de un programa con funciones como main, las diferentes instrucciones como de expresión y control, y los tipos de datos como enteros, reales y caracteres. Se incluye un ejemplo de un programa Hola Mundo para ilustrar estos conceptos.
Este documento presenta una introducción al lenguaje C#. Explica que C# es un lenguaje derivado de C y C++ diseñado para el desarrollo en .NET. Describe las características principales de C# como su sintaxis, tipos de datos, variables, operadores, sentencias de control de flujo y estructuras como clases y métodos. También explica conceptos como espacios de nombres, tipos por valor y referencia, arrays, constantes y excepciones.
1) El documento presenta información sobre operadores matemáticos en lenguajes de programación como Java y C++. 2) Explica conceptos como precedencia de operadores, tipos de datos primitivos como enteros y flotantes, y características de la programación orientada a objetos como clases, atributos, métodos y constructores. 3) También incluye ejemplos simples de programas Hola Mundo en C++.
El documento describe los conceptos básicos de la programación, incluyendo los tipos de lenguajes de programación, las fases del proceso de programación, y conceptos clave como variables, constantes, algoritmos, pseudocódigo y diagramas de flujo. También explica la diferencia entre bits y bytes como unidades básicas de almacenamiento de datos en un computador.
Este documento presenta una introducción al lenguaje C#. Cubre que C# es un lenguaje derivado de C diseñado para .NET, con mejoras sobre C++. Explica la estructura básica de un programa C# incluyendo espacios de nombres, tipos, variables y constantes. También describe expresiones, operadores, sentencias de control de flujo como if, for y switch, y bucles foreach.
El documento explica conceptos básicos de entrada y salida de datos en C, como incluir la librería stdio.h, usar scanf para ingresar datos en variables, y ejemplos de programas que piden datos al usuario y los procesan usando if/else y while.
1) Los punteros permiten almacenar direcciones de memoria y apuntar a otras variables u objetos. 2) Los arreglos almacenan conjuntos de datos del mismo tipo de forma ordenada y contigua en memoria, y se pueden indexar mediante un índice. 3) Las cadenas de caracteres (strings) son arreglos unidimensionales de caracteres que terminan en un carácter nulo, y se pueden manipular con funciones de la biblioteca string.h.
El documento habla sobre punteros en el lenguaje C. Explica que un puntero es una variable que contiene la dirección de memoria de otra variable y permite acceder y modificar su valor. También define los operadores & y * para obtener la dirección de memoria de una variable y acceder al valor apuntado por un puntero, respectivamente. Finalmente, resalta la importancia de entender punteros para dominar el lenguaje C.
El documento describe el lenguaje de programación C, incluyendo que es de uso general y portátil, y maneja elementos básicos como caracteres y números. Explica también cómo crear y ejecutar pequeños programas en C, y presenta conceptos como tipos de datos, variables, constantes, operadores y funciones como printf y scanf.
Este documento describe los diferentes tipos de datos en C++, incluyendo enteros (int, char, float, etc.), con y sin signo, y sus rangos de valores. Explica que los tipos derivados se crean a partir de los tipos primitivos y que estos incluyen enteros, reales, lógicos y caracteres. También cubre la representación de números reales y las bibliotecas matemáticas utilizadas.
Este documento proporciona una introducción a Python, incluyendo qué es Python, sus características, quién lo usa, tipos de datos básicos como listas y diccionarios, definición de funciones, clases, herencia, manejo de excepciones y ejemplos.
El documento describe los conceptos básicos de identificadores, variables y constantes en programación. Explica que los identificadores son nombres asignados a elementos de un algoritmo como variables, constantes y tipos de datos. Las variables representan espacios de memoria para almacenar datos que pueden cambiar, mientras que las constantes almacenan valores fijos. Detalla las reglas para nombrar identificadores y declarar variables y constantes en pseudocódigo.
El primer objetivo de un programa informático es el manejo de datosRolando Azcorra Medina
El documento describe los diferentes tipos de datos que se pueden manejar en C, incluyendo enteros, reales, caracteres y cadenas de caracteres. Explica cómo definir variables de cada tipo usando las palabras clave como int, float y char, y cómo usar las funciones printf() y scanf() para mostrar y leer datos respectivamente.
Este documento proporciona información sobre funciones de E/S de librerías C en GNU/Linux. Incluye tablas sobre funciones de E/S mediante streams y sus características comunes, así como descripciones detalladas de funciones populares como fopen, fread, fprintf y fgets. El documento está licenciado bajo la GNU Free Documentation License.
El documento proporciona una introducción al lenguaje de programación C#.NET. Explica que C# es un lenguaje orientado a objetos diseñado para el desarrollo .NET que mejora C++ en áreas como seguridad de datos y recolección de basura. También describe la estructura básica de un programa C#, incluyendo espacios de nombres, tipos, variables, operadores, sentencias de control de flujo y clases.
Este documento presenta un guión de prácticas para introducir las estructuras secuenciales en C. Explica cómo escribir un primer programa "Hola Mundo" y luego uno más complejo que calcula el perímetro de una circunferencia. También describe elementos como librerías, constantes, variables, entradas y salidas de datos.
Este documento presenta una introducción a la programación en lenguaje C. Explica que los programas son conjuntos de órdenes para un ordenador en un lenguaje que este pueda entender. Mientras que los ordenadores entienden lenguajes de bajo nivel difíciles para humanos, se usan lenguajes de alto nivel más parecidos al lenguaje humano. Luego, proporciona algunos ejemplos para distinguir entre lenguajes de alto y bajo nivel.
Lenguajes De Programacion C nivel1-unidad2charnisch
El documento describe los pasos para compilar y ejecutar un programa en C++, incluyendo instalar un compilador, compilar el código fuente para generar código objeto, enlazar el código objeto con bibliotecas para crear un ejecutable, y ejecutar el programa. También explica operadores aritméticos, relacionales y lógicos usados para realizar operaciones básicas en C++.
Este documento presenta el programa de estudios para el módulo de "Programación básica" para las carreras de Profesional Técnico y Profesional Técnico-Bachiller en Informática. Incluye la presentación general de las carreras, sus objetivos y competencias transversales, así como detalles específicos sobre el módulo como su propósito, contenido y unidades de aprendizaje. El programa proporciona una guía para maestros y estudiantes sobre lo que se debe enseñar y aprender en el módulo de
Lenguaje C para Administradores de Red - Script II Punterossirfids
2da entrega que abarca el uso de punteros en el Lenguaje C de una forma muy sencilla. Dirigido a Administradores de Red que desean incursionar en la programación de este poderoso lenguaje
Para convertir un algoritmo en un programa, se deben seguir varias fases: 1) edición del código fuente, 2) preprocesado del código, 3) compilación del código preprocesado que genera el código objeto, y 4) enlace del código objeto con bibliotecas para crear el programa ejecutable.
Si quiere descargar la presentación y los códigos fuente, dirijase a:
http://programaciondecomputadoresunalmzl.wikispaces.com/codigos_y_diapositivas
Le agradecería si me reporta los errores que encuentre en la diapositiva (daalvarez arroba unal punto edu punto co)
El documento describe los conceptos básicos de la programación en C, incluyendo la estructura de un programa con funciones como main, las diferentes instrucciones como de expresión y control, y los tipos de datos como enteros, reales y caracteres. Se incluye un ejemplo de un programa Hola Mundo para ilustrar estos conceptos.
Este documento presenta una introducción al lenguaje C#. Explica que C# es un lenguaje derivado de C y C++ diseñado para el desarrollo en .NET. Describe las características principales de C# como su sintaxis, tipos de datos, variables, operadores, sentencias de control de flujo y estructuras como clases y métodos. También explica conceptos como espacios de nombres, tipos por valor y referencia, arrays, constantes y excepciones.
1) El documento presenta información sobre operadores matemáticos en lenguajes de programación como Java y C++. 2) Explica conceptos como precedencia de operadores, tipos de datos primitivos como enteros y flotantes, y características de la programación orientada a objetos como clases, atributos, métodos y constructores. 3) También incluye ejemplos simples de programas Hola Mundo en C++.
El documento describe los conceptos básicos de la programación, incluyendo los tipos de lenguajes de programación, las fases del proceso de programación, y conceptos clave como variables, constantes, algoritmos, pseudocódigo y diagramas de flujo. También explica la diferencia entre bits y bytes como unidades básicas de almacenamiento de datos en un computador.
Este documento presenta una introducción al lenguaje C#. Cubre que C# es un lenguaje derivado de C diseñado para .NET, con mejoras sobre C++. Explica la estructura básica de un programa C# incluyendo espacios de nombres, tipos, variables y constantes. También describe expresiones, operadores, sentencias de control de flujo como if, for y switch, y bucles foreach.
El documento explica conceptos básicos de entrada y salida de datos en C, como incluir la librería stdio.h, usar scanf para ingresar datos en variables, y ejemplos de programas que piden datos al usuario y los procesan usando if/else y while.
1) Los punteros permiten almacenar direcciones de memoria y apuntar a otras variables u objetos. 2) Los arreglos almacenan conjuntos de datos del mismo tipo de forma ordenada y contigua en memoria, y se pueden indexar mediante un índice. 3) Las cadenas de caracteres (strings) son arreglos unidimensionales de caracteres que terminan en un carácter nulo, y se pueden manipular con funciones de la biblioteca string.h.
El documento habla sobre punteros en el lenguaje C. Explica que un puntero es una variable que contiene la dirección de memoria de otra variable y permite acceder y modificar su valor. También define los operadores & y * para obtener la dirección de memoria de una variable y acceder al valor apuntado por un puntero, respectivamente. Finalmente, resalta la importancia de entender punteros para dominar el lenguaje C.
El documento describe el lenguaje de programación C, incluyendo que es de uso general y portátil, y maneja elementos básicos como caracteres y números. Explica también cómo crear y ejecutar pequeños programas en C, y presenta conceptos como tipos de datos, variables, constantes, operadores y funciones como printf y scanf.
Este documento describe los diferentes tipos de datos en C++, incluyendo enteros (int, char, float, etc.), con y sin signo, y sus rangos de valores. Explica que los tipos derivados se crean a partir de los tipos primitivos y que estos incluyen enteros, reales, lógicos y caracteres. También cubre la representación de números reales y las bibliotecas matemáticas utilizadas.
Este documento proporciona una introducción a Python, incluyendo qué es Python, sus características, quién lo usa, tipos de datos básicos como listas y diccionarios, definición de funciones, clases, herencia, manejo de excepciones y ejemplos.
El documento describe los conceptos básicos de identificadores, variables y constantes en programación. Explica que los identificadores son nombres asignados a elementos de un algoritmo como variables, constantes y tipos de datos. Las variables representan espacios de memoria para almacenar datos que pueden cambiar, mientras que las constantes almacenan valores fijos. Detalla las reglas para nombrar identificadores y declarar variables y constantes en pseudocódigo.
El primer objetivo de un programa informático es el manejo de datosRolando Azcorra Medina
El documento describe los diferentes tipos de datos que se pueden manejar en C, incluyendo enteros, reales, caracteres y cadenas de caracteres. Explica cómo definir variables de cada tipo usando las palabras clave como int, float y char, y cómo usar las funciones printf() y scanf() para mostrar y leer datos respectivamente.
Este documento proporciona información sobre funciones de E/S de librerías C en GNU/Linux. Incluye tablas sobre funciones de E/S mediante streams y sus características comunes, así como descripciones detalladas de funciones populares como fopen, fread, fprintf y fgets. El documento está licenciado bajo la GNU Free Documentation License.
El documento proporciona una introducción al lenguaje de programación C#.NET. Explica que C# es un lenguaje orientado a objetos diseñado para el desarrollo .NET que mejora C++ en áreas como seguridad de datos y recolección de basura. También describe la estructura básica de un programa C#, incluyendo espacios de nombres, tipos, variables, operadores, sentencias de control de flujo y clases.
Este documento presenta un guión de prácticas para introducir las estructuras secuenciales en C. Explica cómo escribir un primer programa "Hola Mundo" y luego uno más complejo que calcula el perímetro de una circunferencia. También describe elementos como librerías, constantes, variables, entradas y salidas de datos.
Este documento presenta una introducción a la programación en lenguaje C. Explica que los programas son conjuntos de órdenes para un ordenador en un lenguaje que este pueda entender. Mientras que los ordenadores entienden lenguajes de bajo nivel difíciles para humanos, se usan lenguajes de alto nivel más parecidos al lenguaje humano. Luego, proporciona algunos ejemplos para distinguir entre lenguajes de alto y bajo nivel.
Lenguajes De Programacion C nivel1-unidad2charnisch
El documento describe los pasos para compilar y ejecutar un programa en C++, incluyendo instalar un compilador, compilar el código fuente para generar código objeto, enlazar el código objeto con bibliotecas para crear un ejecutable, y ejecutar el programa. También explica operadores aritméticos, relacionales y lógicos usados para realizar operaciones básicas en C++.
Este documento presenta el programa de estudios para el módulo de "Programación básica" para las carreras de Profesional Técnico y Profesional Técnico-Bachiller en Informática. Incluye la presentación general de las carreras, sus objetivos y competencias transversales, así como detalles específicos sobre el módulo como su propósito, contenido y unidades de aprendizaje. El programa proporciona una guía para maestros y estudiantes sobre lo que se debe enseñar y aprender en el módulo de
El documento habla sobre las técnicas de algoritmos para el diseño de procesos computacionales. Explica conceptos como algoritmo, diagrama de flujo, pseudocódigo, programa, y las etapas en la creación de programas (requisitos, análisis, diseño, codificación, prueba, mantención). También describe características de la programación estructurada como la estructura descendente, modularidad, cohesión y acoplamiento.
Este documento discute la complejidad de los algoritmos y cómo depende del tamaño del problema a resolver. La complejidad se asocia con la cantidad de memoria y operaciones requeridas para la ejecución, siendo el mejor caso aquel que requiere los menos recursos y el peor caso el que necesita más operaciones. Finalmente, describe diferentes tipos de complejidad de tiempo de ejecución en función del tamaño de la entrada, como complejidad constante, lineal y exponencial.
Este documento presenta una introducción a la programación orientada a objetos en C++. Explica conceptos clave como clases, objetos, herencia y polimorfismo. También describe características del lenguaje C++ como comentarios, tipos de datos definidos por el usuario, funciones miembro, constructores, destructores, entre otros. El documento contiene varios ejemplos de código para ilustrar el uso de estas características.
Este documento presenta un cuaderno de ejercicios y prácticas para el curso de Programación II con WinAPI en C++. Incluye 52 ejercicios y 20 prácticas que cubren temas como la creación de ventanas, controles como botones, cajas de texto y listas, manejo de eventos, y más. Cada ejercicio presenta el código de ejemplo y preguntas sobre los conceptos cubiertos. El objetivo es que los estudiantes practiquen y aprendan los conceptos básicos de la programación de interfaces gráficas de usuario
This document discusses the transition from structured programming to object-oriented programming. Structured programming relies on control structures like if/else and while loops rather than goto statements. It advocates top-down development through stepwise refinement of procedures. However, structured programming is narrowly focused on solving a single problem. It also bases program structure on decomposition of functionality rather than stable data structures. Object-oriented programming orients programs more broadly towards reuse. It focuses on data structures, which tend to be more stable than control structures. OOP provides an alternative to the top-down approach through multiple conceptual "tops" in a system.
Manual de conexión de base de datos distribuidaJorch Mendez
Este documento describe cómo configurar una base de datos distribuida con arquitectura maestro-maestro utilizando MySQL. Se requiere hardware como dos PCs con Windows 7 y software como AppServ. Se explica cómo configurar las IPs de las máquinas, los archivos my.ini para replicación, y crear un usuario replicación. Finalmente, se prueba modificando datos en el maestro 1 y verificando que se repliquen en el esclavo 1.
El documento habla sobre el diseño de bases de datos distribuidas. Menciona consideraciones como la autonomía local de cada nodo, la ausencia de un sitio central, la operación continua del sistema, la independencia de la ubicación y fragmentación de datos, la replicación de datos, el procesamiento de consultas distribuidas y la administración de transacciones distribuidas. También describe el diccionario de datos como un conjunto de metadatos que contiene información lógica sobre los datos del sistema.
La computadora está compuesta de una parte física y lógica. La parte física incluye la unidad central de procesamiento, memoria y dispositivos de entrada/salida. La parte lógica incluye el sistema operativo, software de aplicación y lenguajes de programación. Los lenguajes de programación permiten automatizar tareas mediante instrucciones entendibles por la computadora. Existen lenguajes de bajo y alto nivel, compilados e interpretados, que permiten programar usando estructuras secuenciales, alternativas e iterativas.
1) Un sistema de gestión de bases de datos distribuidas permite la administración y acceso a datos almacenados en múltiples sitios de una red de manera transparente para los usuarios.
2) El diseño de una base de datos distribuida requiere decidir cómo fragmentar y asignar los datos entre los sitios para optimizar el rendimiento y disponibilidad considerando factores como la frecuencia de acceso a los datos.
3) Una arquitectura cliente-servidor es común, donde clientes hacen solicitudes a servidores que procesan y almacen
El lenguaje de programación C fue creado en 1972 por Dennis Ritchie en los laboratorios Bell Telephone con el objetivo de diseñar el sistema operativo UNIX. C es un lenguaje de nivel medio que combina elementos de alto nivel con funcionalidad de ensamblador. Permite crear aplicaciones y software de sistemas mediante librerías de funciones y módulos compilables de forma independiente.
Este documento describe las bases de datos distribuidas. Estas consisten en fragmentos de datos que se almacenan en diferentes lugares conectados a través de una red. Cada lugar contiene una computadora y un sistema de gestión de bases de datos para administrar los fragmentos locales. Las bases de datos distribuidas ofrecen ventajas como el compartimiento de datos y la disponibilidad, pero también presentan desafíos como el costo del desarrollo del software y la actualización de datos duplicados.
1) El programa permite al usuario introducir su nombre mediante la función scanf y luego lo imprime en pantalla usando printf. 2) El programa declara una variable char llamada nom para almacenar el nombre introducido, que tiene un tamaño máximo de 20 caracteres. 3) La función printf muestra el texto "Hola" y el valor de la variable nom usando el indicador de formato %s.
Este documento presenta 7 ejemplos de programas en C++ usando el editor Dev-C++. Los ejemplos incluyen imprimir "Hola Mundo", calcular el cuadrado de un número, calcular el área de un triángulo, determinar el mayor de 3 números, imprimir los divisores de un número, calcular el mayor de un conjunto de números reales, e imprimir el factorial de un número. El documento también incluye un taller con 12 ejercicios adicionales.
Este documento presenta conceptos básicos de programación y fundamentos de PseInt. Explica estructuras como diagramas de flujo, constantes, variables, acumuladores, contadores e identificadores. Define a PseInt como un software educativo para aprender programación a través de pseudocódigo y diagramas de flujo de forma sencilla. Finalmente, concluye que la tecnología ofrece herramientas útiles para la programación como PseInt.
El documento explica la diferencia entre un contador y un acumulador en programación, cómo declarar variables en PSeInt y tres tipos de lenguajes de programación. Luego presenta siete algoritmos en PSeInt para operaciones matemáticas y conversiones de unidades, concluyendo con enlaces sobre el tema.
el objetivo de este trabajo es comprender y ampliar los conocimientos sobre Pseint una herramienta que es capas de interpretar el lenguaje a traves de pseudocódigo con una descripcion informal de algoritmo.
Este documento describe conceptos básicos de programación como constantes, variables, acumuladores, contadores e identificadores. Explica que las constantes son valores fijos que no cambian, mientras que las variables almacenan valores que pueden modificarse. También define acumuladores y contadores como variables utilizadas para sumar valores de forma iterativa. Finalmente, describe los fundamentos de programación en Pseint, incluyendo estructuras de control y tipos de datos.
Este documento describe conceptos básicos de programación como constantes, variables, acumuladores, contadores e identificadores. Explica que las constantes son valores fijos que no cambian, mientras que las variables almacenan valores que pueden modificarse. También define acumuladores y contadores como variables utilizadas para sumar valores de forma iterativa. Finalmente, introduce los fundamentos de programación en Pseint, incluyendo estructuras de control y tipos de datos.
Este documento describe conceptos básicos de programación como constantes, variables, acumuladores, contadores e identificadores. Explica que las constantes son valores fijos que no cambian, mientras que las variables pueden modificarse. Los acumuladores y contadores son variables que cuentan eventos o iteraciones. También presenta los fundamentos de programación en Pseint, incluyendo estructuras de control, tipos de datos y depuración.
Este documento presenta los conceptos básicos del lenguaje de programación Python. Introduce los tipos de datos fundamentales como números, cadenas, listas y diccionarios, y estructuras de control como condicionales e iteración. También explica funciones, excepciones, clases y módulos.
Este documento presenta conceptos básicos de programación como acumuladores, contadores, constantes, variables e identificadores. También explica qué es PSeInt y para qué sirve, resumiendo que es una herramienta didáctica que guía a estudiantes principiantes en la lógica de programación mediante el uso de pseudocódigo en español. Finalmente, concluye que PSeInt es recomendada para aprender sobre informática de manera gradual, desde lo más básico hasta conceptos más avanzados.
El documento describe las tres etapas principales de la programación: 1) especificación, 2) diseño, y 3) implementación. También explica los tipos de lenguajes de programación, como los lenguajes de alto y bajo nivel, y cómo se utilizan compiladores e intérpretes. Además, proporciona detalles sobre el lenguaje de programación Pascal, incluida su historia, características y unidades estándar.
Este documento introduce conceptos básicos del lenguaje de programación C++, incluyendo elementos del lenguaje como identificadores, palabras reservadas, literales constantes y delimitadores. También describe las constantes, variables y tipos de datos, así como la estructura general de un programa en C++.
Este documento presenta información sobre programación. Explica conceptos clave como qué es un programa, lenguajes de programación, tipos de lenguajes, datos y códigos. También define qué es un algoritmo, da ejemplos de algoritmos y pasos para resolver problemas. Por último, describe tipos de datos, constantes, variables y operadores usados en programación.
Este manual describe los tipos de datos básicos en C/C++ como enteros, reales, lógicos y caracteres. Explica cómo declarar variables y realizar entradas y salidas mediante funciones como printf, scanf, cout y cin. También cubre temas como arreglos, estructuras, funciones y sentencias de control.
Este documento contiene notas sobre varios temas de programación en C y C++. Incluye una introducción al lenguaje C en comparación con Pseint, explicaciones sobre tipos de variables, condicionales if-else, bucles for, while y do-while, arreglos, arreglos de estructuras, funciones, tablas ASCII y operadores. También cubre temas como ficheros, lectura y escritura de estructuras en ficheros y la función switch. Por último, incluye apuntes sobre un proyecto final.
Este documento presenta una introducción al lenguaje de programación C++. Explica brevemente la historia de C++ y cómo surgió como una extensión del lenguaje C, añadiéndole características orientadas a objetos. Luego, cubre conceptos básicos como algoritmos, programas, tipos de datos, identificadores, constantes, operadores y comentarios. Finalmente, introduce temas más avanzados como arreglos, estructuras, entrada y salida, funciones y punteros.
Este manual proporciona una introducción al lenguaje de programación C/C++. Explica conceptos básicos como funciones, tipos de variables, operadores, estructura básica de un programa, y estructuras de control como if, switch y for. También cubre temas como E/S, ficheros, estructuras y funciones. El documento está organizado en secciones que detallan estos aspectos fundamentales del lenguaje C/C++.
Este documento describe diferentes temas relacionados con los tipos de datos en C/C++, incluyendo números enteros, reales, lógicos y caracteres. También cubre declaración de variables, entradas y salidas, palabras clave, funciones, arreglos y estructuras. Explica el uso de operadores como sizeof() para determinar el tamaño de los datos, y sentencias de control como if, else, while, for y do while.
Este documento proporciona una introducción a las librerías en C++. Explica que las librerías contienen código objeto predesarrollado para realizar tareas comunes como entrada/salida, funciones matemáticas, etc. También describe las librerías estándar que vienen con los compiladores de C++ y cómo estas librerías permiten ahorrar tiempo al reutilizar funcionalidad en lugar de tener que desarrollarla desde cero para cada programa. Finalmente, resume brevemente qué son exactamente las librerías y cómo se pueden incluir en un programa
Este manual describe los conceptos básicos del lenguaje C/C++. Explica la historia y ventajas de C, la estructura básica del código, los identificadores, tipos de datos como enteros, reales, lógicos y caracteres, variables, constantes, y operadores lógicos y de asignación. El manual proporciona una introducción general al lenguaje C/C++.
Este documento presenta una introducción al lenguaje de programación C/C++. Explica el origen y definición de C y C++, las palabras reservadas, los operadores y tipos de datos básicos como enteros, reales, caracteres y lógicos. También describe conceptos como variables, arreglos, estructuras, funciones y estructuras de control como condicionales y repetitivas.
Este documento presenta una introducción a los lenguajes de programación C y C++. Explica los tipos de datos básicos como enteros, reales y caracteres. También describe palabras reservadas, declaración de variables, sintaxis, sentencias de control como if/else y for, y estructuras de datos como arreglos y estructuras. Finalmente, cubre temas como el uso de ficheros y las funciones printf y scanf.
Este documento presenta un manual sobre C/C++. Explica conceptos básicos como sistemas de numeración, juegos de caracteres permitidos, palabras reservadas, operadores, tipos de datos, cómo crear variables y constantes, mostrar y leer datos, funciones sizeof, arreglos, casting de datos, estructuras, ficheros, funciones fread, fwrite y eof, sentencias de control como if/else, switch, bucles for, while y do-while, funciones fseek y ftell, funciones void, variables globales y locales. El manual provee una guía para aprender sobre
Este documento presenta una introducción al lenguaje de programación C. Explica que C fue creado por Dennis Ritchie y se utiliza principalmente para escribir sistemas operativos y compiladores. Describe las etapas para crear un programa en C, incluyendo la definición del problema, análisis, diseño, codificación, pruebas, documentación y mantenimiento. También define conceptos clave como identificadores, variables, constantes, tipos de datos, expresiones aritméticas y estructuras de datos como arreglos.
Este documento presenta un resumen de los principales conceptos de programación en C/C++. Explica temas como identificadores, tipos de datos, operadores, arreglos unidimensionales y bidimensionales, estructuras, funciones printf y scanf, entrada y salida de datos, y sentencias de control como if-else, switch, while y for. El documento proporciona ejemplos y sintaxis para cada uno de estos conceptos básicos de la programación en C/C++.
Este manual describe los lenguajes de programación C y C++, incluyendo declaración de variables, tipos de datos, palabras reservadas, operadores, arreglos, funciones y ejemplos de código. Explica conceptos fundamentales como la sintaxis para declarar variables, asignar valores, y los diferentes tipos de operadores, comandos y funciones disponibles en ambos lenguajes.
Este documento proporciona una introducción a los conceptos básicos de programación en C/C++, incluyendo elementos de un programa como comentarios, palabras reservadas, variables, constantes, operadores, estructuras de control y más. Explica conceptos como arreglos unidimensionales y bidimensionales, estructuras, funciones y entrada/salida de archivos. El documento servirá como guía para aprender los fundamentos de la programación en C/C++.
un lenguaje de programacion perfecto para hacer nuestras primeras practicas en el mundo de la ingenieria en sistema de informacion. Os dejo este documento para su beneficio
El documento presenta un manual sobre el lenguaje C/C++. Explica conceptos como variables y constantes, tipos de datos, estructuras de control como if, else, switch, while, for, arreglos, estructuras, funciones y entrada/salida. El manual contiene ejemplos de código para ilustrar cada uno de estos conceptos básicos del lenguaje C/C++.
Este documento presenta un manual sobre conceptos básicos de C/C++. Explica temas como tipos de datos, declaración de variables, librerías, operadores, arreglos, estructuras, funciones de entrada y salida, condicionales y bucles. El documento contiene ejemplos de código y sintaxis para cada tema cubierto.
Este documento proporciona una introducción al lenguaje de programación C/C++. Explica conceptos básicos como lenguaje de programación, algoritmo y programa de computadora. Luego describe datos básicos, variables, constantes y operadores en C/C++. Finalmente, cubre temas como arreglos, estructuras, entrada y salida, ficheros y estructuras de control. El objetivo es que el lector comprenda completamente el lenguaje C/C++ y pueda crear aplicaciones.
Este documento presenta un manual de programación en C/C++. Explica conceptos básicos como variables, constantes, tipos de datos, expresiones y operadores. También cubre estructuras de datos como arreglos y estructuras, así como entrada y salida de datos utilizando funciones como printf, scanf y ficheros. Finalmente, introduce sentencias de control de flujo como if/else, switch y bucles while y do-while, así como el uso de funciones y parámetros.
Estilo Arquitectónico Ecléctico e Histórico, Roberto de la Roche.pdfElisaLen4
Un pequeño resumen de lo que fue el estilo arquitectónico Ecléctico, así como el estilo arquitectónico histórico, sus características, arquitectos reconocidos y edificaciones referenciales de dichas épocas.
2. 1
CONTENIDO
Introducción.......................................................................................................................................................................2
Identificadoresy Tiposde Datos...........................................................................................................................................3
Operadoresen C.................................................................................................................................................................4
Size Of................................................................................................................................................................................6
Casting...............................................................................................................................................................................6
Arreglos(Arrays).................................................................................................................................................................7
ArreglosUnidimensionales.............................................................................................................................................7
ArreglosBidimensionales................................................................................................................................................7
Estructuras .........................................................................................................................................................................8
Estructuras anidadas.......................................................................................................................................................8
Uso de PrintF()y Scanf().......................................................................................................................................................9
printf.............................................................................................................................................................................9
scanf...........................................................................................................................................................................10
Manejo de archivos...........................................................................................................................................................12
Ficheros.......................................................................................................................................................................12
fopen..........................................................................................................................................................................12
fclose.......................................................................................................................................................................13
feof.........................................................................................................................................................................14
rewind.....................................................................................................................................................................14
Lectura........................................................................................................................................................................15
fgetc........................................................................................................................................................................15
fgets........................................................................................................................................................................16
fread.......................................................................................................................................................................18
fscanf......................................................................................................................................................................18
Escritura......................................................................................................................................................................19
fputc.......................................................................................................................................................................19
fputs........................................................................................................................................................................20
fwrite......................................................................................................................................................................21
fprintf......................................................................................................................................................................22
Funciones .........................................................................................................................................................................24
La sentencia return...................................................................................................................................................24
Argumentos .................................................................................................................................................................24
Variables Locales y Globales...........................................................................................................................................25
Instruccionesde control.....................................................................................................................................................25
La estructura condicional IF... else.........................................................................................................................25
Operadores de comparación......................................................................................................................................26
Operadores lógicos...................................................................................................................................................26
La estructura condicionalabierta y cerrada SWITCH... case.......................................................................................26
El bucledo...while..................................................................................................................................................27
El buclewhile............................................................................................................................................................27
El buclefor.................................................................................................................................................................28
3. 2
INTRODUCCIÓN
El lenguaje C es el resultado de un proceso de desarrollo que inició con un
lenguajedenominado BCPL. Este influenció a otro llamado B(inventado por
Ken Thompson). En los años 70; éste lenguajellevó a la aparición del C.
C es un lenguaje de programación de nivel medio ya que combina los
elementos del lenguaje de alto nivel con la funcionalidad del ensamblador.
Su característica principal es ser portable, es decir, es posible adaptar los
programas escritos para un tipo de computadora en otra.
Otra de sus características principales es el ser estructurado, es decir, el
programa sedivide en módulos (funciones) independientes entre sí.
El lenguaje C inicialmente fue creado para la programación de:
-Sistemas operativos
-Intérpretes
-Editores
-Ensambladores
-Compiladores
-Administradores debases de datos.
Actualmente, debido a sus características, puede ser utilizado para todo
tipo de programas.
4. 3
IDENTIFICADORES Y TIPOS DE DATOS
Los identificadores se reconocen como palabras que definen un tipo de
dato de un lenguaje, estos son tomados como palabras reservadas y cada
uno tiene un significado o función.
Los identificadores más comunes en un algoritmo son:
char: Palabra reservada que se usa para clasificar un dato como carácter o
cadena. Un ejemplo de su uso: char[6]=“Aquino”; (Aquí este está
declarando que “Aquino” es de tipo Carácter.)
int: Palabra reservada que se usa para clasificar un dato como numero
entero. Un ejemplo de su uso: int x = 98; Aquí está declarando que “x” es
de tipo entero y seinicializa con el valor de 98.
float: Palabra reservada que se usa para clasificar un tipo de dato como
número real o decimal. Ejemplo: float y = 12.34. Aquí se está declarando
que y es de tipo real o decimal y se inicializa con el valor de 98.
double: Se usa como la palabra reservada float, pero con doble precisión
(Para números elevados y con exponentes precisos).
5. 4
OPERADORES EN C
*Los operadores son distintos en casi todos los lenguajes, las tablas de valores antes
vistos son de operadores solamente de C, en C++ cambian algunos.*
7. 6
SIZE OF
Esta función u operador se usa para mostrar el tamaño de una cadena, por
lo generalcuando cuenta la cadena empieza desde“0” hasta el tamaño que
tenga.
Ejemplo:
Con el comando Size of medimos cuanto espacio en memoria ocuparía la
variable, y como se observa nos dio resultado 4 bytes siendo un entero.
CASTING
El casting se utiliza para castear o cambiar valores, pasar deun tipo de
dato a otro.
Aquí una tabla de casting entre tipo de datos:
8. 7
ARREGLOS (ARRAYS)
Los arrays, arreglos o vectores forman parte de la amplia variedad de
estructuras de datos que nos ofrece C++, siendo además una de las
principales y más útiles estructuras quepodremos tener como herramienta
de programación. Los arrays, arregloso vectores (como los quieras llamar),
son utilizados para almacenar múltiples valores en una única variable.
ARREGLOS UNIDIMENSIONALES
Un arreglo unidimensional es un conjunto de n elementos del mismo tipo
almacenadosen memoria continua en un vector o lista. Paraacceder a cada
elemento del arreglo se requiere de un solo índice o subíndice, el cual
representa la posición en la que se encuentra.
Aquí se declaró un arreglo unidimensional de10 caracteres.
ARREGLOS BIDIMENSIONALES
Un arreglo bidimensional es un conjunto de n elementos del mismo tipo
almacenados en memoria contigua en una matriz o tabla. A diferencia de
los arreglos unidimensionales que solo requieren de un subíndice, los
arreglos bidimensionales para acceder a cada elemento del arreglo
requieren dedosíndices o subíndicesdeclaradosen dosparesdecorchetes,
donde el primer corchete se refiere al tamaño de filas y el segundo al
tamaño de columnas.
Aquí se declaró un arreglo bidimensional de10 filas y 4 columnas.
9. 8
ESTRUCTURAS
En la creación de soluciones para algunos problemas surgela necesidad de
agrupar datos de diferente tipo o de manejar datos que serían muy difícil
de describir en los tipos de datos primitivos, esta es la situación en la que
debemos aprovecharnos de las características que hacen al lenguaje C
especial, o sea el uso de estructuras.
Una estructura contiene varios datos. La forma de definir una estructura es
haciendo uso de la palabra clave struct. Aquíun ejemplo deuna estructura:
ESTRUCTURAS ANIDADAS
Una estructura puede estar dentro de otra
estructura a esto se le conoce como
anidamiento o estructuras anidadas. Ya que
se trabajan con datos en estructuras si
definimos un tipo de dato en una estructura
y necesitamos definir ese dato dentro de otra
estructura solamente se llama el dato de la
estructura anterior.
Ejemplo:
10. 9
USO DE PRINTF() Y SCANF()
PRINTF
La función PRINTF() se usa para la salida; en forma similar, la función
SCANF() se usa para la entrada. En sentido técnico, estas funciones no son
parte del lenguajeC, sino del sistema C; residen en una biblioteca estándar
y están disponibles para usarlas donde quiera que haya un sistema C.
Ambas funciones tienen una lista de parámetros con dos partes:
string_de_control y lista_de_argumentos
La primera es un String y puede contener especificaciones de conversión o
formatos. Una especificación de conversión se inicia con un carácter % y
termina con un carácter de conversión; por ejemplo, en el formato %d la
letra d es el carácter de conversión y permite imprimir el valor de una
expresión como un entero decimal. Para imprimir las letras ABC en la
pantalla, podría usarsela proposición:
printf("ABC");
Otra manera de hacer esto es mediante la proposición:
printf("%s", "ABC");
El formato %s hace que el argumento "ABC" se imprima en el formato de
un string de caracteres. Esto mismo puede realizarse también con la
proposición:
printf("%c%c%c", 'A', 'B', 'C');
Los apóstrofos que encierran cada letra se emplean para designar
constantes de caracteres; de acuerdo con esto, `A` es la constante de
carácter que correspondea la letra A mayúscula. El formato %c imprime el
valor de una expresión como un carácter.
11. 10
Por ejemplo:
char c1, c2,c3;
c1 = 'A';
c2 = 'B';
c3 = 'C';
printf("%c%c%c", c1,
c2, c3);
Imprimirá de nuevo las letras ABC en la pantalla.
Ahora veamos los caracteres de conversión:
c: carácter
d: decimal
e: número de punto flotante en notación científica
f : número de punto flotante
g : en el formato-e o el formato-f, el que sea más corto
s : string
SCANF
La función scanf() es análoga a la función printf(), pero se usa para la
entrada. Su primer argumento es un string de control con formatos que
corresponden a las diferentes formas en que pueden interpretarse los
caracteresen la entrada como valorespara losdiferentes tipos de variables.
La lista de argumentos está formada por DIRECCIONES de variables. El
símbolo & representaal operadordedirección; porejemplo, la proposición:
scanf("%d", &x);
Contiene el formato %d, el cual provoca que scanf() interprete los
caracteres de entrada como un entero decimal y que coloque el valor en la
dirección x. La función scanf() puede usarse para convertir cadenas de
dígitos decimales en valores enteros y almacenarlos en el lugar apropiado.
12. 11
Ahora veamos los caracteres de conversión:
c: carácter
d: decimal
f: número de punto flotante (float)
lf: número de punto flotante (double)
s: cadena de caracteres (string)
Veamos un ejemplo.
#include <stdio.h>
main() {
int x;
char c;
float y;
double z;
printf("nIngrese
un caracter : ");
scanf("%c", &c);
printf("nIngreseun int : ");
scanf("%d", &x);
printf("nIngreseun float: ");
scanf("%f", &y);
printf("nIngreseun double: ");
scanf("%lf", &z);
printf("nnLos datos queud. ingreso fueron :n");
printf("%c %d %e %enn", c, x, y, z);
}
13. 12
MANEJO DE ARCHIVOS
Así como hemos revisado la salida y entrada por pantalla y teclado
respectivamente, veremos ahora la entrada y/o salida de datos utilizando
ficheros, lo cual será imprescindible para un gran número de aplicaciones
que deseemos desarrollar.
FICHEROS
El estándar de C contiene varias funciones para la edición de ficheros, éstas
están definidas en la cabecera stdio.h y por lo generalempiezan con la letra
f, haciendo referencia a file. Adicionalmente se agrega un tipo FILE, el cual
se usará como apuntador a la información del fichero. La secuencia que
usaremos para realizar operaciones será la siguiente:
Crear un apuntador del tipo FILE *
Abrir el archivo utilizando la función fopen y asignándole el resultado de la
llamada a nuestro apuntador.
Hacer las diversas operaciones (lectura, escritura, etc).
Cerrar el archivo utilizando la función fclose.
FOPEN
Esta función sirvepara abrir y crear ficheros en disco.
El prototipo correspondientede fopen es:
FILE * fopen (const char *filename, const char *opentype);
Los parámetros de entrada de fopen son:
filename: una cadena quecontiene un nombrede fichero válido. opentype:
especifica el tipo de fichero que se abrirá o se creará.
14. 13
Una lista de parámetros opentypepara la función fopen es:
"r”: abrir un archivo para lectura, el fichero debe existir.
"w”: abrir un archivo para escritura, se crea si no existe o se sobrescribe si
existe.
"a”: abrir un archivo para escritura al final del contenido, si no existe se crea.
"r+”: abrir un archivo para lectura y escritura, el fichero debe existir.
"w+”: crear un archivo para lectura y escritura, se crea si no existe o se
sobrescribe si existe.
"r+b ó rb+”: Abre un archivo en modo binario para actualización (lectura y
escritura).
"rb”: Abre un archivo en modo binario para lectura.
FCLOSE
Esta función sirvepara poder cerrar un fichero que seha abierto.
El prototipo correspondientede fclose es:
int fclose (FILE *stream);
Un valor de retorno cero indica que el fichero ha sido correctamente
cerrado, si ha habido algún error, el valor de retorno es la constanteEOF.
Un ejemplo pequeño para abrir y cerrar el archivo llamado fichero.in en
modo lectura:
#include <stdio.h>
#include <stdlib.h>
int main(int argc, char** argv)
{
FILE *fp;
fp = fopen ( "fichero.in", "r" );
if (fp==NULL) {fputs ("File error",stderr); exit (1);}
fclose ( fp );
return 0;
}
15. 14
Como vemos,en el ejemplo seutilizó el opentype"r",quees para la lectura.
Otra cosa importante es que el lenguaje C no tiene dentro de si una
estructurapara elmanejo de excepciones o deerrores,poreso es necesario
comprobar que el archivo fue abierto con éxito "if (fp == NULL)". Si fopen
pudo abrir el archivo con éxito devuelve la referencia al archivo (FILE*), de
lo contrario devuelve NULL y en este caso se debera revisar la direccion del
archivo o los permisos del mismo. En estos ejemplos solo vamos a dar una
salida con un retorno de 1 que sirvepara señalar que el programa termino
por un error.
FEOF
Esta función sirvepara determinar si el cursor dentro del archivo encontró
el final (end of file). Existe otra forma de verificar el final del archivo que es
comparar el caracter quetrae fgetc del archivo con el macro EOF declarado
dentro de stdio.h, pero este método no ofrece la misma seguridad (en
especial al tratar con los archivos "binarios"). La función feof siempre
devolverácero (Falso) sino es encontrado EOF en el archivo,de lo contrario
regresará un valor distinto de cero (Verdadero).
El prototipo correspondientede feof es:
int feof(FILE*fichero);
REWIND
Literalmente significa "rebobinar", sitúa el cursor de lectura/escritura al
principio del archivo.
El prototipo correspondientede rewind es:
void rewind(FILE*fichero);
16. 15
LECTURA
Un archivo generalmente debe verse como un string (una cadena de
caracteres) que esta guardado en el disco duro. Para trabajar con los
archivos existen diferentes formas y diferentes funciones. Las funciones
que podríamos usar para leer un archivo son:
char fgetc(FILE *archivo)
char *fgets(char *buffer, int tamano, FILE *archivo)
size_t fread(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
int fscanf(FILE *fichero, const char *formato, argumento, ...);
Las primeras dos de estas funciones son muy parecidas entre sí. Pero la
tercera, por el número y el tipo de parámetros, nos podemos dar cuenta de
que es muy diferente, por eso la trataremos aparte junto al fwrite que es
su contraparte para escritura.
FGETC
Esta función lee un caracter a la vez del archivo que esta siendo señalado
con el puntero *archivo. En caso de que la lectura sea exitosa devuelve el
caracter leído y en caso de que no lo sea o de encontrar el final del archivo
devuelve EOF.
El prototipo correspondientede fgetc es:
char fgetc(FILE *archivo);
Esta función se usa generalmente para recorrer archivos de texto. A manera
de ejemplo vamos a suponer que tenemos un archivo de texto llamado
"prueba.txt" en el mismo directorio en que se encuentra la fuente de nuestro
programa.
17. 16
Un pequeño programa que lea ese archivo será:
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *archivo;
char caracter;
archivo = fopen("prueba.txt","r");
if (archivo == NULL){
printf("nError de apertura del archivo. nn");
}else{
printf("nEl contenido del archivo de prueba es nn");
while (feof(archivo) == 0)
{
caracter = fgetc(archivo);
printf("%c",caracter);
}
}
fclose(archivo);
return 0;
}
FGETS
Esta función está diseñada para leer cadenas de caracteres. Leerá hasta n-
1 caracteres o hasta que lea un cambio de línea 'n' o un final de archivo
EOF. En este último caso, el carácter de cambio de línea 'n' también es
leído.
El prototipo correspondientede fgets es:
char *fgets(char *buffer, int tamaño, FILE *archivo);
El primer parámetro buffer lo hemos llamado así porque es un puntero a
un espacio de memoria del tipo char (podríamos usar un arreglo de char).
18. 17
El segundo parámetro es tamaño que es el límite en cantidad de caracteres
a leer para la función fgets.Ypor último el punterodel archivopor supuesto
que es la forma en que fgets sabrá a que archivo debe leer.
#include <stdio.h>
#include <stdlib.h>
int main()
{
FILE *archivo;
char caracteres[100];
archivo = fopen("prueba.txt","r");
if (archivo == NULL)
exit(1);
printf("nEl contenido del archivo de prueba es nn");
while (feof(archivo) == 0)
{
fgets(caracteres,100,archivo);
printf("%s",caracteres);
}
system("PAUSE");
fclose(archivo);
return 0;
}
Este es el mismo ejemplo de antes con la diferencia de que este hace uso
de fgets en lugar de fgetc. La función fgets se comporta de la siguiente
manera, leerá del archivo apuntado por archivo los caracteres que
encuentre y a ponerlos en buffer hasta que lea un caracter menos que la
cantidad de caracteres especificada en tamaño o hasta que encuentre el
final de una linea (n) o hasta que encuentre el final del archivo (EOF).
El beneficio de esta función es que se puede obtener una linea completa a
la vez. Y resulta muy útil para algunos fines como la construcción de un
parser de algún tipo de archivo de texto.
19. 18
FREAD
size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );
Esta función lee un bloque de una "stream" de datos. Efectúa la lectura de
un arreglo de elementos "count", cada uno de los cuales tiene un tamaño
definido por "size". Luego los guarda en el bloquede memoria especificado
por "ptr". El indicador de posición de la cadena de caracteres avanza hasta
leer la totalidad de bytes. Si esto es exitoso la cantidad de bytes leídos es
(size*count).
PARAMETROS:
ptr : Puntero a un bloque de memoria con un tamaño mínimo de
(size*count) bytes.
size : Tamaño en bytes de cada elemento (de los que voy a leer).
count : Número de elementos, los cuales tienen un tamaño "size".
stream: Puntero a objetos FILE, queespecifica la cadena de entrada.
FSCANF
La función fscanf funciona igual que scanf en cuanto a parámetros, pero la
entrada se toma de un fichero en lugar del teclado.
El prototipo correspondientede fscanf es:
int fscanf(FILE *fichero, const char *formato, argumento, ...);
20. 19
Podemos ver un ejemplo de su uso, abrimos el documento "fichero.txt" en
modo lectura y leyendo dentro de él.
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char buffer[100];
fp = fopen ( "fichero.txt", "r" );
fscanf(fp, "%s" ,buffer);
printf("%s",buffer);
fclose ( fp );
return 0;
}
ESCRITURA
Así como podemos leer datos desde un fichero, también se pueden crear y
escribir ficheros con la información que deseamos almacenar, Para trabajar
con los archivos existen diferentes formas y diferentes funciones. Las
funciones que podríamos usar para escribir dentro de un archivo son:
int fputc(int caracter, FILE *archivo)
int fputs(const char *buffer, FILE *archivo)
size_t fwrite(void *puntero, size_t tamano, size_t cantidad, FILE *archivo);
int fprintf(FILE *archivo, const char *formato, argumento, ...);
FPUTC
Esta función escribe un carácter a la vez del archivo que está siendo
señalado con el puntero *archivo. El valor de retorno es el carácter escrito,
si la operación fue completada con éxito, en caso contrario será EOF.
El prototipo correspondientede fputc es:
int fputc(int carácter, FILE *archivo);
21. 20
Mostramos un ejemplo del uso de fputc en un "fichero.txt", se escribirá
dentro del fichero hasta que presionemos la tecla enter.
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char caracter;
fp = fopen ( "fichero.txt", "a+t" ); //parametro para escritura
al final y para file tipo texto
printf("nIntroduce un texto al fichero: ");
while((caracter = getchar()) != 'n')
{
printf("%c", fputc(caracter, fp));
}
fclose ( fp );
return 0;
}
FPUTS
La función fputs escribeuna cadena en un fichero. la ejecución de la misma
no añadeel carácter de retorno de línea ni el carácter nulo final. El valor de
retorno es un número no negativo o EOF en caso de error. Los parámetros
de entrada son la cadena a escribir y un puntero a la estructura FILE del
fichero dondese realizará la escritura.
El prototipo correspondientede fputs es:
int fputs(const char *buffer, FILE *archivo)
22. 21
Para ver su funcionamiento mostramos el siguiente ejemplo:
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char cadena[] = "Mostrando el uso de fputs en un fichero.n";
fp = fopen ( "fichero.txt", "r+" );
fputs( cadena, fp );
fclose ( fp );
return 0;
}
FWRITE
Esta función está pensadapara trabajarcon registrosdelongitud constante
y forma pareja con fread. Es capaz de escribir hacia un fichero uno o varios
registros de la misma longitud almacenados a partir de una dirección de
memoria determinada. El valor de retorno es el número de registros
escritos, no el número de bytes. Los parámetros son: un puntero a la zona
de memoria de dondese obtendrán los datos a escribir, el tamaño de cada
registro, el número de registros a escribir y un puntero a la estructura FILE
del fichero al que se hará la escritura.
El prototipo correspondientede fwrite es:
size_t fwrite(void *puntero, size_t tamano, size_t cantidad,
FILE *archivo);
23. 22
Un ejemplo concreto del uso de fwrite con su contraparte fread y usando
funciones es:
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char cadena[] = "Mostrando el uso de fwrite en un fichero.n";
fp = fopen ( "fichero.txt", "r+" );
fwrite( cadena, sizeof(char), sizeof(cadena), fp ); //char
cadena[]... cada posición es de tamaño 'char'
fclose ( fp );
return 0;
}
FPRINTF
La función fprintf funciona igual que printf en cuanto a parámetros, pero la
salida se dirige a un archivo en lugar de a la pantalla.
El prototipo correspondiente de fprintf es:
int fprintf(FILE *archivo, const char *formato, argumento, ...);
24. 23
Podemos ver un ejemplo de su uso, abrimos el documento "fichero.txt" en
modo lectura/escritura y escribimos dentro de él.
#include <stdio.h>
int main ( int argc, char **argv )
{
FILE *fp;
char buffer[100] = "Esto es un texto dentro del fichero.";
fp = fopen ( "fichero.txt", "r+" );
fprintf(fp, buffer);
fprintf(fp, "%s", "nEsto es otro texto dentro del fichero.");
fclose ( fp );
return 0;
}
25. 24
FUNCIONES
Como vimos anteriormente C tiene como bloque básico la función main() ,
también hemos visto la sentencia printf() que es otra función, y de igual
forma hay muchas más funciones predefinidas, pero nosotros mismos
también podemos definir nuestras propias funciones. Dehecho, es
fundamental hacerlo.
Podemos definir una función cualquiera de la misma manera en que
definimos la función main(). Basta con poner su tipo, su nombre, sus
argumentos entre paréntesis y luego, entre llaves, su código:
LA SENTENCIA RETURN
La sentencia return puede utilizarse dentro de una función para terminar
su ejecución.
ARGUMENTOS
Las funciones también pueden recibir argumentos o parámetros, para
modificar su comportamiento.
26. 25
VARIABLES LOCALES Y GLOBALES
Además de pasar valores a una función, también se pueden declarar tipos
de datos dentro de las funciones,estos tipos de datos declaradosdentro de
una función solo son accesibles dentro de esta misma función y se les
conocen como variables locales, así pues podemos definir los mismos
nombres de variables en diferentes funciones, ya que estas variables solo
son accesibles dentro de esas funciones.
INSTRUCCIONES DE CONTROL
C es un ejemplo de programación estructurada. En este tipo de
programación, es necesario contar con ciertas estructuras que permitan
controlar el flujo del programa, es decir, tomar decisiones y repetir
acciones.
LA ESTRUCTURA CONDICIONAL IF... ELSE
En la gran mayoría de los programas será necesario tomar decisiones
sobrequé acciones realizar. Esas decisiones pueden depender de los datos
que introduzcael usuario, desi se ha producido algún error o de cualquier
otra cosa.
La estructura condicional if... else es la que nos permite tomar ese tipo de
decisiones. Traducida literalmente del inglés, se la podría llamar la
estructura "si...sino", es decir, "si secumple la condición, haz esto, y si no,
haz esto otro".
Un ejemplo sencillo sería el siguiente:
27. 26
OPERADORES DE COMPARACIÓN
El símbolo > visto en el último ejemplo es un operador, que en este caso
compara dos números enteros y devuelve verdadero si el primero es
mayor, falso en caso contrario.
A continuación un listado de los posibles operadores decomparación en C
y su significado.
Operadores de Comparación
Operador Significado
< estrictamente menor que
> estrictamente mayor que
<= menor o igual que
>= mayor o igual que
== igual a
!= distinto de
OPERADORES LÓGICOS
Los operadores && ("y"), || ("o") y ! ("no") son operadores lógicos.
Permiten operar con expresiones lógicas para generar expresiones más
complejas.
LA ESTRUCTURA CONDICIONAL ABIERTA Y CERRADA SWITCH... CASE
La estructura condicional switch... case se utiliza cuando queremos
evitarnos las llamadas escaleras de decisiones. La estructura if nos puede
proporcionar, únicamente, dos resultados, uno para verdadero y otro para
falso. Una estructura switch... case, por su parte, nos permite elegir entre
muchas opciones.
28. 27
EL BUCLE DO...WHILE
El bucle do...whilees un bucle que, por lo
menos, se ejecuta una vez. Do significa literalmente "hacer", y while
significa "mientras”
EL BUCLE WHILE
El bucle while sirvepara ejecutar código reiteradas veces.
La condición debe de ser una expresión lógica, similar a la de la sentencia
if. Primero seevalúa la condición. Si el resultado es verdadero, se
ejecuta el bloque de código. Luego sevuelve a evaluar la condición, y en
caso de dar verdadero se vuelvea ejecutar el bloque. El bucle se corta
cuando la condición da falso.
Ejemplo: imprimir los números de 0 a 99:
EJEMPLO
29. 28
EL BUCLE FOR
El bucle for es un bucle muy flexible y a la vez muy potente ya que tiene
varias formas interesantes de implementarlo, su forma más tradicional es
la siguiente:
for (/* inicialización */; /* condición */; /* incremento */) {
/* código a ejecutar */
}
Inicialización: en esta parte se inicia la variable que controla el bucle y es
la primera sentencia que ejecuta el bucle. Sólo se ejecuta una vez ya que
solo senecesita al principio del bucle.
Expresióncondicional: al igual que en el bucle while, esta expresión
determina si el bucle continuará ejecutándoseo no.
Incremento: es una sentencia que ejecuta al final de cada iteración del
bucle. Por lo general, se utiliza para incrementar la variable con que se
inició el ciclo. Luego de ejecutar el incremento, el bucle revisa
nuevamente la condición, si es verdadera tiene lugar una ejecución más
del cuerpo del ciclo, si es falsa se termina el ciclo y así.
30. 29
Fuentes:
- Clase de Laboratorio de Programación 1, Universidad
Centroamericana
- Programación en C, es.wikilibros.org