PROPUESTA ACADEMICA: PROGRAMACIÓN BÁSICA

NOMBRE: John Franklin Cardozo Pinilla

NOMBRE DE DOCENTE: Edith Cortés

C++

PARA EMPEZAR VEAMOS ALGUNAS DEFINICIONES QUE SERAN

NECESARIAS PARA LA TEORIA DE C++:

PROGRAMACION: Es un lenguaje de programación como sintaxis con instrucciones

para que un ordenador ejecute.

BASICA: Es la base de lo fundamental.

Programación Básica: La programación es el proceso de escribir -en un lenguaje

de programación- el código fuente de un software. De acuerdo a lo anterior
programación básica es algo básico, necesario para aprender a programar.

Algoritmo: es un método para resolver un problema mediante una serie de pasos

definidos, precisos y finitos.

VARIABLE: Una variable es un símbolo que representa un elemento no

especificado de un conjunto dado.

CONSTANTE: un valor estable en la ejecución de un programa.

INICIO CARACTE
RIZACION
DE LAS
SALIDAS
CARACTERIZ
ALGORITMO DESEADA
ACION DE
S COMO
TOAS LAS
UNA
ENTRADAS
FUNCION
LEGALES
DE LA
FINAL ENTRADA
introducción a los códigos que se utilizan para trabajar en DEV C++.

C++

Lenguage de
programació
n

C++ tiene los siguientes tipos

fundamentales:

Caracteres: char
(también es un entero),
wchar_t

Enteros: short int, int,

long int, long long int
Números con coma
flotante: float, double,
long double
Booleanos: bool

Vacío: void

Utilizamos librerias como <iostream.h>, <studio> y <conio.h>.

LIBRERIA (Iostream).

Es una librería de entrada y salida que provee los códigos fundamentales para
la ejecución del programa, se incluye así: # incluye <iostream.h>

LIBRERÍA (conio)
Es una librería de entrada y salida lleva funciones muy útiles para el programa.
De esta librería depende la funcion de (pause) en la pantalla, se incluye así: #
incluye <conio.h>

LIBRERÍA (Stdio)

Es una librería de tipo cabecera que contiene las definiciones de macros y las
constantes. Las declaraciones de funciones y usados por operaciones
estándar de entrada y salida.

Cout que es utilizado para escribir el mansaje que el computador va a imprimir

o mostrar.

Cin que es el espacio de memoria asignado para una variable.

Int se refiere a la utilización de números enteros.

FUNCION (main)

La funcion main es el punto de entrada a la ejecución del programa. Este

módulo realiza diversas tareas preparatorias a la ejecución del programa.

ASI SE REALIZA UN PROGRAMA BASICO EN C++.

# include <iostream.h>

Int main ( )

Int año_act=2010;

Int año_nac,edad;

Cout<<”digite año de nacimiento”;

Cin>>año_nac;

Edad=año_act – año_nac;

Cout<<”su edad es:\n”<<edad<<”años”;

Getch()

Return 0;
}

CONDICIONES

Condiciones: Una condición es una proposición que se debe cumplir para que se
cumpla otra. Igualmente, en programación las condiciones son expresiones que se
deben cumplir para que se ejecute un determinado bloque de acciones.

IF: Significa SI (condicional) en español. Su funcionamiento es simple. Se evalúa

una condición, si es verdadera ejecuta un código, si es falsa, ejecuta otro código (o
continúa con la ejecución del programa).

Else: La palabra else se refiere al bloque de acciones que se ejecuta cuando no se

cumple una determinada condición en un bucle if.

Estructura en pseudocódigo:

if (condición)
ejecuta esto si la condición es verdadera
else
ejecuta esto si la condición es falsa

Ejemplo de la estructura de selección if en lenguaje C:

int edad;
cout<<”Ingrese su edad: ”;
cin>>edad;

if (edad>=18)
{
cout<<“Usted es mayor de edad. ”;
}
else
{
cout<<“Usted es menor de edad. ”;
};

Expresiones lógicas simples

Las expresiones lógicas simples son aquéllas que se construyen mediante los
operadores relacionales aplicados a dos expresiones (variables, constantes, etc)
de un mismo tipo. En la siguiente tabla puedes ver una lista de los operadores
relacionales, mostrando el equivalente en C++, así como un ejemplo de una
expresión lógica simple utilizando cada operador:

