SINTAXIS DE FILAS Y COLAS

SACAR COLA Y COLA VACIA

//Saca datos de la colaint sacarcola()
{
if(!colavacia())
{
int dato=cola[0];
tope--;
for (int x=0;
x
{
cola[x]=cola[x+1];
}
return(dato);
}
else
{
cout<<"Error, cola vacia";

}
}

//Verifica que la cola no este vaciaint colavacia()

{
if (tope2<0)>
{
return (1);
}
else
{
return (0);
}
}


METER COLA Y COLA LLENA

//Pilasvoid meterpila(int numero)

{
if (!pilallena())
{
pila[tope]=numero;
tope++;
}
else
{
cout<<"Error, pila llena";
}
}

//verificar que no este llena la pila para poder meter datosint pilallena()
{
if (tope==10)
{
return (1);
}
else
{
return (0);
}
}

SACARPILA Y PILA VACIA

int sacarpila()
{
if (!pilavacia())
{
tope--;
int dato=pila[tope];
return(dato);
}
else
{
return(-1);
}
}

int pilavacia()
{
if (tope<0)>
{
return (1);
}
else
{
return (0);
}
}

ESTRUCTURA DE ARCHIVOS DE TEXTO

//***********************************************
// archiv01.cpp
// Demuestra la escritura básica en archivo
// ©1999, Jaime Virgilio Gómez Negrete
//***********************************************
#include
int main()
{
ofstream archivo; // declaramos archivo como un objeto que permite escribir a un archivo

archivo.open("datos.txt"); //le asignamos el nombre del archivo a escribir y lo abrimos

//Escribimos en el archivo utilizando el objeto
archivo << "lo que vamos a escribir";
archivo << "Primera línea de texto" << endl;
archivo << "Segunda línea de texto" << endl;
archivo << "Última línea de texto" << endl;
//se cierra el archivo
archivo.close();
return 0;
}

LEER ARCHIVOS DE TEXTO

Dividiremos este tema en dos

• Leer Archivos de Texto
• Escritura deArchivosdeText

// archiv03.cpp

// Demuestra operaciones de lectura de archivos

// 1999, Jaime Virgilio Gómez Negrete

//***********************************************

#include

int main()

{

//objeto que permite leer el archivoifstream archivo("archivo.txt", ios::noreplace);

//variable en donde se coloca la linea leida del archivochar linea[128];if(archivo.fail())

cerr << "Error al abrir el archivo" <<>

//mientras no sea fin del archivo{//lee la linea del archivo, la guarda en la variable linea.archivo.getline(linea, sizeof(linea)); cout <<>

//muestra en pantalla lo que se ha leido.

}

archivo.close();

return 0;

}

LISTAS ENLAZADAS

En esta tema aprenderemos a crar listas enlazadas y para esto debemos de crear un nodo

La cantidad de datos se ajusta a la cantidad de memoria.

Estrutura


struct a
{
int num
drar letra
}

CREAR NODO

1. crear nuevo nodo
2. siguiente d nuevo es inicio
3. ponrle valor al número
4. mover inicio alnuevo

ejemplo

void insertar_inicio(int num)
{
nodo *nuevo;
nuevo = new (nodo);
nuevo->sig = inicio;
nuevo->dato = num;
inicio = nuevo;
}

CREAR LISTA

1. crar nuevo nodo
2. meter dato alnuevo
3. final esigual a incio
4. final es igual a nuevo
5. inicio es igual a nuevo
6. siguiente de final es NULL

Ejemplo

void crear_lista (int num)

{
nodo *nuevo;
nuevo = new(nodo);
nuevo->dato = num;
inicio=final=nuevo;
final->sig = NULL;
}


INSERTAR AL FINAL

1. crear nuevo nodo
2. siguiente al final es el nuevo
3. siguiente de nuevo apunta a nada (null)
4. Meter dato al nuevo
5. mover final al nuevo

Ejemplo

void insertar_final (int num)
{
nodo *nuevo;
nuevo = new (nodo);
final->sig = nuevo;
nuevo->sig = NULL;
nuevo->dato = num;
final = nuevo;
}

SINTAXIS BASICA

A continuación presentaremos la sintaxis genral de C++ mostrada como si estuvieramos elaborando un programa, la sintaxis que contiene es de:

• librerias
• tipos de datos
• declarar variables
• declarar constantes
• asignación
• salidas
• entradas