Expresiones lógicas compuestas

Las expresiones lógicas compuestas son aquéllas que se construyen mediante los
operadores lógicos aplicados a variables o expresiones lógicas. En la siguiente
tabla puedes ver una lista de los operadores lógicos, mostrando el equivalente en C+
+ de los que has visto en pseudocódigo, así como un ejemplo de una expresión
lógica compuesta utilizando cada operador:

La siguiente table nos muestra es codigo que se debe utilizar para manejar
condiciones en c++.

Las condiciones se construyen utilizando expresiones lógicas simples y compuestas.

Recuerda que en el caso en que deban examinarse más ramificaciones puede

conseguirse anidando estructuras condicionales.
 Una expresión lógica
es cualquier
expresión que tenga
un resultado de tipo
lógico.
Los únicos
valores posibles
para una
expresión lógica
son:

Verdader
Falso o

Se
forman

Operadores Operadores
relacionales lógicos

Se utilizan para crear

las condiciones

SWITCH
Muchas veces nos metemos en aprietos cuando necesitamos tener el control sobre

muchas opciones que pudiese tomar el usuario, porque resulta muy complicado

pensar en varios if/else anidados, para esos casos tenemos otra herramienta muy

cómoda, la estructura de selección múltiple switch.

La forma general es:

switch (parámetro a evaluar o comparar)

case a : //cuando el parámetro tiene un valor a

Acciones a ejecutar;

case b: //cuando el parámetro tiene un valor b

Acciones a ejecutar

caso por default;

EJEMPLO

#include <iostream.h>