Sintaxis general:

#include
#include “librerias propias”
declaración_de_prototipos
funciones ()
void main() // función principal
{
}

Tipos de Datos:

int : números enteros generalmente entre el -32768 al 32768.
float: números con punto flotante generalmente de 10-38 a 1038.
char: carácter – un solo byte
short: entero corto.
long: entero largo.
double: punto flotante de doble precisión.

Declaracion de Variable:

tipo nombre_de_variable

Declaración de Constantes:

#define constante [valor numérico]
const nombre [valor numérico]

Asignación:

valor = (expresión)
++valor preincremento. --valor predecremento.
valor++ posincremento. valor-- posdecremento.
valor+=x valor-=10

Salida:

printf(“Mensaje”);
printf(“ %tipo_var1 Mensaje %tipo_var2”, var1, var2);
%s Cadena de caracteres.
%c Carácter.
%d Entero.
%f Decimal.

Entrada:

scanf(“% tipo_var”, &variable);

DECLARACION DE VARIABLES

En realidad ya hemos visto la mecánica de la declaración de variables, al mostrar la sintaxis de cada tipo.
El sistema es siempre el mismo, primero se especifica el tipo y a continuación una lista de variables.
En realidad, la declaración de variables puede considerarse como una sentencia. Desde este punto de vista, la declaración terminará con un punto y coma ";".

Sintaxis: ;

Existe una particularidad relacionada con el punto en que se declaren las variables.
Las variables declaradas dentro de una función sólo serán accesibles desde el interior de esa función, y se conocen como variables locales de la función.
Las variables declaradas fuera de las funciones, serán accesibles desde todas las funciones, y son conocidas como variables globales.

También es posible inicializar las variables dentro de la misma declaración.

int X= 5

declaramos la variable "X"y le asignamos el valor de 5

FUNCIONES

Declaración y Definición

Las funciones son un conjunto de instrucciones que realizan una tarea específica.
En general toman unos valores de entrada, llamados parámetros y proporcionan un valor de salida o valor de retorno; aunque tanto uno como el otro pueden no existir.
Al igual que con las variables, las funciones pueden declararse y definirse.

Un ejemplo tipico para una función podría ser la que, dados dos números a y b, nos indique si a es menor que b.

En este caso los parametros serían a y b y valor de retorno verdadero o falso, dependiendo de si a es menos que b o no.

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

DEFINICIÓN DE UNA FUNCIÓN

En general, la definición de una función se compone de las siguientes secciones, aunque pueden complicarse en ciertos casos:

[extern static] tipoRetorno nombreFuncion (listaDeParámetros)

{
cuerpoDeLaFuncion
}

Veamos paso a paso cada una de las secciones:
Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser "extern" o "static". Si no se especifica es "extern". link al tema de almacenamiento
El tipo del valor de retorno, que puede ser "void", si no necesitamos valor de retorno. Si no se establece, por defecto será "int". Generalmente, no se suele omitir.

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

DECLARACION DE UNA FUNCION

Un elemento que se usa muy frecuentemente son los prototipos o declaración de función. Una función prototipo consiste en una definición de la función con un sin cuerpo y terminado con un ";".

La estructura de un prototipo es:

tipoRetorno nombreFuncion (listaDeParámetros);

Sirve para indicar al compilador los tipos de retorno y los de los parámetros de una función, de modo que compruebe si son del tipo correcto cada vez que se use esta función dentro del programa, o para hacer las conversiones de tipo cuando sea necesario.
En C++ es obligatorio el uso funciones prototipo.

NOTA: La diferencia entre una declaración y una definición es que la definición posee un cuerpo de función.

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

ESTRUCTURA DE UN PROGRAMA

La estructura de un programa en C++ es:.

[directivas del pre-procesador: includes y defines]

[declaración de variables globales]

[prototipos de funciones]

funcion main

[definiciones de funciones]

Los programas complejos se escriben normalmente usando varios ficheros fuente. Estos ficheros se compilan separadamente y se enlazan juntos.
Esto es una gran ventaja durante el desarrollo y depuración de grandes programas, ya que las modificaciones en un fichero fuente sólo nos obligarán a compilar ese fichero fuente, y no el resto, con el consiguiente ahorro de tiempo.
La definición de las funciones puede hacerse dentro de los ficheros fuente o enlazarse desde librerías precompiladas.