int main(){

int opcion;

cout<<"Menu de opciones"<<endl;

cout<<"1.Opcion1"<<endl;

cout<<"2.Opcion 2"<<endl;

cout<<"3.Opcion 3"<<endl;

cout<<"elige una opcion"<<endl;

cin>>opcion;

switch(opcion){
case 1:

cout<<"ejecucion 1"<<endl;

break;

case 2:

cout<<"ejecucion 2"<<endl;

break;

case 3:

cout<<"ejecucion 3"<<endl;

break;

default:

cout<<"es una opcion no valida"<<endl;

break;

cout<<"presiona enter para salir"<<endl;

cin.ignore();

cin.get();

return 0;

CICLOS REPETITIVOS

Sirve para hacer que una cierta parte de un programa se repita un cierto número de
veces o mientras se cumpla una condición (lo que llamamos un “bucle”). En C++
tenemos varias formas de conseguirlo.

Una de esas formas es el bucle o ciclo “for”.

for
Ésta es la orden que usaremos habitualmente para crear partes del programa que se
repitan un cierto número de veces.

El formato de “for” es:

for (valor Inicial; Condición Repetición; Incremento)

Sentencia;

Así, para contar del 1 al 10, tendríamos 1 como valor inicial, <=10 como condición
de repetición, y el incremento sería de 1 en 1. Por tanto, el programa quedaría:

#include <iostream.h>

main()

int contador;

for (contador=1; contador<=10; contador++)

cout<< contador;

WHILE

Otra forma de lograr que una estructura se repita si y solo si se cumple una condición
es el bucle o ciclo “while”.

Si queremos hacer que una sección de nuestro programa se repita mientras se

cumpla una cierta condición, usaremos la orden “while”. Esta orden tiene dos
formatos distintos, según comprobemos la condición al principio o al final.

En el primer caso, su sintaxis es

While (condición)

Sentencia;

Es decir, la sentencia se repetirá mientras la condición sea cierta. Si la condición es

falsa ya desde un principio, la sentencia no se ejecuta nunca. Si queremos que se
repita más de una sentencia, basta agruparlas entre { y }.

Un ejemplo que nos diga si cada número que tecleemos es positivo o negativo, y que
pare cuando tecleemos el número 0, podría ser:

#include <stdio.h>

#include <iostream.h>

Int main()

int numero;

cout<<”Teclea un número (0 para salir): ";

cin>>numero;

while (numero!=0)

if (numero > 0)

Cout<<”Es positivo\n”;

else

{
Cout<<”Es negativo\n”;

Cout<<"Teclea otro número (0 para salir): ";

Cin>>numero;

Otra de las formas para cumplir una sentencia con condición es DO – WHILE.

DO-WHILE

Cuando necesitamos que un ciclo se ejecute por lo menos una vez, es necesaria

esta sentencia. La forma general es:

do {

Acciones a ejecutar;

while(condicion a cumplir);

Pongamos como ejemplo lo siguiente.

Necesitamos que por lo menos una vez lea la opción que elige, y en caso de que

Elija una no disponible, en lugar de aparecer el mensaje “es una opción no válida” y
termine el programa, espere a que el usuario escoja una de la lista.

El programa de ejemplo:

#include <iostream.h>

int main()

int opcion;
do

cout<<"elije una opcion de la lista"<<endl;

cout<<"1.opcion

1"<<endl;

cout<<"2.opcion

2"<<endl;

cout<<"3.opcion

3"<<endl;

cin>>opcion;

}while((opcion<1)||(opcion>3));

cout<<"esta opcion si fue valida"<<endl;

cin.ignore();

cin.get();

return 0;

Nunca debemos olvidar el punto y coma después del while. Usada en

combinación

con el bloque switch, podemos tener muy buenos resultados y encontrar

varias

aplicaciones de ellos.

FUNCIONES
Una función es como un miniprograma dentro de un programa. Las funciones
contienen varias sentencias bajo un solo nombre, que un programa puede utilizar
una o más veces para ejecutar dichas sentencias. El objetivo de estas funciones es
ahorrar espacio y evitar repeticiones en un programa.

La estructura básica de una función en C++ es:

tipo_de_retorno nombreFunción (listaDeParámetros)

… // cuerpo de la función

return expresión

tipo_de_retorno: tipo de valor devuelto por la función o la palabra void si no

devuelve ningún valor

nombreFunción: identificador de la función.

listaDeParametros: lista de declaraciones de los parámetros de la función

separados por comas.

expresión: valor que devuelve la función

Una función puede retornar cualquier tipo de dato, tal como int, float, char, e incluso
tipos de datos definidos por el usuario (concepto que se clarificará con los objetos).
Si la función no devuelve ningún valor, el tipo de resultado será void, y no será
necesario un valor devuelto (es decir, utilizaremos return;).

La llamada a una función se puede hacer desde el main o desde otra función,
siempre y cuando esta esté referenciada arriba de su llamada (mas adelante
aclararemos este concepto).

Parámetros de una función

Existen dos métodos para pasar variable (parámetros) entre funciones. Una es por
valor y otra es por referencia. Claro esta que una función puede no tener parámetros,
y en este caso podemos colocar la palabra void o dejar vacíos los paréntesis.

Parámetros por valor

El paso de parámetros por valor (también llamado por copia) significa que cuando el
código llama la función, se crea una copia en memoria de los valores enviados, a los
cuales sólo puede acceder la función (ninguna otra podrá modificar esas “copias”). Si
la función cambia los valores que se le han enviado, los originales se conservarán sin
modificaciones, aun si usamos el mismo nombre para ambas variables (cosa que es
muy común).

Parámetros por referencia

Si queremos que una función modifique las variables originales de los parámetros
que les enviamos, utilizamos el paso de parámetros por referencia. En este tipo de
parámetros, no se realiza una copia, sino que se le envía a la función la dirección de
memoria de la variable. Es como si le colocáramos un sobrenombre a la variable,
que solo usaremos en esta función. El nombre que le coloquemos al recibir el
parámetro puede ser igual o distinto al enviado, similar que en los parámetros por
valor, pero con la diferencia que esta variable no será del mismo tipo que el enviado,
sino que será un puntero (más adelante veremos qué es un puntero, por ahora
diremos que es una referencia).

ARRREGLOS

Un arreglo es una colección ordenada de variables del mismo tipo. Las variables que
pertenecen a un arreglo se conocen por el nombre de elementos. El término
ordenado significa que en la colección hay un primer elemento, un segundo
elemento, un tercer elemento, y así sucesivamente. Además, los elementos pueden
a su vez organizarse en subgrupos llamadas dimensiones. El subgrupo más pequeño
posible se conoce como un arreglo de una dimensión. Un arreglo de dos
dimensiones se subdivide en arreglos de una dimensión. Un arreglo de tres
dimensiones se subdivide en arreglos de dos dimensiones los cuales a su vez se
dividen en arreglos de una dimensión. Un arreglo de cuatro dimensiones se
subdivide en arreglos de tres dimensiones los cuales a su vez se dividen en arreglos
de dos dimensiones los cuales a su vez se dividen en arreglos de una dimensión. La
misma idea se aplica en arreglos de más dimensiones.

En resumen, un arreglo:
· No es una variable; es un grupo de variables conocidas como elementos

· Cada elemento ocupa una posición dentro del grupo

· Todos los elementos son del mismo tipo

· El nombre del arreglo indica donde se localiza el grupo en la memoria de la

computadora

· Los arreglos se clasifican de acuerdo a las dimensiones que tengan

· Las dimensiones no tienen relación con el plano Cartesiano; nada que ver con

matemática

· Las dimensiones indican como están organizados los elementos dentro del grupo

· Los arreglos de dos dimensiones pueden visualizarse como tablas

· Los valores que se guarden en el arreglo se almacenan en los elementos ya que los

elementos son las variables

Para crear arreglos en C++, hay que indicar:

1. el tipo de los elementos (ejemplo, int, char, double, bool o un tipo definido por

el programador)

2. el nombre del arreglo

3. la cantidad de dimensiones y sus tamaños; cada dimensión comienza con el signo

[ seguido por el tamaño de la dimensión y termina con el signo ]

Para crear un arreglo de una dimensión, el formato es el siguiente:

<tipo de los elementos> <nombre del arreglo> [ <tamaño primera dimensión> ]

Para determinar la cantidad de elementos en un arreglo, hay que multiplicar el

tamaño de cada una de las dimensiones indicados en la declaración. El tamaño debe
ser un literal de tipo entero o el nombre de una constante de tipo entero.

Para nombrar un elemento en un arreglo hay que indicar el nombre del arreglo,
seguido de tantas parejas de corchetes [ ] como dimensiones declaradas. Dentro de
cada pareja de corchetes tiene que haber un índice. La combinación de los índices
indica la posición del elemento dentro del grupo. El valor mínimo para un índice es 0.
El valor máximo es uno menos que el tamaño de la dimensión correspondiente en la
declaración del arreglo.

Ejemplo #1. Arreglo de una dimensión

Declaración

int a[3]; // forma una secuencia de tres elementos

Nombre del grupo

Nombre de los elementos

a[0] → primer elemento

a[1] → segundo elemento

a[2] → tercer elemento

Ejemplo #2. Arreglo de dos dimensiones

Declaración

char m[2][3]; // forma una tabla de dos filas y tres columnas

// cada fila es un arreglo de una dimensión

// la declaración indica que hay dos arreglos de una dimensión

Nombre del grupo

m → indica la localización del grupo en la memoria

Nombre de las filas

m[0] → primera fila → indica la localización de la fila dentro del grupo

m[1] → segunda fila → indica la localización de la fila dentro del grupo

Nombre de los elementos

m[0][0] → primer elemento

m[0][1] → segundo elemento

m[0][2] → tercer elemento

m[1][0] → cuarto elemento

m[1][1] → quinto elemento

m[1][2] → sexto elemento

Ejemplo #3. Arreglo de tres dimensiones

Declaración

double w[2][2][3]; // forma dos tablas de dos filas y tres columnas

// cada fila es una secuencia de tres elementos

// cada fila es un arreglo de una dimensión

// la declaración indica que hay dos arreglos de dos dimensiones

// los arreglos de dos dimensiones tienen a su vez dos arreglos de una dimensión

Nombre del grupo

w → indica la localización del grupo en la memoria

Nombre de las tablas

w[0] → primera tabla → indica la localización de la tabla dentro del grupo

w[1] → segunda tabla→ indica la localización de la tabla dentro del grupo

Nombre de las filas

w[0][0] → primera tabla, primera fila

w[0][1] → primera tabla, segunda fila

w[1][0] → segunda tabla, primera fila

w[1][1] → segunda tabla, segunda fila

Nombre de los elementos

w[0][0][0] → primer elemento

w[0][0][1] → segundo elemento

w[0][0][2] → tercer elemento

w[0][1][0] → cuarto elemento

w[0][1][1] → quinto elemento

w[0][1][2] → sexto elemento

w[1][0][0] → séptimo elemento

w[1][0][1] → octavo elemento

w[1][0][2] → noveno elemento

w[1][1][0] → décimo elemento

w[1][1][1] → undécimo elemento

w[1][1][2] → duodécimo elemento

La siguiente figura muestra la división descrita el los comentarios al lado de la

declaración del arreglo de tres dimensiones llamado w (cantidad de elementos en el

arreglo w: 2x2x3=12).
 VECTORES

Un vector, también llamado array(arreglo) unidimensional, es una estructura de datos

que permite agrupar elementos del mismo tipo y almacenarlos en un solo bloque de
memoria juntos, uno despues de otro. A este grupo de elementos se les identifica por
un mismo nombre y la posición en la que se encuentran. La primera posición del
array es la posición 0.

Podríamos agrupar en un array una serie de elementos de tipo enteros, flotantes,

caracteres, objetos, etc.

Ejm:

1 int a[5];//Vector de 5 enteros

2 float b[5];//vector de 5 flotantes

3 Producto product[5];//vector de 5 objetos de tipo Producto

Podríamos también inicializar el vector en la declaración:

1 int a[] = {5,15,20,25,30};

2 float b[] = {10.5,20.5,30.5,12.5,50.5}

3 Producto product[] = {celular,calculadora,camara,ipod,usb}

Como hay 5 elementos en cada array, automáticamente se le asignará 5 espacios de

memoria a cada vector. Pero si trato de crear el vector de la forma int a[]; el
compilador mostrará un error, porque no indiqué el tamaño del vector ni tampoco
inicializé sus elementos.

Asigno valores a los elementos de un vector indicando su posición:

int a[4] = 30; // le asigno el valor 30 a la posición 4 del vector, es decir, al 5to
1
elemento.

product[2].setPrecio(300) // le asigno un precio de 300 al producto en la

2
posicion 2, o sea al tercer elemento.

Obviamente el método setPrecio() debe de estar implementado.

Para llenar, recorrer e imprimir un vector podemos utilizar un bucle for:

01 #include <iostream>

02 using namespace std;

03

04 int main()

05 {

06 int dim;

07 cout << "Ingresa la dimension del vector" << endl;

08 cin >> dim; // Supongamos que ingrese 10

09 int vector[dim]; // mi vector es de tamaño 10

10
11 for(int i=0;i < dim;i++){

12 vector[i] = i * 10;

13 cout << vector[i] << " ";

14 }

15

16 return 0;

17 }

La salida del programa mostrará: 0 10 20 30 40 50 60 70 80 90.

MATRICES

Una matriz es un vector de vectores o un también llamado array bidimensional. La

manera de declarar una matriz es c++ es similar a un vector:

1 int matriz[fils][cols];

int es el tipo de dato, matriz es el nombre de todo el conjunto de datos y debo de

especificar el numero de filas y columnas. Las matrices también pueden ser de
distintos tipos de datos como char, float, double,etc.

Las matrices en c++ se almacenan al igual que los vectores en posiciones

consecutivas de memoria. Usualmente uno se hace la idea que una matriz es como
un tablero. Pero internamente el manejo es como su definicion lo indica, un vector de
vectores, es decir, los vectores estan uno detras del otro juntos.

La forma de acceder a los elementos de la matriz es utilizando su nombre e

indicando los 2 subindices que van en los corchetes. Si Coloco int matriz[2][3]=10;
//estoy asignando al cuarto elemento de la tercera fila el valor 10. No olvidar que
tanto filas como columnas se enumeran a partir de 0.

Bueno y para recorrer una matriz podemos usar igualmente un bucle. En este caso 2
for

1 for(int i=0;i<fils;i++){

2 for(int j=0;j<cols;j++){
3 matriz[i][j] = i % j;

4 }

5}

ELEMENTO1 ELEMENTO1.1 ----------------- ELEMENTO1.n

ELEMENTO2 ELEMENTO2.1 ----------------- ELEMENTO2.n

ELEMENTO3 ELEMENTO3.1 ----------------- ELEMENTO3.n

------------------ -------------------- ----------------- ---------------------

ELEMENTOn ELEMENTOm.1 ----------------- ELEMENTOm.n

ARRAY UNIDIMENCIONAL ARRAY BIDIMENCIONAL

ARRAY MULTIDIMENCIONAL

MEMORIA DINAMICA

La memoria dinámica es un espacio de almacenamiento que se solicita en tiempo de

ejecución. De esa manera, a medida que el proceso va necesitando espacio para
más líneas, va solicitando más memoria al sistema operativo para guardarlas. El
medio para manejar la memoria que otorga el sistema operativo, es el puntero,
puesto que no podemos saber en tiempo de compilación dónde nos dará huecos el
sistema operativo (en la memoria de nuestro PC).

Hasta el momento no contamos con una forma de “administrar” la memoria utilizada

en nuestros programas, cuando declaramos una variable se asigna memoria para
almacenar datos dentro de ella, y ésta no se destruye hasta que termina el bloque en
el que fue declarada, se crea y se destruye cada que se pasa por ese bloque, quizá
puede parecer poco importante, pero cuando se cuentan con grandes cantidades de
datos, es necesario tener un mejor control de lo que se pone en memoria.

Una de las formas en que podemos asegurarnos que una variable declarada dentro
de un bloque no sea borrada al término de éste, es mediante la utilización del
calificador static. De ésta manera, la variable perdurará hasta el término de todo el
programa.

static tipo_variable mi_variable;

Pero en algunos casos esto nos será insuficiente, vamos a necesitar “destruir”
variables antes de terminar el programa, para hacer esto contamos con los
operadores new y delete.

Se puede utilizar el operador new para crear cualquier tipo de variables, en todos los
casos devuelve un puntero a la variable creada. En el momento en que se quiera
borrar esta variable deberemos utilizar el operador delete, todas las variables
creadas mediante el operador new deben de ser borradas con el otro operador.

EJEMPLO:
 PUNTEROS

Un apuntador se define como una variable que contiene una dirección de memoria.
Para declarar un apuntador se hace uso del operador desreferencia o indirección (*),
no se debe confundir con la multiplicación.

Al declarar un apuntador debemos de hacerlo de la siguiente forma:

tipo *nombre;

int *MiApuntador;

Ya habíamos dicho anteriormente que el nombre de un arreglo apunta al primer

elemento de éste, es decir contiene la dirección en memoria del elemento 0.

Tomando en cuenta esto, podemos ver que si hacemos:

int arreglo[10];

int *apuntador;

apuntador = arreglo;
sucede que, pasamos la dirección del primer elemento del arreglo a la
variable“apuntador” que está determinada para almacenar una dirección de memoria.

El uso de los apuntadores sirve para hacer uso de una variable con la cual no se
tiene contacto directo, por medio del operador desreferencia. Por ejemplo, podemos
asignar un nuevo valor a esta variable referenciada.

*MiApuntador=9;

por medio de la instrucción anterior se está asignando un valor de 9 a la variable que

apunta “MiApuntador”. Es decir que “MiVariable” ahora contiene un 9.

Como podemos ver podemos usar un apuntador para asignar cantidades (o lo que
sea) a la variable referenciada ya sea por instrucción o por medio del teclado.
En la última instrucción cout se imprime el valor de “lo que apunta ‘apuntador’ ”.

ARCHIVOS
Para empezar con el manejo de archivos es necesario recordar el concepto de flujo,
el cual se define como un dispositivo que consume o produce información. En
nuestros programas hechos hasta el momento hemos utilizado los flujos estándar
cin y cout el resto de los flujos que se deseen deberán ser creados por el
programador. Todos los flujos se comportan de forma análoga,
Independientemente del dispositivo que se trate.
Para poder usar un flujo estándar basta con incluir la biblioteca iostream.h como lo
hemos hecho hasta ahora. Cuando decidimos utilizar la función cin.get() no
sabíamos exactamente el porque de la utilización del punto(.), ahora que hemos visto
un poco el concepto de estructura podemos decir que se trata de la invocación a una
función miembro del flujo cin. Sí, el flujo es un objeto, viéndolo desde la perspectiva
de las estructuras y no precisamente de las clases como debería de ser, se trata de
un tipo de dato que contiene variables y funciones que pueden ser invocadas.
Las estructuras (en realidad clases) para la entrada y salida de datos tienen un orden
jerárquico, en ellas existe la herencia que básicamente consiste en que una de orden
inferior obtiene las mismas variables y funciones que la de orden mayor, además
deque puede agregar más.

Para poder trabajar los ficheros como flujos es necesario incluir la librería
fstream.h, y según la utilización que queramos dar a este fichero (lectura o
escritura) deberemos declarar el tipo de flujo.

Para crear un archivo de salida declaramos una variable de tipo ofstream, el cualya
está declarado dentro de nuestra librería.

#include<fstream.h>

int main()
{
ofstream archivo;
archivo.open("miarchivo.txt");
archivo<<"hola desde este archivo\n";
archivo<<"ya he escrito algo\n";
archivo.close();
}

Aquí declaramos a “archivo” como variable tipo ofstream, y posteriormente utilizamos

su función miembro open para asociarla a un archivo, se pude asociar directamente
en la declaración de la siguiente manera:

ofstream archivo(“miarchivo.txt”);

Tanto la primera como la segunda forma admiten un segundo argumento que

especifica el modo de apertura de un archivo. Los modos disponibles se muestran en
la siguiente tabla y pueden ser utilizados incluyendo la librería iostream.h.
Con el archivo creado en el ejemplo anterior utilizaremos el siguiente programa para
escribir al final de él.

#include<iostream.h>
#include<fstream.h>
int main(){
ofstream archivo("miarchivo.txt", ios::app);
archivo<<"hola desde este archivo de nuevo\n";
archivo<<"ya he escrito algo de nuevo\n";
archivo.close();
}

El método para abrir un archivo en modo lectura es muy similar, pero en este caso
utilizaremos ifstream. Para tener el control del fichero, aparte de conocer los
modos de apertura de un archivo, debemos de conocer el delimitador, así como en
las cadenas existe el carácter de fin de cadena('\0'), en los archivos está el fin de
archivo (EOF).

ESQUEMA
 PROGRAMACION
BASICA

UTILIZA

LENGUAJE DE FUNCION
SW
PROGRAMACI ES
APOYA CREAR
ON C++

COMO
DEV C++
HERRAMIENTAS
TURBO C SINTAXI ARREGLOS
S
VISUAL C+ ESTRUCTURA
+ S DE DATOS PUNTEROS
TIENE
TIPOS DE
ESTRUCTURA
DATOS ESTRUCTURA
DIRECTIVAS DE PRINCIPAL
S DE
PROCESADOR CICLOS
CONTROL
REPETITIVOS

NUMERICO
MAIN VOID S CONDICIONALE IF, IF ELSE, SWITCH
CARACTERE S
# INCLUDES S
INT, FLOAT,
DOUBLE

CHAR
 FOR WHILE DO WHILE

WHILE {

FOR
SENTENCIA:
DE= 1 {

HASTA=10 NUM=NUM+1;

AUMENTO=1 EN 1 } }

FUNCIÓN

ES UN MINIPROGRAMA
DENTRO DE UN
PROGRAMA

CONTIENE

VARIAS SENTENCIAS
CON UN SOLO NOMBRE,
QUE UN PROGRAMA
PUEDE UTILIZAR PARA
EJECUTAR DICHAS
SENTENCIAS

SIN PARAMETROS
PARAMETROS

En este caso se puede

utilizar un “VOID” o
dejar lo paréntesis en
REFERENCIA valor blanco
Si queremos que una función
modifique las variables
originales de los parámetros
que les enviamos, utilizamos
el paso de parámetros por
referencia. En este tipo de
parámetros, no se realiza
una copia, sino que se le
envía a la función la
dirección de memoria de la
variable. Es como si le
colocáramos un sobrenombre
a la variable, que solo
usaremos en esta función. El
nombre que le coloquemos al
recibir el parámetro puede
ser igual o distinto al
enviado, similar que en los
parámetros por valor, pero
El paso de parámetros por
valor (también llamado por
copia) significa que cuando
el código llama la función, se
crea una copia en memoria
de los valores enviados, a los
cuales sólo puede acceder la
función (ninguna otra podrá
modificar esas “copias”). Si
la función cambia los valores
que se le han enviado, los
originales se conservarán sin
modificaciones, aun si
usamos el mismo nombre
para ambas variables (cosa
que es muy común).

ARREGLOS

SECUENCIA DE
OBJETOS DEL MISMO
TIPOS

COMO

ENTEROS,
CARACTERES,
FLOTANTES Y TIPOS
DE DATOS ELEGIDOS
POR EL USUARIO

INICIALIZACIÓN

char a[5]={68, 97, 118, 105, 100};

char b[]={68, 97, 118, 105, 100};

char c[]={‘D’, ‘a’, ‘v’, ‘i’, ‘d’};

CADENAS DE TEXTO ARREGLOS MULTIDIMENCIONALES

Los arreglos
Una cadena de texto es
multidimensionales son
un conjunto de caracteres
aquello que, como su
consecutivos que pueden
nombre lo indica, tienen
ser manejados como
más de una dimensión, y
palabras o frases en ves
por lo tanto más de un
de cómo caracteres
índice. Los arreglos
separados.
multidimensionales más
utilizados son los
bidimensionales o mejor
llamados matrices, sin de
este modo excluir el
posible uso de tres o
cuatro dimensiones en un
arreglo.

MEMORIA
ESTATICA DINAMICA

HACE
REFERENCIA A:
Lista de nodos (es uno de los elementos
de una lista enlazada, de un árbol o de
Arreglos, vectores o un grafo. Cada nodo será una estructura
o registro que dispondrá de varios
matrices campos , a partir de esa referencia,
debe poder accederse a otros nodos de
la estructura. Los nodos son
herramientas esenciales para la
construcción de estructuras de datos
El programador en este tipo de dinámicas.
memoria define el tamaño
máximo del vector y en la
ejecución del programa cada )
uno de sus elementos va a
ocupar un espacio en memoria.
El programador en este tipo de
memoria no define el tamaño
No se podrá hacer máximo de memoria en la
uso de espacios ejecución del programa se van
creando nodos dependiendo
extra, se utilizan de la necesidad y cada uno de
solamente los sus elementos va a ocupar un
espacio en memoria.
1 2reservados.
3 4 8 6
 0 1 2 3
SE PUEDEN ELIMINAR
NO PUEDEN ELIMINAR ELEMENTOS PARA
ELEMENTOS PARA RECUPERAR ESPACIOS
RECUPERAR ESPACIOS DE MEMORIA
DE MEMORIA

PUNTEROS

ARCHIVOS

SE PUEDE TRABAJAR CON LIBRERIAS

OFSTREAM FSTREAM

LECTURA O ESCRITURA

MODO DE APERTURA

IOS::IN
IOS::APP IOS::OUT IOS:: TRUNC IOS::BINARY
OPERACION
ES DE
Operacion Crea un
LECTURA.
es de archivo, si ESTA ES LA
escritura. existe uno EL
OPERACIÓ OPCION
Esta es la con el POR ARCHIVO
N DE opción por
mismo DEFECTO SE ABRE
AÑADIDUR
IOS::NOREPLACE defecto IOS::NOCREATE IOS::ATE
PARA EN MODO
A nombre lo
para OBJETOS DE BINARIO.
objetos de borra. LA CLASE
la clase IFSTREAM.H
ofstream.
CREA UN
ARCHIVO, SI COLOCA EL
EXISTE UNO SI EL ARCHIVO
APUNTADOR
CON EL MISMO NO EXISTE SE
NOMBRE LA DEL ARCHIVO
SUSPENDE LA
OPERACIÓN SE AL FINAL DEL
OPERACIÓN.
SUSPENDE. MISMO.

REFLEXION DEL ESTUDIANTE

A lo largo de este semestre hemos visto detalladamente la forma de programar en

c++ con la tutoría de la profesora Edith Cortés. El grupo en general ha tenido que
llevar clase por clase un seguimiento en portafolios de los temas tratados en cada
una de ellas estos, temas que dan paso a soluciones de problemas diarias que y se
efectúa su solución por medio de programas (por ejemplo la administración de una
tienda). Este portafolio contiene una compilación de todos aquellos temas tratados
(portafolio final) para dar una finalización a programación y por tanto al semestre,
no sobra dar el agradecimiento a la profesora Edith por acompañarnos el proceso de
aprendizaje.