Tutorial de C

Tutorial de C/C++, programar paso a paso, para Linux,
Windows y Mac
LinuxParty se complace en compartir con vosotros este extraordinario Tutorial de C/C++
que hemos tardado ms de un ao en terminar, este tutorial naci a partir de una sugerencia
realizada en una encuesta [Link ya no disponible], y este es el fruto de un ao largo de
trabajo. No ha sido fcil, ni sencillo, pero por fin este documento ve la luz.
Como IDE (Entorno de Desarrollo Integrado) para realizar el curso de programacin, te
recomendamos encarecidamente Geany, para el desarrollo, que tendrs para Linux y
Windows.
Este es el ndice principal del curso:
01.- El compilador GNU cc, (gcc o g++) Qu es, y cmo se utiliza.
02.- Acerca de C/C++
03.- Compiladores e IDEs para C/C++
04.- Estructura de un programa en C/C++ e Introduccin al cdigo fuente.
05.- Introduccin a las sentencias condicionales en C/C++.
06.- Funciones en C/C++.
07.- Matrices en C/C++
08.- Strings, cadenas en C/C++
09.- Punteros en C/C++
10.- Estructuras "Structures" en C/C++
11.- Unions en C/C++
12.- Ficheros en C/++
13.- Programacin Orientada a Objetos en C/C++.
14.- Herencia en C/C++.
15.- Sobrecarga de Operadores en C/C++.
16.- Polimorfismo en C/C++
Recomendamos encarecidamente usar el compilador GCC tanto en Windows como en Mac.
Por supuesto en Linux se utiizar siempre gcc para compilar los programas en C y g++ para
C++, si lo desea puede utilizar en todo momento g++ que en Ubuntu lo han llamado g
Tutorial de C++, entrega N 1

Vamos a hacer una "pequea" entrega de un tutorial de C++, que ya
prometimos hace algn tiempo, no vamos a reinventar la rueda. Quien quiera
aprenderlo, bienvenido, creo que el conocimiento por saber cmo se
programan/desarrollan las cosas son fundamentales para comprender su
funcionamiento, muchos Administradores de Sistemas, como alguno de
nuestros editores previamente han sido programadores, y eso ayuda a
"adivinar" cual ser la salida, incluso antes de ejecutarse.
Tambin es fundamental hacerlo desde la lnea de comandos, por lo que por

supuesto, lo haremos slo en Linux, y utilizaremos el compilador gcc, as, lo
primero que debemos estudiar y comprender es cmo funciona el compilador
gcc, para poder posteriormente desarrollar las cosas y poder compilarlo.
El compilador GCC
Sintaxis.
Ejemplos.
Sufijos en nombres de archivo.
Opciones.
Etapas de compilacin.
1. Preprocesado.
2. Compilacin.
3. Ensamblado.
4. Enlazado.
Todo en un solo paso
Enlace dinmico y esttico.
Resumen.
Informacin adicional.
GCC es un compilador integrado del proyecto GNU para C, C++, Objective C y Fortran; es
capaz de recibir un programa fuente en cualquiera de estos lenguajes y generar un programa
ejecutable binario en el lenguaje de la mquina donde ha de correr.
La sigla GCC significa "GNU Compiler Collection". Originalmente significaba "GNU C
Compiler"; todava se usa GCC para designar una compilacin en C. G++ refiere a una
compilacin en C++.
Sintaxis.
gcc [ opcin | archivo ] ...
g++ [ opcin | archivo ] ...
Las opciones van precedidas de un guin, como es habitual en UNIX, pero las opciones en
s pueden tener varias letras; no pueden agruparse varias opciones tras un mismo guin.
Algunas opciones requieren despus un nombre de archivo o directorio, otras no.
Finalmente, pueden darse varios nombres de archivo a incluir en el proceso de
compilacin.
Ejemplos.
gcc hola.c
compila el programa en C hola.c, gener un archivo ejecutable a.out.
gcc -o hola hola.c
compila el programa en C hola.c, gener un archivo ejecutable hola.
g++ -o hola hola.cpp

compila el programa en C++ hola.c, gener un archivo ejecutable hola.
gcc -c hola.c
no genera el ejecutable, sino el cdigo objeto, en el archivo hola.o. Si no s
indica un nombre para el archivo objeto, usa el nombre del archivo en C y le
cambia la extensin por .o.
gcc -c -o objeto.o hola.c
genera el cdigo objeto indicando el nombre de archivo.
g++ -c hola.cpp
igual para un programa en C++.
g++ -o ~/bin/hola hola.cpp
genera el ejecutable hola en el subdirectorio bin del directorio propio del
usuario.
g++ -L/lib -L/usr/lib hola.cpp
indica dos directorios donde han de buscarse bibliotecas. La opcin -L debe
repetirse para cada directorio de bsqueda de bibliotecas.
g++ -I/usr/include hola.cpp
indica un directorio para buscar archivos de encabezado (de extensin .h).
Sufijos en nombres de archivo.

Son habituales las siguientes extensiones o sufijos de los nombres de archivo:
.c
fuente en C
.C .cc .cpp .c+

+ .cp .cxx
fuente en C++; se recomienda .cpp
.m
fuente en Objective-C
.i
C preprocesado
.ii
C++ preprocesdo
.s
fuente en lenguaje ensamblador
.o
cdigo objeto
.h
archivo para preprocesador (encabezados), no suele figurar en

la linea de comando de gcc
Opciones.
-c
realiza preprocesamiento y compilacin, obteniento el archivo en cdigo
objeto; no realiza el enlazado.
-E
realiza solamente el preprocesamiento, enviando el resultado a la salida
estndar.
-o archivo
indica el nombre del archivo de salida, cualesquiera sean las etapas cumplidas.
-Iruta
especifica la ruta hacia el directorio donde se encuentran los archivos
marcados para incluir en el programa fuente. No lleva espacio entre la I y la
ruta, as: -I/usr/include
-L
especifica la ruta hacia el directorio donde se encuentran los archivos de
biblioteca con el cdigo objeto de las funciones referenciadas en el programa
fuente. No lleva espacio entre la L y la ruta, as: -L/usr/lib
-Wall
muestra todos los mensajes de error y advertencia del compilador, incluso
algunos cuestionables pero en definitiva fciles de evitar escribiendo el cdigo
con cuidado.
-g
incluye en el ejecutable generado la informacin necesaria para poder rastrear
los errores usando un depurador, tal como GDB (GNU Debugger).
-v
muestra los comandos ejecutados en cada etapa de compilacin y la versin
del compilador. Es un informe muy detallado.
Etapas de compilacin.
El proceso de compilacin involucra cuatro etapas sucesivas:
preprocesamiento, compilacin, ensamblado y enlazado. Para pasar de un
programa fuente escrito por un humano a un archivo ejecutable es necesario
realizar estas cuatro etapas en forma sucesiva. Los comandos gcc y g++ son
capaces de realizar todo el proceso de una sola vez.
1. Preprocesado.
En esta etapa se interpretan las directivas al preprocesador. Entre otras cosas,
las variables inicializadas con #define son sustitudas en el cdigo por su valor
en todos los lugares donde aparece su nombre.
Usaremos como ejemplo este sencillo programa de prueba, circulo.c:
/* Circulo.c: calcula el rea de un crculo.

Ejemplo para mostrar etapas de compilacin.
*/
#define PI 3.1416
main()
{
float area, radio;
radio = 10;
area = PI * (radio * radio);
printf("Circulo. ");
printf("%s%f ", "Area de circulo radio 10: ", area);
}
El preprocesado puede pedirse con cualquiera de los siguientes comandos; cpp alude
especficamente al preprocesador.
$ gcc -E circulo.c > circulo.pp
$ cpp circulo.c > circulo.pp
Examinando circulo.pp
$ more circulo.pp
puede verse que la variable PI ha sido sustituda por su valor, 3.1416, tal como haba sido
fijado en la sentencia #define.
2. Compilacin.
La compilacin transforma el cdigo C en el lenguaje ensamblador propio del
procesador de nuestra mquina.
$ gcc -S circulo.c
realiza las dos primeras etapas creando el archivo circulo.s; examinndolo con
$ more circulo.s
puede verse el programa en lenguaje ensamblador.
3. Ensamblado.
El ensamblado transforma el programa escrito en lenguaje ensamblador a
cdigo objeto, un archivo binario en lenguaje de mquina ejecutable por el
procesador.
El ensamblador se denomina as:

$ as -o circulo.o circulo.s
crea el archivo en cdigo objeto circulo.o a partir del archivo en lenguaje ensamblador
circulo.s. No es frecuente realizar slo el ensamblado; lo usual es realizar todas las etapas
anteriores hasta obtener el cdigo objeto as:
$ gcc -c circulo.c
donde se crea el archivo circulo.o a partir de circulo.c. Puede verificarse el tipo de archivo
usando el comando
$ file circulo.o
circulo.o: ELF 32-bit LSB relocatable, Intel 80386, version 1, not stripped
En los programas extensos, donde se escriben muchos archivos fuente en cdigo C, es muy
frecuente usar gcc o g++ con la opcin -c para compilar cada archivo fuente por separado, y
luego enlazar todos los mdulos objeto creados. Estas operaciones se automatizan
colocndolas en un archivo llamado makefile, interpretable por el comando make, quien se
ocupa de realizar las actualizaciones mnimas necesarias toda vez que se modifica alguna
porcin de cdigo en cualquiera de los archivos fuente.
4. Enlazado
Las funciones de C/C++ includas en nuestro cdigo, tal como printf() en el
ejemplo, se encuentran ya compiladas y ensambladas en bibliotecas existentes
en el sistema. Es preciso incorporar de algn modo el cdigo binario de estas
funciones a nuestro ejecutable. En esto consiste la etapa de enlace, donde se
renen uno o ms mdulos en cdigo objeto con el cdigo existente en las
bibliotecas.
El enlazador se denomina ld. El comando para enlazar

$ ld -o circulo circulo.o -lc
ld: warning: cannot find entry symbol _start; defaulting to 08048184
da este error por falta de referencias. Es necesario escribir algo como
$ ld -o circulo /usr/lib/gcc-lib/i386-linux/2.95.2/collect2 -m elf_i386 -dynamic-linker
/lib/ld-linux.so.2 -o circulo /usr/lib/crt1.o /usr/lib/crti.o /usr/lib/gcc-lib/i386linux/2.95.2/crtbegin.o -L/usr/lib/gcc-lib/i386-linux/2.95.2 circulo.o -lgcc -lc -lgcc
/usr/lib/gcc-lib/i386-linux/2.95.2/crtend.o /usr/lib/crtn.o
para obtener un ejecutable.
El uso directo del enlazador ld es muy poco frecuente. En su lugar suele proveerse a gcc los
cdigos objeto directamente:
$ gcc -o circulo circulo.o
crea el ejecutable circulo, que invocado por su nombre
$ ./circulo
Circulo.
Area de circulo radio 10: 314.160004
da el resultado mostrado.
Todo en un solo paso.
En programa con un nico archivo fuente todo el proceso anterior puede
hacerse en un solo paso:
$ gcc -o circulo circulo.c
No se crea el archivo circulo.o; el cdigo objeto intermedio se crea y destruye

sin verlo el operador, pero el programa ejecutable aparece all y funciona.
Es instructivo usar la opcin -v de gcc para obtener un informe detallado de todos los pasos
de compilacin:
$ gcc -v -o circulo circulo.c
Enlace dinmico y esttico.

Existen dos modos de realizar el enlace:
- esttico: los binarios de las funciones se incorporan al cdigo binario de
nuestro ejecutable.
- dinmico: el cdigo de las funciones permanece en la biblioteca; nuestro
ejecutable cargar en memoria la biblioteca y ejecutar la parte de cdigo
correspondiente en el momento de correr el programa.
El enlazado dinmico permite crear un ejecutable ms chico, pero requiere
disponible el acceso a las bibliotecas en el momento de correr el programa. El
enlazado esttico crea un programa autnomo, pero al precio de agrandar el
tamao del ejecutable binario.
Ejemplo de enlazado esttico:

$ gcc -static -o circulo circulo.c
$ ls -l circulo
-rwxr-xr-x 1 victor victor 237321 ago 4 11:24 circulo
Si no se especifica -static el enlazado es dinmico por defecto.
Ejemplo de enlazado dinmico:
$ ls -l circulo
-rwxr-xr-x 1 victor victor
4828 ago 4 11:26 circulo
Notar la diferencia en tamao del ejecutable compilado esttica o dinmicamente. Los
valores pueden diferir en algo de los mostrados; dependen de la plataforma y la versin del
compilador.
El comando ldd muestra las dependencias de bibliotecas compartidas que tiene un
ejecutable:
$ ldd circulo
libc.so.6 => /lib/libc.so.6 (0x40017000)
/lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)
$ gcc -static -o circulo circulo.c
$ ldd circulo
statically linked (ELF)
La compilacin esttica no muestra ninguna dependencia de biblioteca.
Resumen.
Para producir un ejecutable con fuente de un solo archivo:
Para crear un mdulo objeto, con el mismo nombre del fuente y extensin .o:
$ gcc -c circulo.c
Para enlazar un mdulos objeto:
$ gcc -o circulo circulo.o
Para enlazar los mdulos objeto verde.o, azul.o, rojo.o, ya compilados
separadamente, en el archivo ejecutable colores:
$ gcc -o colores verde.o azul.o rojo.o
Informacin adicional.
Sobre GCC: man gcc info gcc
pgina info de GCC, ms completa y
actualizada que la pgina man.
Sobre el depurador: man gdb info gdb
Tutorial de C++, Entrega N 2

Bien, no se puede iniciar a explicar algo, sin conocer algunas cosas
elementales y esenciales de ellas, por eso vamos a incorporar la siguiente
tabla (que la puedes leer por completo al continuar leyendo el artculo) Si me
hubiera equivocado les invito a que me corrijan en los comentarios --yo soy
humano--, si alguien tambin quisiera ampliar el comentario, lo puede hacer
aadiendo cualquier comentario.
Aprender C / C ++ Paso a paso
01. Paso a paso de C / C ++ --- Introduccin
Contenido
I. Acerca de C
1.
2.
3.
4.
5.
Qu es C?
Desarrollo de lenguaje C
C como lenguaje de propsito general
Historia de C
Caractersticas de C
II. Fundamentos de la programacin

1. Componentes de un programa
2.
3.
4.
5.
6.
7.
8.
9.
Constantes
Tipos de datos
Tipo de datos numricos
Tipo de datos - No numrico
Tipo de datos - Entero
Tipo de datos - real
Tipo de datos - lgicos
Tipo de datos - Enumerado
Introduccin al lenguaje y las expresiones

Qu es C?
C es un lenguaje de programacin basado en el compilador, es decir no es
interpretado como el Basic (que no es ningn inconveniente, y tampoco es
malo), soporta tanto expresiones y declaraciones de alto nivel como de bajo
nivel para interactuar directamente con el hardware.
Desarrollo del lenguaje C

El lenguaje de programacin C evolucion a partir de una sucesin de
lenguajes de programacin desarrollados en los Laboratorios Bell en 1970. No
fue sino hasta finales de 1970 cuando este lenguaje de programacin comenz
a ganar popularidad y apoyo. Esto se deba a que hasta ese momento los
compiladores de C no estaban disponibles para uso comercial fuera de los
Laboratorios Bell.
El lenguaje C fue el resultado del trabajo de Dennis Ritchie en un proyecto en
los Laboratorios Bell, para inventar un lenguaje adecuado con suficiente alto
nivel para escribir un sistema operativo que gestionara los dispositivos de
entrada y salida de un equipo, asignar su almacenamiento y los horarios de
funcionamiento de otros programas.
El sistema operativo UNIX est escrito en el lenguaje C. Por lo tanto el sistema
operativo Unix tiene C como su lenguaje de programacin estndar. De hecho
ms del 90% del sistema operativo en s mismo est escrito en el lenguaje C.
As que originalmente el lenguaje C fue diseado e implementado en el sistema
operativo Unix.
C como un lenguaje de propsito general

C es un lenguaje de alto nivel, proceduramental y estructurado, y de uso
general el lenguaje de programacin C se asemeja a algunos otros lenguajes

de alto nivel como Fortran, Pascal, y PL / 1. Sin embargo, no podemos llamar el
lenguaje C como "puramente lenguaje de alto nivel".
C se encuentra en algn lugar entre los lenguajes de alto nivel destinado a la
realizacin de actividades especiales y los lenguajes de bajo nivel, tales como
el lenguaje ensamblador a causa de algunas caractersticas como "Sistema de
la Independencia", "Limitados Tipos de datos", "Alta flexibilidad", C es
considerado como un potente lenguaje y se ha convertido muy popular por su
portabilidad a travs de los sistemas.
Historia de la C
Ao
Lengua
Desarrollado por:
je
1960
ALGOL
International
Committee
Demasiado general, demasiado

abstracto
1963
CPL
Universidad
deCambridge
Duro de aprender, difcil de

implementar
1967
BCPL
Martin Richards
Slo podra hacer problemas

especficos.
1970
Ken Thompson AT & Slo podra hacer problemas

T Bell Labs
especficos.
1972
Dennis Ritchie AT & Restructurado, perdi la

T Bell Labs
generalidad de BCPL y B
Cerca de
los 80s
C++
Bjarne Stroustrup AT Introdujo la Programacin

&T
Orientada a Objeto a C
Detalles
Caractersticas de C
- Simple, es un lenguaje verstil, de uso general
- Los programas son rpidos y eficientes
- Tiene amplio conjunto de operadores
- Ms general y no tiene restricciones
- Manipula fcilmente bits, bytes y direcciones
- Variedades de tipos de datos estn disponibles
- Es posible compilar las funciones de forma separada y las funciones se las
puede llamar por cualquier programa C
- Lenguaje de bloques estructurado

- Puede ser aplicado en reas de programacin del sistema, como sistemas
operativos, compiladores e intrpretes, montadores, etc,
II. Fundamentos de la programacin

Componentes de un programa
1.
2.
3.
4.
Constantes
Variables
Operadores
Declaraciones
Por lo tanto, antes de escribir un programa debera tener claro que son todos
los componentes anteriormente mencionados. Segn el ejemplo anterior, cada
programa es un conjunto de declaraciones, y la declaracin es una
instruccin para el equipo, que es una coleccin de constantes, variables,
operadores y sentencias.
Constantes
Una constante es un valor fijo, que nunca se altera durante la ejecucin de un
programa.
Las constantes se pueden dividir en dos categoras principales:
1. Constantes Primaria
2. Constantes Secundaria
Tipos de datos
La clase datos que pueden contener las variables usadas en un lenguaje de
programacin es conocido como el tipo de datos.
Los Tipos bsicos de datos son los siguientes:
1.
2.
3.
4.
5.
6.
Tipo
Tipo
Tipo
Tipo
Tipo
Tipo
de
de
de
de
de
de
datos
datos
datos
datos
datos
datos
numricos
No numrico
Entero
real
lgicos
Enumerado
1. Tipo de datos numricos: Funciona slo con nmeros. Estos nmeros

pueden ser de tipo entero (int) o tipo de datos real (float)
2. Tipo de datos No numrico: Funciona slo con cadenas de caracteres.
Cualquier carcter o grupo de caracteres encerrados entre comillas se
considerar como tipo de datos no numricos o de caracteres.
3. Tipo de datos - Entero: Se ocupa de los nmeros enteros. Todas las
operaciones aritmticas se puede lograr a travs de este tipo de datos y los
resultados son de nuevo los nmeros enteros.
4. Tipo de datos - Real: se ocupa de los nmeros reales, que incluyen las
fracciones. Todas las operaciones aritmticas se puede lograr a travs de este
tipo de datos y los resultados pueden ser del tipo de datos real.
5. Tipo de datos Lgico o booleano: slo puede tener cualquiera de los dos
valores VERDADERO o FALSO a la vez. En computacin, un 1 (uno) se almacena
para TRUE y un 0 (cero) se almacena para FALSO.
6. Tipo de datos - Enumerado: Incluye los datos no estructurados agrupados
para dar lugar a un nuevo tipo. Este tipo de datos no es estndar y por lo
general es definido por el usuario.
Ex.
Dias_Semana = {"Lun", "Mar", "Mi", "Jue", "Vie", "Sb", "Dom"};
Direcciones = {"Norte", "Sur", "Este", "Oeste"};
La siguiente tabla muestra los tipos de datos estndar con sus propiedades.
Range: high
Keyword Range: low
Digits of
precision
Bytes of
memory
FormatoID
char
-128
127
n/a
%c
int
-32, 768
32, 767
N/a
2 (on 16 bit
processor)
%d
long
-2,147, 483,
648
2, 147, 483, 647 N/a
%ld
float
3.4 x 10-38
3.4 x 1038
%f
double
1.7 x 10-308 1.7 x 10308
long double3.4 x 10-4932 3.4 x 10-4932
15
%lf
19
10
%Lf
Quiero que usted consulte esta pgina para obtener ms informacin sobre el
tipo de int para diferentes procesadores:
http://www.jk-technology.com/c/inttypes.html

02. Paso a Paso-C / C ++ - IDE y compiladores para C / C++
GCC para C / C++ es un compilador de estos lenguajes de programacin. Con el fin de
ejecutar un programa que necesita ser compilado (es decir, utilizar GNU GCC, Tiny C, MS
Visual C, C Cygwin, Borland C, Intel C, etc.). Tambin es necesario un IDE para crear o
modificar los programas (por ejemplo: Dev-C, Eclipse, TurboC, etc)
Yo les doy un par de ejemplos de mi compilador favorito y varios IDEs, Usted puede elegir
el que mejor le convenga.
1. Instalacin del compilador GCC
1.1. Para Linux
1.2. Para Mac OS X
1.3. Para Windows (MinGW DevCpp-IDE)
1.4. Cmo crear, compilar y ejecutar programas
1.5. Ejemplos de Programas
1. Instalacin del compilador GNU GCC
1.1. Para Linux
Para Red Hat, consiga un gcc-c RPM, por ejemplo, utilizando rpmfind y luego
instalar (como root) con
rpm -ivh gcc-c -version-release.arch.rpm
Para Fedora Core / CentOS, instalar el compilador GCC C (como root) mediante el
uso de
yum install gcc-c
Para Mandrake, instale el compilador GCC C (como root) mediante el uso de
urpmi gcc-c
Para Debian/Ubuntu, instale el compilador GCC C (como root) mediante el uso de

apt-get install g
Tambin ara Ubuntu, instale el compilador GCC C utilizando
sudo apt-get install g
Si no puede convertirse en root, obtenga el tarball de ftp://ftp.gnu.org/ y siga las

instrucciones para compilar e instalar en su directorio personal.
1.2. Para Mac OS X

Xcode Tiene el compilador GCC de C incluido.
1.3. Para Windows (MinGW
DevCpp-IDE)
Ir a la http://www.bloodshed.net/devcpp.html, elija la versin que desea, haga clic

en el vnculo de descarga adecuado! Para la versin ms actual, visite
http://www.bloodshed.net/dev/devcpp.html
Vaya hacia abajo para leer la licencia y luego a los enlaces de descarga. Descargar
una versin con MinGW / GCC. Es mucho ms fcil. Con una demora muy pequea
(slo unos das) que siempre obtendr la versin ms actualizada de MinGW
empaquetado con el IDE devcpp.
Usted recibe un archivo ejecutable que puede ser ejecutado a nivel de usuario en
cualquier versin de WinNT. Si usted quiere que sea la configuracin para todos los
usuarios, necesita derechos de administrador. Se instalar devcpp y MinGW en las
carpetas deseadas
Inicie el IDE y la experiencia de su primer proyecto!
Encontrar similitudes con MSVC, incluyendo el men y ubicacin de los botones. Por
supuesto, muchas cosas son algo diferentes si estaban familiarizados con la versin antigua,
pero es tan simple como un puado de clics para que su ejecucin del primer programa.
1.4. Cmo crear, compilar y ejecutar programas
Si est utilizando Linux, para crear o editar un programa:
vi hello.cpp
Compilacin: (el compilador puede ser g, o gcc)

g -Wall -g -o hello.out hello.cpp
Ejecutar un programa:
./hello.out
1.5. Programas de ejemplo:
C Programa de ejemplo:
/* 0001_hello.c */
#include <stdio.h>
int main()
{
printf("\nHello world");
return 0;
}
C Programa de ejemplo:
/* 0001_hello.cpp */
#include <iostream>
using namespace std;
int main()
{
cout << endl << "Hello, Happy programming";
return 0;
}

* Estructura de un programa en C
1. Sentencias de E/S
2. printf
3. Caracteres de Escape
4. Utilizar variables en los programas
5. scanf
* Ms sentencias de E/S
1. gets
2. puts
3. getch
4. putch
5. getche
6. getchar
Indicarle que, cada programa es un conjunto de sentencias, y cada sentencia es una
instruccin (o ms de una) para el equipo, que es una coleccin de constantes, variables,
operadores y declaraciones.
Debemos indicar, que durante el curso, todo aquello que aparezca entre < y > indica que su
uso es opcional, y depender tanto del desarrollador como de las exigencias del programa.
No obstante, en las sentencias #include incorporan estos caracteres y su uso es obligatorio
para indicar al compilador que durante el proceso de creacin deber incluir dicho fichero
que contiene sentencias o variables fundamentales para el programa.
Estructura de un programa en C
< tipo
{
<
<
<
}
de valor de retorno > main ( arg-list )

Parte de las declaraciones >
Bloque de sentencias >
Retorno de valores >
Vamos a comenzar con las sentencias de entrada / salida Estados ya que juegan un papel
fundamental en nuestros programas.
Sentencias de E/S
printf
Este comando muestra el literal dado / prompt / identificadores en la pantalla con el
formato determinado.
Sintaxis:
printf(< "prompt/cadena literal/id del formato, escape/caracter " >, id1,id2, .....);
Ejemplo:
printf("Hola");
printf("Estudiante nmero : %d", sno);
printf("Nombre del alumno: %s", name);
printf("3 Marcas importantes: %d, %d, %d", m1, m2, m3);
<p>Necesita un navegador que use frames

=======================================================
Introduccin al cdigo fuente. (versin 2)
=======================================================
1. Cdigo fuente
/* 02_print.c */
#include <stdio.h >
int main( )
{
printf("Hello");
return 0;
}
Caracteres de Escape
Sentencias de escape ms comunes.
Secuencia escape
Caracter.
--------------------+-------------------------------------------\a
Bell(beep) "alarma sonora"
--------------------+-------------------------------------------\b
Borra un especio
--------------------+-------------------------------------------\f
Desde "final de la lnea" (from feed)
--------------------+-------------------------------------------\n
Nueva lnea
--------------------+-------------------------------------------\r
Retorno de carro
--------------------+-------------------------------------------\t
Tabulador
--------------------+-------------------------------------------\\
Muestra una nica \
--------------------+-------------------------------------------\'
Muestra comillas simples
--------------------+-------------------------------------------\"
Muestra comillas dobles.
--------------------+-------------------------------------------\xdd
Representaciones hexadecimales.
--------------------+--------------------------------------------
=======================================================
2. Programa que imprime mensaje tras una nueva lnea.

- Comprelo con el ltimo programa
/* 03_esc.c */
#include <stdio.h>
int main()
{
printf("\nHello");
return 0;
}
=======================================================
3.- Programa que muestra la direccin de una persona.

- Mltiples sentencias en la funcin main
/* 04_multi.c */
#include <stdio.h>
int main()
{
printf("\nNombre de la persona");
printf("\nStreet, Apartment//House No. ");
printf("\nzip, City");
printf("\nCountry");
return 0;
}
Utilizando variables en los programas.

Tipos de variables bsicas.
Digitos de
Palabra Clave | Rango: bajo |Rango: alto
ID
|precisin
| Bytes memoria
----------------+---------------+---------------+---------------+---------------+-----------Char
| -128
| 127
N/a
|1
| %c
----------------+---------------+---------------+---------------+---------------+-----------Int
| -32, 768
| 32.767
N/a
|2
| %d
----------------+---------------+---------------+---------------+---------------+------------
| Format-
Long
| -2.147.483.647| 2.147.483.647
N/a
|4
| %ld
--------------------------------+---------------+---------------+---------------+-----------Float
| -3.4 x 10^38 | 3.4 x 10^38 |
|4
| %f
----------------+---------------+---------------+---------------+---------------+-----------Double
| -1.7 x 10^308
| 1.7 x 10^308 |
15
|8
| %lf
----------------+---------------+---------------+---------------+---------------+-----------long double
| -3.4 x 10^4932| 3.4 x 10^4932
19
| 10
----------------+---------------+---------------+---------------+---------------+------------
=======================================================
4. Programa que resuelve la suma de dos valores.

- Introduccin a las variables en este programa
/* 05_var.c */
#include <stdio.h>
int main()
{
/* con esta sentencia se declaran las variables a,b y c como enteras ?cortas? */
int a , b , c;
a = 5;
b = 10;
c = a + b;
printf("%d", c);
return 0;
}
| %Lf
=======================================================
5. Programa que resuelve la suma de dos valores, con un mensaje

- Comprelo con el ltimo programa.
#include <stdio.h>
int main()
{
int a, b, c;
a = 5;
b = 10;
c = a + b;
printf("\nLa Suma es %d", c);
/* Insertamos un texto antes de imprimir el mensaje */
return 0;
}
Scanf
Utilizando esta sentencia podremos aceptar y dar valores a las variables durante la
ejecucin del programa.
Sintaxis:
scanf(<format id/esc char">, id1,id2, .....);
Ejemplo.
scanf("%d", &sno);
/* Espera un valor decimal */
scanf("%s", name);
/* Espera un valor de cadena */
scanf("%d%d%d", &m1, &m2, &m3);

por comas */
/* Espera tres valores separados
6. Programa que resuelve la suma de dos valores usando scanf

- La primera vez que ejecute este programa le mostrar un cursor, estar esperando que
introduzca un valor numrico entero y presione Intro, entonces, har lo mismo para el
siguiente valor y le mostrar el resultado.
=======================================================
/* 07_scanf.c */
#include <stdio.h>
int main()
{
int a , b, c;
scanf("%d", &a);
scanf("%d", &b);
c = a + b;
printf("\nLa Suma es %d", c);
return 0;
}
=======================================================
7. Programa que resuelve la suma de dos valores con mensajes de salida.

- Los mensajes son opcionales, pero hacen las aplicaciones una interaccin ms
amigable.
- Comprelo con el ltimo programa.
=======================================================
/* 08_sum.c */
#include <stdio.h>
int main()
{
int a , b, c;
printf("Introduzca un valor para A "); scanf("%d", &a);
printf("Introduzca un valor par a B "); scanf("%d", &b);

c = a + b;
printf("\nLa Suma A+B es %d", c);
return 0;
}
=======================================================
8. Programa que busca el resultado de ( a+ b )2

- Similar a la suma de dos valores pero modificando la frmula.
=======================================================
/* 09_formula.c */
#include <stdio.h>
int main()
{
int a, b, c;
printf("Introduzca un valor para A "); scanf("%d", &a);
printf("Introduzca un valor para B "); scanf("%d", &b);

c = a * a + b * b + 2 * a * b;
printf("El resultado es %d", c);

return 0;
}
=======================================================
9. Programa que haya el salario anual de un empleado.

- Introduce : eno, name, sal
- Proceso : Asal = sal * 12
- Salida : Eno, name, sal, asal
- Este programa es una introduccin a los diferentes tipos de variables.
=======================================================
/* 10_emp.c */
#include <stdio.h>
int main()
{
int eno;
char name[10];
/* Nombre con 10 caracteres de ancho. */
float sal, asal;
/* sal & asal son valores reales. */
printf("Introducir el nmero de empleado "); scanf("%d", &eno);
printf("Introducir el nombre del empleado "); scanf("%s", name);

printf("Introducir el salario del empleado "); scanf("%f", &sal);
asal = sal * 12;

printf("\nEmpleado nmero %d", eno);
printf("\nEmpleado llamado %s", name);
printf("\nSalario del empleado %f", sal);
printf("\nSalario anual %f", asal);
return 0;
}
=======================================================
10. Escribiremos un programa que resuelva la nota total y la media de un estudiante.

- Entrada : Sno, name, sub1, sub2, sub3
- Proceso : total = sub1 + sub2 + sub3; media = total / 3
- Salida : sno, name, total, avg
- Similar al programa de arriba pero aceptamos valores, procesos e imprimimos los
mensajes.
=======================================================
/* 11_stud.c */
#include <stdio.h>
int main()
{
/* declaramos valores enteros */
int sno, sub1, sub2, sub3, total;
/* declaramos la variable ?name? de longitude 10 */
char name[10];
/* declaramos la variable avg, como decimal flotante */
float avg;
clrscr();
/* Limpiamos la pantalla antes de la salida. */
printf("Introduzca el nmero de estudiante: "); scanf("%d", &sno);

printf("Introduzca el nombre del estudiante: "); scanf("%s", name);
printf("Nota del primer trimestre: "); scanf("%d", &sub1);
printf("Nota del segundo trismestre "); scanf("%d", &sub2);
printf("Nota del tercer trimestre "); scanf("%d", &sub3);
total = sub1 + sub2 + sub3;

avtg = total / 3;
printf("\nStudent number %d", sno);

printf("\nStudent name %s", name);
printf("\nTotal marks %d", total);
printf("\nAverage marks %f" , avg);
return 0;
}
=======================================================
Ms sentencias de E/S
Gets:
Acepta una cadena desde el teclado. Acepta toda la cadena que se introduzca hasta que se
pulse intro
Sintaxis:
scanf(<format id/esc char">, id1,id2, .....);
Ejemplos:
scanf("%d", &edad);
scanf("%s", nombre);
scanf("%d%d%d", &m1, &m2, &m3);
Puts:
Muestra el valor de la cadena dada en la pantalla.
Sintaxis:
puts( <id.> / <"prompt">);
Ejemplos:
puts(nombre);
puts(calle);
getch - Lee un carcter (desde el teclado) sin producir eco

/* Por eco, se entiende que se mostrar en pantalla el carcter escrito */
getche - Lee un carcter (desde el teclado) con eco

getchar - Lee un carcter y acepta retorno de carro.
putch - Imprime un carcter en la pantalla
Sintaxis:
putch(<char>).
Ejemplo:
putch('a');
putch(65);
getch ? Acepta un carcter desde consola
Sintaxis:
char = getch().
Ejemplo:
ch = getch();
option = getch();
1. Introduccin a las sentencias condicionales.

2. if..else
3. switch
1. Introduccin a las sentencias condicionales:
Un ordenador es un dispositivo electrnico que puede realizar tanto operaciones aritmticas
como decisiones lgicas.
En este punto, el ordenador est lejos de ser una calculadora ordinaria, la cual slo permite
operaciones aritmticas.
Podemos interactuar mejor dndole valores o usando Sentencias condicionales
del tipo: if-else, switch.
2. if..else
Esta es una sentencia condicional para buscar variedad de resoluciones entre
dos expresiones.
Sintaxis:
if ( < condition > )
{ < St.block >; }
else
{ < St block >; }
Todos los if tienen una condicin y dos bloques de sentencias. Si la condicin es
verdadera se ejecuta la primera "st.block" y viceversa.
Ejemplo.
If( a>b )
printf("A is big");
else
printf("B is big");
Nota: No siempre sera necesario una sentencia de dos bloques, si el Segundo
bloque no es necesario que se ejecute.
1. Programa que busca el mayor de dos nmeros
/* 12_if.c */
#include <stdio.h>
int main()
{
int a, b; /* Declaracin de las variables. */
printf("\nIntroducir valor para A: "); scanf("%d", &a); /* Lee valor de
A */
printf("\nIntroducir valor para B: "); scanf("%d", &b); /* Lee valor de
B */
if( a>b ) /* Comparamos ambos */
printf("A es mayor");
else
printf("B es mayor");
return 0;
} /* End */
Esta es una lista de los operadores en C++ y C. Todos los operadores de C

estn incluidos en C++
Ref: http://en.wikipedia.org/wiki/Operators_in_C_and_C++
Operadores aritmticos
Operador
Proposito
Adicin
Subtraccin
Multiplicacin
Divisin
Devuelve el modulo de divisions
Operadores Unitarios
Operador
Propsito
Menos (nmero negativo)
++
Incremento en 1
--
Decremento en 1
sizeof
Tamao en bytes
(type)
Cast
Operadores relacionales
Operador
Propsito
<
Menor qu
<=
Menor o igual qu
>
Mayor qu
>=
Mayor o igual qu
Operadores de Igualdad
Operador
Propsito
==
Igual a:
!=
No igual a:
Operadores lgicos
Operador
Propsito.
&&
AND
||
OR
NOT
Operadores para la manipulacin de bits

Operator
Purpose
&
AND
OR
NOT
XOR
<<
Desplazamiento a la izquierda
>>
Desplazamiento a la derecha
Agrupacin de operadores por prioridad de desplazamiento.

R to L, indicar desplazamiento de Derecha a Izquierda, L to R, viceversa
Categora del operador
Operadores
Asociativo
Operadores unitarios
- ++ -- ! sizeof (type)
R to L
Aritmticos, multiplicacin,
division y mdulo
*/%
L to R
Aritmticos sumar y restar
+-
L to R
Operadores relacionales
< <= > >=
L to R
Operadores de igualdad
== !=
L to R
Operadores lgicos
&& ||
L to R
Operadores condicionales
?:
R to L
Operadores de asignacin
= += -= *= /= %=
R to L
Ms ejercicios
La razn que perseguimos para hacer ms ejercicios es la de familiarizarse con
las sentencias aprendidas, si est seguro, entonces no tendr que ejecutar los
siguientes programas.
/* 01. Programa que pregunta la edad de una persona

y le aade los siguientes detalles. */
/* age <= 12 Cro
age >= 13 and age <= 19 Adolescente
age >= 20 and age <= 35 Joven
age >= 36 and age < 65 Mediana edad
age >= 65 Viejo
*/
/* 13_age.c */
#include <stdio.h>
int main()
{
char name[20];
int age;
clrscr();
print "Dime tu nombre: "; input name;
print "Dime tu edad: "; input age;
printf("\n%s ests entre ");
if ( age <= 12 ) printf("Un cro");
if ( age >= 13 and age <= 19 ) printf("Un adolescente");
if ( age >= 20 and age <= 35 ) printf("Joven");
if ( age >= 36 and age < 65 ) printf("De mediana edad");
if ( age >= 65 ) printf("Viejo");
return 0;
}
/* 02. Programa que busca el mayor de tres valores */

/* 14_big3.c */
#include <stdio.h>
#include <conio.h>
int main()
{
int a, b, c;
clrscr();
printf("Dime el valor de A: "); scanf("%d", &a);
printf("Dime el valor de B: "); scanf("%d", &b);
printf("Dime el valor de C: "); scanf("%d", &c);
if( a > b && a > c ) printf( "A es el mayor. " );
if( b > a && b > c ) printf( "B es el mayor." );
if( c > a && c > b ) printf( "C es el mayor." );
return 0;
}
/* 03. Programa que busca el mayor de tres valores usando ifelse */

/* 15_big3.c */
#include <stdio.h>
#include <conio.h>
int main()
{
int a, b, c;
clrscr();
printf("Dime el valor de A: "); scanf("%d", &a);
printf("Dime el valor de B: "); scanf("%d", &b);
printf("Dime el valor de C: "); scanf("%d", &c);
if( a > b && a > c )
printf( "A es el mayor. " );
else
if ( b > c )
printf( "B es el mayor. " );
else
printf( "C es el mayor. " );
return 0;
}
/* 04. Programa que busca el
/* 16_big3.c */
#include <stdio.h>
#include <conio.h>
int main()
{
int a, b, c;
clrscr();
printf("Dime el valor de A:
printf("Dime el valor de B:
printf("Dime el valor de C:
if( a > b )
if( a > c )
printf(" A es el mayor. ");
else
printf(" C es el mayor.");
else
if( b > c )
printf(" B es el mayor.");
else
printf(" C es el mayor.");
return 0;
}
mayor de 3 valores usando un if anidado. */
"); scanf("%d", &a);

"); scanf("%d", &b);
"); scanf("%d", &c);
/* 05. Programa que busca el da de la semana a partir de un nmero

dado.*/
/* 17_week.c */
#include <stdio.h>
int main()
{
int week;
printf("Introduce el nmero del da de la semana: "); scanf("%d",

&week);
if (week == 1 ) printf ("Lunes");
if (week == 2 ) printf ("Martes");
if (week == 3 ) printf ("Mircoles");
if (week == 4 ) printf ("Jueves");
if (week == 5 ) printf ("Viernes");
if (week == 6 ) printf ("Sabado");
if (week == 7 ) printf ("Domingo");
if ( week < 1 || week > 7 ) printf("No hay das as !!");
return 0;
}
3. Instruccin switch
Sentencia multicondicional que tiene la posibilidad de comprobar una variable
a travs de ms de una expresin
Sintaxis:
switch(<id>)
{
case <expr.> : <st. block>; break;
case <expr.> : <st. block>; break;
......
Default : <st. block>;
}
Ejemplo
switch(week)
{
case 1 : printf( "Lunes"); break;
case 2 : printf( "Martes"); break;
.
.
case 7: printf("Domingo"); break;
default : printf("Entrada equivocada");
}
/* 06. Buscar el da de la semana por un nmero dado usando la sentencia
switch */
/* 18_switch.c */
#include <stdio.h>
int main()
{
int week;
printf("Introducir el nmero del da de la semana "); scanf("%d",
&week);
switch(week)
{
case 1 : printf ("Lunes"); break;
case 2 : printf ("Martes"); break;
case 3 : printf ("Mircoles"); break;
case 4 : printf ("Jueves"); break;
case 5 : printf ("Viernes"); break;
case 6 : printf ("Sbado"); break;
case 7 : printf ("Domingo"); break;
default : printf("Wrong Entry");
}
return 0;
}
Introduccin a las Sentencias looping, (anidadas o de lazo)

1. Declaracin de la controvertida: goto
2. Sentencias Looping
for
while
do..while
1. La sentencia controvertida:
No se recomienda utilizar la sentencia goto, no obstante es la nica forma de poderte
permitir salir de algn bloque de sentencias anidadas, evita utilzarlo siempre que puedas.
Goto: Transfiere el control del puntero de un lugar a otro en el programa actual.
Sintaxis:
goto <label>;
Note: La etiqueta debe ser definida con el caracter de dos puntos ":" y no debe exceeder el
nombre de los 32 caracteres de longitud.
Ejemplo.
abc:
printf("Hello");
goto abc;
/* 01. A demonstration program to illustrate goto statement */

/* 19_goto.c */
#include <stdio.h>
int main()
{
abc: /*Nombre de la etiqueta*/
printf("\nHello");
/* Se introducir en un bucle sin fin */
goto abc; return 0;
}
/* 07. En este programa para poder parar el programa vamos a vigilar

una variable para que cuando se de un cierto valor de incremento
realice una operacin diferente, comprueba este programa con el anterior.
*/
/* 20_goto.c */
#include <stdio.h>
int main()
{
int i = 1;
abc:
printf("\nHello");
i ++;
if ( i<= 10 ) /* Take care of this statement */
goto abc;
return 0;
}
2. Sentencias de Looping
Utilice una sentencia iterativa para ejecutar un bloque de instrucciones un nmero de veces.
Sintaxis:
for(<initialization> ; <condition> ; <step value>)

{
<st. block>
}
Ejemplo:
for(I=1;I<=10; I++)
printf("\n%d",i);
Ejemplo:
http://www.youtube.com/watch?v=z1Zj9Yc3asQ&feature=related
for(I=1, j = 0; I<10; I+=2, j+=2)

printf("%d %d\n", i, j);
/* 08. Imprime un mensaje 5 veces */

/* 21_for.c */
#include <stdio.h>
int main()
{
int i;
for(i = 1; i <= 5; i++ )
printf("\nHello");
return 0;
}
/* 09. Imprime un mensaje y lo muestra, contndolo, 5 veces. */

/* 22_hello.c */
#include <stdio.h>
int main()
{
int i;
for(i = 1; i <= 5; i++ )
printf("\nHello - %d", i);
return 0;
}
/* 10. Imprime los nmeros naturales del 1 al 10 */

/* Vdeo: http://www.youtube.com/watch?v=z1Zj9Yc3asQ&feature=related */
/* 23_nat.c */
#include <stdio.h>
int main()
{
int i;
for(i = 1; i <= 10; i++ )
printf("\n%d", i); /* Mensaje elemental */
return 0;
}
/* 11. Imprime la tabla de multiplicar por 2 */

/* Note : Comprelo con el programa anterior */
/* 24_table.c */
#include <stdio.h>
int main()
{
int i;
for(i = 1; i <= 20; i++ )
printf("\n%d * 2 = %d", i, i * 2);
return 0;
}
/* 12. Imprime la tabla de multiplicar por un nmero dado */

/* 25_tablen.c */
#include <stdio.h>
#include <conio.h>
int main()
{
int i, t; /* una nueva variable 't' */
clrscr();
printf("Cual es la tabla a imprimir:"); scanf("%d", &t);
for(i = 1; i <= 20; i++ )
printf("\n%d * %d = %d", i, t, i * t);
return 0;
}
/* 13. Imprime una tabla de multiplicar por un nmero dado */

/* 26_tablen.c */
#include <stdio.h>
int main()
{
int i, t;
clrscr();
for(t = 1; t <= 20; t++) /* Un loop ms */
for(i = 1; i <= 20; i++ )
printf("\n%d * %d = %d", i, t, i * t);
return 0;
}
/* 14. Imprime los nmeros de forma de tringulo */

/* 27_tri.c */
#include <stdio.h>
int main()
{
int i, j;
clrscr();
for( i = 1 ; i<= 5; i++ )
{
for( j = 1; j <= 5; j++ )
printf("%4d", j);
printf("\n");
}
return 0;
}
For:
Algunos ejemplos ms de loops.
/* Loop infinito */
for ( ; ; )
{
printf("\nHello");
}
/* Interrupcin explcita de un loop */
for ( i=1; ; )
{
printf("\n%d", i++);
if ( i> 5 ) break;
}
/* Imprime mensajes del 1 al 5 */

for ( i=1; i<=5; )
{
}
int i = 1;
for ( ;i<=5 ; )
{
}
while:
Una sentencia iterativa para ejecutar un bloque de sentencias hasta que la condicin sea
satisfecha.
do.. while:
Esta declaracin iterativa ejecuta un bloque de instrucciones desde el comienzo y luego
comprueba la validez de la condicin. Si la condicin es verdadera se ejecuta el bloque de
instrucciones otra vez y viceversa.
Syntax:
Syntax:
while( < condition > )

{
<st. block>;
}
do
{
<st. block>
} while(<condition>);
Ejemplo:
Los siguientes ejemplos muestran los nmeros del 1 al 10
int main()
{
int i=1;
while( i<=10)
{
printf("\n%d",i);
i++;
}
return 0;
}
int main()
{
int i=1;
do
{
printf("\n%d",i);
i++;
}while(i<=10);
return 0;
}
Se comprueba la primera condicin y Se ejecuta el primer bloque y se

ejecuta el siguiente bloque, as que comprueba en la condicin siguiente,
usted debe tener un valor inicial para debes determinar el valor en la
la condicin
sentencia
Ms ejemplos:
/* 16. Imprimir mensajes del 1 al 5 */
/* 15. Imprimir mensajes del 1 al 5 */
/* Note : Este es el programa de referencia
*/
/* 29_dowhile.c */
#include <stdio.h>
/* 28_while.c */
int main()
#include <stdio.h>
{
int main()
int i;
{
i = 1; /* Initial value is 1 */
int i;
do
i = 1; /* Initial value is 1 */
{
while( i<= 10 )
printf("\n%d", i);
/* True i is less than or equal to 10 at
i ++;
first */
}while( i<=10 );
{
/* True, i is less than or equal to 10 at
printf("\n%d", i);
Second */
i ++;
}
return 0;
return 0;
}
}
/* 17. Demostracin del comando while */ /* 18. Demostracin de do */
/* Note : Si el valor inicial es 100 cual
/* Nota : Si el valor inicial es 100 cual
ser la salida? Comprubalo */
ser la salida? Comprubalo */
/* 30_demow.c */
#include <stdio.h>
int main()
{
int i;
i = 1;
while( i<= 10 )
{
printf("\n%d", i);
i++;
}
return 0;
}
/* 31_demod.c */
#include <stdio.h>
int main()
{
int i;
i = 1;
do
{
printf("\n%d", i);
i++;
}while( i<= 10 );
return 0;
}
Tutorial de C++. Entrega N 6

Funciones
I. Introduccin
II. Definicin de Funcin
III. Tipos de funciones
IV. Las funciones integradas
1. Funciones numricas
2. Funciones de cadena
3. Funciones de comprobacin de cadenas
V. Funciones definidas por el usuario
1. Funciones simples
2. Funcin con argumentos
3. Funcin de Devoluciones
4. Funcin con recursin
VI. Punteros y funciones
1. Paso de parmetros por referencia
2. Llamada por valor
3. Llamada por referencia
VII. Local vs Global
VIII. Los especificadores de la clase de almacenamiento
Clase de Almacenamiento Automtico
Clase de almacenamiento Registro
Clase de almacenamiento Esttico
Clase de Almacenamiento Externo
I. Introduccin
Aqu hay un programa para imprimir la direccin de una persona dos veces,
lo que est escrito en la letra b
Utilizando los 2 mtodos, el de las funciones y sin las funciones.

Se demuestra la ventaja de las mismas
#include <stdio.h>
int main()
{
printf("\nName of the Person");
return 0;
}
#include <stdio.h>
void address()
{
}
int main()
{
address();
address();
return 0;
}
II. Definicin de funciones
Un
bloque de instrucciones, que tiene capacidad para aceptar los valores
como argumentos y devuelven los resultados al programa de llamada. Por lo

tanto,
una funcin es un bloque de auto-contenido que realizan una tarea
especfica.
III. Tipos de funciones
- Funciones preconstruidas que pueden estar en biblioteca de funciones y
funciones predefinidas
- Funciones definidas por el usuario
IV. Biblioteca de Funciones
Las funciones de una biblioteca (tambin llamada librera) han sido
diseados por el
fabricante del software, se cargan desde el disco cada vez que el
software se carga.
Las siguientes funciones son el ejemplo de las funciones de la
biblioteca.
1. - Funciones Numricas
Funcin
Sintaxis
Ejemplo
Resultado
Abs
Abs(n)
abs(-35)
35
ceil
ceil(n)
ceil(45.232)
46
floor
floor(n)
floor(45.232)
45
fmod
fmod(n,m)
fmod(5,2)
cos
cos(n)
cos(60)
0.5
sin
sin(n)
sin(60)
0.866
tan
tan(n)
tan(60)
1.732
sqrt
sqrt(n)
sqrt(25)
pow
pow(n,m)
pow(2,3)
2. Funciones del tipo Cadena.
Funciones
Sintaxis
Ejemplo.
strlen
strlen(str)
strlen("Computer")
strcpy
strcpy(target,source)
strcpy(res,Pass)
strcat
strcat(target,source)
strcat("mag","gic")
strcmp
strcmp(str1,str2)
strcmp("abc","Abc")
strrev
strrev(target,scr)
fstrrev(res,LIRIL)
3. Funciones de comprobacin de cadenas.

Funcin
Descripcin
isalnum
isalpha
isdigit
iscntrl
isascii
islower
isupper
isspace
isxdigit
es
es
es
es
es
es
es
es
es
una letra or dgito

una letra
un dgito
un caracter de control ordinario
un caracter ASCII vlido
una letra minscula
una letra mayscula
un caracter de espacio
un caracter hexadecimal
Hay una enorme biblioteca de funciones disponible, te he dado una pequea

porcin
de la misma.
Para obtener ms funciones de la biblioteca te remitimos al Manual de
Ayuda.
V. definidas por el usuario
Los programas que tienes ya han visto realizar la divisin del trabajo.
Cuando se llama a gets, puts, o strcmp, usted no tiene que preocuparse
acerca
las entraas de estas funciones.
Estas y cerca de otras 400 funciones ya estn definidos y compilados para
usted
en la biblioteca de Turbo C (por ejemplo). Para usarlos, basta con
incluir el
archivo cabecera apropiado en su programa, "La biblioteca en tiempo de
ejecucin",
consulte el manual de referencia para asegurarse de cmo llamar a las
funciones, y
qu valor (si los hay) devuelve.
Pero usted tendr que escribir sus propias funciones. Para ello, es
necesario
romper el cdigo en secciones independientes (funciones) que cada una
realiza una
tarea simple, comprensible para sus funciones, se las puede llamar a
travs de su
programa de la misma manera que las llamara a las funciones C de la
biblioteca.
Pasos para implementar una funcin
1. Declaracin
2. Funcin de llamada
3. Definicin
Todas las funciones deben ser declaradas al principio del programa.
Definir la funcin que contiene el cdigo real de ejecucin de la
tarea.
Si una funcin se define en el inicio del programa, no hay necesidad de
declarar
la funcin.
Una funcin de ejemplo para demostrar lo enseado.
/* 32_egfun.c */
#include <stdio.h>
void address();
/* Declaracin */
int main()
{
address();
address();
/* Llamada a la funcin */
/* Llamada a la funcin */
return 0;
void address()
/* Definicin */
{
}
Las funciones definidas por el usuario se pueden dividir en 4 tipos

basados en cmo
las estamos llamando.
1.
2.
3.
4.
Funciones Simple
Function con Argumentos
Function que retornan (un valor)
Function con Recursin
1. Funciones Simple
Realizan slo una tarea especfica, sin necesidad de argumentos ni
devolver
valores.
Ejemplo de una funcin simple
/* 33_line.c */
#include <stdio.h>
void line();
/* Declaraciln */
int main()
{
line();
/* Llamada a la funcin*/
return 0;
}
void line()
/* Definicin */
{
int i;
for(i =1;i<80; i++)
putch("*");
}
2. Funcin con Argumentos
Una funcin, que acepta argumentos, se conoce como funcin con

argumentos.
Ejemplo
/* 34_argu.c */
void line(char ch, int n)
int main()
{
line("-", 50);
line("*", 8);
return 0;
}
void line(char ch, int n)
{
int i;
for( i = 1; i<=n; i++ )
putch(ch);
}
3. Funciones que devuelve valores

Una funcin que puede devolver valores al programa de llamada se la
conoce como
funcin con retorno de valores.
Ejemplo
/* 35_retu.c */
int abs(int n);
int main()
{
int res;
printf("%d", abs(-35))
res = abs(-34);
printf("%d", res);
return 0;
}
void abs(int n)
{
/* Function Call*/
if( n < 0 )
n = n * -1;
return n;
}
4. Funcin con Recursin

Si una sentencia dentro del cuerpo de una funcin llama a la misma
funcin se denominada 'recursividad'. A veces tambin llamada
"definicin circular", la recursividad es el proceso para definir
algo en trminos de s mismo.
Ejemplos de funciones recursivas de
/* The following program demonstrates function call of itself */

int main()
{
printf("\nHello");
main(); /* A function, which can call it self */
return 0;
}
No ejecute este programa, sigue siendo una explicacin por lo tanto

el programa no es vlido lgicamente.
El mismo resultado se puede llegar con esta otra funcin:
void disp( );
int main( )
{
disp( );
return 0;
}
void disp( )
{
printf("\nHello");
disp( );
}
El programa debe terminar en un momento determinado por lo que la clave

de
la recursividad se encuentra en la interrupcin suave, que se puede
definir con una sentencia condicional.
Verifica en el siguiente ejemplo:
/* 36_recursion.c */
int i = 1;
/* Declaring a global variable */
void disp( );
int main( )
{
disp( );
return 0;
}
void disp( )
{
printf("\nHello %d ", i);
i ++;
if( i < 10 ) /* if i value is less than 10 then call the function
again */
disp( );
}
Programa para encontrar el factorial del nmero dado:
/* 37_fact.c */
int factorial(int x);
void main
{
int a, fact;
printf("\nEnter any number "); scanf("%d", &a);
fact = factorial(a);
printf("\nFactorial is = %d", fact);
}
int factorial(int x)
{
int f = 1, i;
for( i = x; i>=1; i--)
f = f * i;
return f;
}
Para encontrar el factorial de un nmero determinado, utilizando

recursividad
/* 38_fact.c */
int rec_fact(int x);
int main( )
{
int a, fact;
printf("\nEnter any number "); canf("%d", &a);
fact = rec_fact(a);
printf("\nFactorial value is = %d", fact);
return 0;
}
int f = 1;
int rec_fact(int x)
{
if( x > 1)
f = x * rec_fact(x-1);
return f;
}
VI. Punteros y funciones

Paso de parmetros por referencia
Llamada por valor
Llamada por referencia
1. Paso de parmetros por referencia
El puntero se puede utilizar en la declaracin de la funcin y esto hace
que una funcin compleja sea fcilmente representadas, as como
acceder a ella. La definicin de la funcin hace uso de punteros
se puede hacer, de dos maneras
- Llamada por valor
- Llamada por referencia
La llamada por referencia es el mecanismo ms rpido en comparacin a
llamar por valor ya que en la llamada por referencia, la
direccin se pasa y la manipulacin con las direcciones es ms rpido
que trabajar variables normales. Al pasar la localizacin como
una sla posicin de memoria se crea para cada una de los parmetros
reales pasados.
#include <stdio.h>
/* #include <conio.h> */
int main()
{
int a;
/* Declaracin de la variable a */
int *dir;
/* Declaracin de un puntero a una variable */
a = 7;
dir = &a;
/* Asignacin de un valor a la variable */

/* Asignacin de la direccin de memoria de "a" a dir */
printf ("\nValor..: %d\n\n", *dir); /* Impresin del valor (de a) */

/* a partir de su direccin de memoria */
return 0;
En ensamblador, es todava ms fcil de comprender...

mov [2345],7h
memoria 2345
mov AX,[2345]
posicin 2345
;; Asignamos el valor 7 (en hexadecimal) a la posicin de

;; Recuperamos al registro AX, lo que hubiera en la
Cuando en alguna una parte del programa, los argumentos reales, llaman
a una funcin y los valores son alterados dentro de la funcin sern
devueltos a la parte llamada por programa principal en su forma
modificada.
Esta forma de trabajar, se denomina como llamadas por referencia o
llamadas
por su direccin. El uso de punteros como un argumento de una funcin de
este mecanismo permite a los objetos de los datos ser modificados
globalmente
es decir, tanto dentro de la funcin, como en la parte que llam del
programa.
Cuando se pasa un puntero a una funcin, la direccin del argumento se
pasa a
las funciones y el contenido de esta direccin se accede globalmente.
Los cambios realizados en los parmetros formales (parmetros utilizados
en
la funcin) afectan al valor original de los parmetros actuales (los
parmetros utilizados en la llamada de funcin en el programa de
llamada).
Por ejemplo.
/* 39_func.c */
void func_c( int *x );
int main()
{
int i = 100;
int *a;
a = &i;
printf("\nThe value is %d", i);
func_c(a);
printf("\nThe value is %d", i);
return 0;
}
void func_c( int *x )
{
(*x) ++;
printf("\nThe value in function is %d ", *x);
}
La salida del programa devuelve:

En el programa anterior, estas declaraciones son tres 'printf',
tras la funcin main() y una llamada a la funcin del subprograma. Debido
al
efecto de la primera sentencia printf el valor de i se imprime como 100.
Ms tarde otra llamada a la funcin se hace y dentro de la funcin, el
valor
se altera y se debe al incrementarse de 1. El valor se altera de nuevo al
volver a main() y se imprime en 101.
Por lo tanto el resultado es:
El valor es de 100
El valor de la funcin es de 101
El valor es de 101
Ms informacin sobre llamadas de funcin
Despus de haber tenido la primera cita con punteros ahora vamos a volver
a lo que nos habamos propuesto originalmente para aprender - los dos
tipos
de llamadas funciones: llamada por valor y llamada por referencia.
Los argumentos en general, se pueden pasar a la funcin en una de las dos
maneras:
a. El envo de los valores de los argumentos
b. El envo de las direcciones de los argumentos
2. Llamada por valor

En el primer mtodo del "valor" de cada uno de los argumentos reales en
la
funcin de llamada se copia en las correspondientes argumentos formales
de la funcin llamada. Con este mtodo, los cambios realizados a los
argumentos formales en la funcin llamada no tendr ningn efecto en
los valores de los argumentos reales en la funcin de llamada. La
programacin siguiente ilustra la llamada por valor.
/* 40_callbyvalue.c */
void swap( int x, int y )
int main( )
{
int a = 10, b = 20;
swap( a ,b );
printf("\n a = %d, b = %d ", a, b);
*/
return 0;
}
void swap( int x, int y )
{
int t;
t = x;
x = y;
y = t;
printf("\nx = %d, y = %d", x, y);
/* Muestra a = 10, b = 20
/* Entran x=10 e y=20 */

/* t=10 */
/* x=20 */
/* y=10 */
/* Muestra: x = 20, y = 10
*/
}
X = 20 y = 10
A = 10 b = 20
Tenga en cuenta que el valor de A y B permanecen sin cambios despus
de cambiar el valor de x e y.
3. Llamada por referencia
Esta vez las direcciones de los argumentos reales en la funcin de
llamada
se copian en argumentos formales de la funcin que llama. Esto significa
que
al utilizar estas direcciones tendramos un acceso a los argumentos
reales y
por lo tanto que sera capaz de manipularlos. El programa siguiente
ilustra
este hecho.
/* 41_callbyref.c */
void swap( int *x, int *y )
int main()
{
int a = 10, b = 20;
swap( &a, &b);
printf("\na = %d, b = %d", a, b);
return 0;
}
void swap( int *x, int *y )
{
int t;
t = *x; *x = *y; *y = t;
}
La salida del programa anterior sera:

A = 20, b = 10
Tenga en cuenta que este programa se las arregla para intercambiar los
valores de a y b con sus direcciones almacenadas en x e y. Por lo
general,
en la programacin de C hacemos un llamamiento por valor. Es decir en
general no se pueden alterar los argumentos reales. Pero si
se desea, siempre puede lograrse a travs de una llamada por
referencia.
Llamar a una funcin por referencia de forma inteligente, puede devolver
ms de un valor a la vez, que no es posible normalmente. Esto se muestra
en el programa que figura a continuacin.
/* 42_callbyref.c */
void areaperi(int r, float *a, float *p)
int main()
{
int radius;
float area, perimeter;
printf("\nEnter radius of a circle :"); scanf("%d", &radius);
areaperi(radius, &area, &perimeter);
printf("\nArea = %f ", area);
printf("\nPerimeter = %f", perimeter);
return 0;
}
void areaperi(int r, float *a, float *p)
{
*a = 3.14 * r * r;
*p = 2 * 3.14 * r;
}
Y aqu est el resultado:

Introduzca radio de un crculo : 5
Area = 78.500000
Permetro = 31.400000
En este sentido, hace una llamada mixta, en el sentido de que estamos
pasando el
valor del radio (que no va a cambiar), pero la direccin del rea y la
del permetro.
Y ya que estamos pasando las direcciones, cualquier cambio que se realice
en los
valores almacenados en la direccin que figura en las variables A y
P, hara que el cambio efectivo en las principales.
Por eso, cuando vuelve el control
obtener los
valores de rea y el permetro.
de la funcin areaperi() podemos
Por lo tanto, hemos sido capaces de devolver dos valores de una funcin
llamada, y por lo tanto, han superado la limitacin de la instruccin
return, que puede devolver un solo valor de una funcin a la vez.
VII. Variables globales vs Locales
Segn el mbito donde las variables se declaran como identificadores de
tipos.
ser donde funcionen...
/* 42_globalid.cpp */
int i=4000; /* Global variable declaration*/
int main()
{
int a=10, b=20;
int i=100;
/* Local Variable */
/* Local Variable */
printf("%d %d", a, b);

printf("\nLocal i : %d", i);
/* Acceso a la variable local */
printf("\nGlobal i : %d ", ::i);

return 0;
}
/* Acceso a la variable global */
Nota: El Operador de resolucin de mbito ( :: ) slo est disponible

para C++
VIII. Los especificadores de clase de almacenamiento
Hasta este punto de vista en el que ya estamos familiarizados con la
declaracin
de variables. Para definir una variable no basta mencionar slo su
tipo, sino
tambin su "clase de almacenamiento".
De acuerdo con esta seccin de las variables no son slo un "tipo de
datos",
tambin tienen una "clase de almacenamiento".
Las clases de almacenamiento son de 4 tipos
1.
2.
3.
4.
Clase
Clase
Clase
Clase
de
de
de
de
almacenamiento
almacenamiento
almacenamiento
almacenamiento
Automtico
Registro
Estticos
Externos
1. Clase de Almacenamiento Automtico

Palabra clave
Tipo de Auto
------------------------------------------------Storage (Almacn)
Memory
Default Value
Null
Scope (mbito)
Local en el bloque en la que se encuentra
definida
Life (Vida)
Hasta la ejecucin de su bloque
Por ejemplo:
/
* 43_auto.c */
#include <stdio.h>
int main()
{
auto int i, j;
printf("%d %d", i, u);
return 0;
}
2. Clase de almacenamiento Registro

Palabra clave
Registro
-----------------------------------------------------Storage
Registros de la CPu
Default Value
Null
Scope (mbito)
Local en el bloque en la que se encuentra
definida
Life (Vida)
Hasta la ejecucin de su bloque
Por ejempo:
/* 44_register.c */
#include <stdio.h>
int main( )
{
register int i, j;
for(i=1;i<=10;i++)
printf("\n%d", i);
return 0;
}
3. Clase de Almacenamiento Esttico

Palabra clave
statico
--------------------------------------------Storage
Memory
Default Value
Zero
Scope (mbito)
local al bloque en el que la variable
definida
Life (Vida)
El valor de la variable persiste entre
las diferentes llamadas
Por ejempo:
/* 45_static.c */
#include <stdio.h>
void add();
int main()
{
add();
add();
add();
return 0;
}
void add()
{
static int i = 1;
printf("%d\n",i++);
}
4. Clase de Almacemiento externo

Palabra clave
externo
----------------------------------------Storage
Memory
Default Value
Zero
Scope (mbito)
Global
Life (vida)
Mientras la ejecucin del programa no
llegue su fin
Por ejemplo:
/* 46_extern.c */
#include <stdio.h>
int i;
void add();
/* Externa variable */
int main( )
{
extern j=10;
/* Externa variable */
for(i=1;i<=10;i++)
add();
return 0;
}
void add( )
{
j++;
printf("%d %d\n", i, j);
}

Curso de C++ paso a paso: Programacin C - Matrices
1. Introduccin a las matrices

2. Acerca de matrices
3. Elementos de la matriz
4. Pasar matrices a funciones
5. Tipos de matrices
- Matrices de dimensiones simples
1. Aadir elemento
2. Insertar elemento
3. Eliminar elemento
4. Reemplazar elemento
5. Buscar un elemento
6. Supresin de la matriz
7. Clasificacin de una matriz
- Arreglos multidimensionales
Matriz de Operaciones con matrices multidimensionales
1. Introduccin a las matrices
Una variable puede contener un valor constante. Slo un nico valor
constante
y no es posible llevar a cabo ms de un valor en una variable.
En el ejemplo siguiente se muestra el alcance de una variable.
#include <stdio.h>
int main()
{
int sno;
sno = 1001;
sno = 1008;
sno = 1005;
printf("%d", sno);
return 0;
}
Salida: Nada
El programa anterior es capaz de mostrar slo 1005, pero no el resto

de los valores (i,e. 1001, 1008, 1005).
Se puede utilizar el siguiente programa en lugar del programa anterior.
#include <stdio.h>
int main()
{
int sno;
sno 0 = 1001;
sno 1 = 1008;
sno 2 = 1005;
printf("%d", sno);
return 0;
}
Salida: Nada
El programa mostrado encima le devolver una lista de errores, debido a
que
el enfoque est equivocado.
Vamos a continuar con el programa siguiente para obtener 0 errores de
programa
#include <stdio.h>
int main()
{
int sno[3];
sno[0] = 1001;
sno[1] = 1008;
sno[2] = 1005;
printf("%d", sno[2]);
return 0;
}
/* 3 valores insertados */
/* El primer valor insertado 1001 */
/* El siguiente valor insertado 1008 */
/* y el siguiente valor insertado 1005 */
/* Imprime el segundo valor insertado */
Salida: 1005
En el programa anterior, la variable sno puede tener ms de un nmero.
Es fcil, utilizando la tcnica multi-ubicacin, tambin conocida como
matrices.
2. Acerca de matrices
Las matrices contienen una serie de elementos de datos todos del mismo
tipo. Este
tipo puede ser un tipo de datos simple, una estructura o una clase. A los
items de
una matriz se les llama elementos. A los elementos se accede por un
nmero, a este
nmero se le denomina ndice. Los elementos pueden ser inicializados con
los valores
especficos cuando la matriz se define.
Las matrices pueden tener varias dimensiones.
Una matriz de dos dimensiones es una matriz de una matriz. La direccin
de una
matriz puede ser utilizado como un argumento a una funcin, la propia
matriz
no se copia. Las matrices pueden ser utilizadas como datos por los
miembros de las
clases.
Se debe tener cuidado para evitar que los datos que sean colocados en la
memoria
no estn fuera de la matriz.
/* El siguiente programa lee la edad de 4 personas y los muestra por pantalla */

/* 47_arrays.c */
#include <stdio.h>
int main()
{
int age[4], i;
/* Declaramos las dos variables como
integers */
for( i=0; i<4; i++)
{
printf("\n\n(%d de 4) Introducir una edad: ", i); scanf("%d",
&age[i]);
}
for(i=0; i<4; i++)
printf("\nTu has introducido: %d", age[i]);
printf("\n\n");
return 0;
Al igual que otras variables en C, una matriz debe definirse antes de que
pueda
ser utilizada para almacenar informacin. Y, al igual que otras
definiciones,
requiere un tipo de variable y un nombre.
Pero incluye otra caracterstica: el tamao. El tamao especifica cuantos
elementos contendr la matriz. Sigue inmediatamente al nombre, y est
entre
corchetes.
3. Elementos de la matriz
Los items de una matriz se denominan elementos. Una matriz unidimensional
es capaz de almacenar slo un conjunto de valores. Una matriz
bidemensional
acepta los valores tanto de una fila como en una columna.
El primer elemento se almacena en la posicin 0, el segundo en la 1 y as
sucesivamente.
El valor de la matriz se puede inicializar directamente en tiempo de
diseo.
La Inicializacin de matrices es la siguiente ..
void display (float [DISPLAY] [meses]);
4. Pasar matrices a funciones
Las matrices pueden ser utilizados como argumentos en las funciones.
En la declaracin de una funcin, el tipo de datos y el tamao de la
matriz
representan los argumentos de la matriz.
Cuando la funcin se llama, slo el nombre de la matriz se utiliza como
un argumento.
pantalla (ventas);
Programa para aceptar e imprimir 10 elementos
/* 48_ ele10.c */
#include <stdio.h>
#define MAX 10
display(int a[MAX])
{
int i;
for(i = 0;i<MAX; i++)
printf("\n%d",,a[i]);
}
int main()
{
int x[MAX], i;
for(i=0;i<MAX; i++)
scanf("%d",&x[i]);
display(x);
return 0;
}
Devolver un array de valores desde las funciones tambin es posible,

pero debemos tener claro el concepto de los punteros. Por favor, mire
el tema de los punteros para ms informacin.
5. Clasificacin de Arrays
Arrays de dos tipos
1. Matrices dimensionales simples (unidimensionales)
2. Matrices multidimensionales
1. Matrices unidimensionales
Un array unidimensional es una coleccin de elementos en o una fila
o una columna.
En un array unidimensional se pueden hacer las siguientes operaciones:
1.
2.
3.
4.
5.
6.
7.
Agregar elemento
Insertar elemento
Borrar elemento
Remplazar elemento
Buscar elemento
Borrar el array
Ordenar el array
El siguiente programa muestro lo aprendido descrito arriba.

========= PRINCIPIO DEL PROGRAMA =========
/* ARRAY FUNCTIONS */
/* 49_sarray.c */
#include <stdio.h>
#define N 100
#define M 10
int i,j,r,c,r1,r2,c1,c2;
/* Lectura de los elementos del array */
int accept_values(int a[N])
{
int n;
printf("\nCuantos valores vas a introducir (por ejemplo, 4)..? ");
scanf("%d",&n);
printf("\nIntroducuzca los valores y pulse intro..\n");
for(i=0;i<n;i++)
scanf("%d",&a[i]);
return n;
}
/* Mostrar los elementos del array */
void display(int a[N],int n)
{
printf("\n Los elementos del Array son...");
for(i=0;i<n;i++)
printf("\n%d",a[i]);
/* Borrar los elementos del array */

int delete_cell(int a[N],int n)
{
int pos;
char ch;
printf("\nIntroducir la posicin de los elementos para ser borrados:
");
scanf("%d",&pos);
for(i=pos-1;i<n;i++)
a[i] = a[i+1];
n--;
printf("\n Deseas continuar..(s/n)?");
ch = getchar();
if(ch == 's') delete_cell(a,n);
return n;
}
/* Insertar elementos al array */
int insert_cell(int a[N],int n)
{
int pos, nuevo;
char ch;
printf("\nIntroduzca los elementos a ser insertado: ");
scanf("%d",&nuevo);
printf("\nIntroducir la posicin del elemento: "); scanf("%d",&pos);
for(i=n;i>=pos;i--)
a[i] = a[i-1];
a[pos-1] = nuevo;
n++;

ch = getchar();
if(ch=='s') insert_cell(a,n);
return n;
/* Aadir elementos a un array existente */

int append_cell(int a[N],int n)
{
int pos, nuevo;
char ch;
printf("\nIntroducir el elemento a ser agregado: ");
scanf("%d",&nuevo);
a[n] = nuevo;
n++;
ch = getchar();
if(ch=='y')append_cell(a,n);
return n;
}
/* Ordenar la lista de elementos de forma descendiente */
void sort_list_descend(int a[N],int n)
{
int temp;
for(i=0;i<n;i++)
for(j=i;j<n;j++)
if(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf("\nLos elemenos ordenados de forma descendiente son...");
}
/* Ordenar la lista de elementos de forma ascendiente */
void sort_list_ascend(int a[N],int n)
{
int temp;
for(i=0;i<n;i++)
for(j=i;j<n;j++)
if(a[i] > a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf("\nLos elemenos ordenados de forma descendiente son..");
}
/* Buscar el elemento ms grande y ms pequeo de un array */
void small_big(int a[N],int n)
{
int temp;
for(i=0;i<n;i++)
for(j=i;j<n;j++)
if(a[i] < a[j])
{
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
printf("\nEl elemento ms pequeo es : %d",a[n-1]);
printf("\nEl mayor elemento es : %d",a[0]);
}
/* Buscar un elemento en un array */
void search(int a[N],int n)
{
int target, temp=0;
printf("\n Introduzca el elemento a buscar: ");
scanf("%d",&target);
for(i=0;i<n;i++)
if(a[i] == target)
{
printf("\nEncontrado en la posicin nmero: %d",i+1);
temp = 1;
}
if(temp == 0)
printf("\n No encontrado.");
}
/* Programa principal */
/* Demostrar operaciones con arrays */
#define m 100
int main()
{
int a[m],n; char ch;
/* clrscr(); */
n = accept_values(a);
do
{
printf("\n Men principal, eliga una opcin\n\n\n");
printf("\n 1 - Append_cell");
printf("\n 2 - Delete_cell");
printf("\n 3 - Insert_cell");
printf("\n 4 - Sort_list_descend");
printf("\n 5 - Sort_list_ascend");
printf("\n 6 - Small_big");
printf("\n 7 - Search");
printf("\n 8 - Remove_list");
printf("\n 9 - Exit");
printf("\n\n Elegir una opcin: ");
ch = getchar();
printf("\n");
switch(ch)
{
case '1': n = append_cell(a,n); break;
case '2': n = delete_cell(a,n); break;
case '3': n = insert_cell(a,n); break;
case '4': sort_list_descend(a,n); break;
case '5': sort_list_ascend(a,n); break;
case '6': small_big(a,n); break;
case '7': search(a,n); break;
case '8': n = 0; break;
case '9': printf("\nDeseas terminar el programa."); break;
}
display(a,n);
printf("\nDeseas ejecutarlo nuevamente..(9 - Fin/n)?");
ch = getchar();
}
while(ch!='9');
return 0;
}
========= FIN DEL PROGRAMA =========

2. Array de doble dimensin
Un array de doble dimensin es una coleccin de elementos que dispone de
una fila y una columna.
Un array multidimensionar acepta todas las operaciones de los arrays
unidimensionales
Un array multidimensionar es utilizado comunmente en las areas de

matrices
para apredender ms en este sentido siga el programa de abajo.
MATRIX FUNCTIONS
========= PRINCIPIO DEL PROGRAMA =========
/* 50_menumat.c */
#define N 100
#define M 10
int i, j, r, c, r1, r2, c1, c2;
/* Read the values for a MATRIX */
void read_matrix(int A[M][M])
{
printf("\nHow many rows? ");
scanf("%d",&r);
printf("\nHow many columns? ");
scanf("%d",&c);
for(i=0;i<r;i++)
for(j=0;j<c;j++)
scanf("%d",&A[i][j]);
}
/* Write the values of a MATRIX */
void disp_matrix(int A[M][M])
{
for(i=0;i<r;i++)
{
for(j=0;j<c;j++)
printf("%5d",A[i][j]);
printf("\n");
}
}
/* To find the TRANSPOSE for a MATRIX of ANY ORDER */
void tra_matrix_1(int T[M][M],int A[M][M])
{
printf("\nTranspose of A is\n");
for(i=0;i<c1;i++)
{
for(j=0;j<r1;j++)
{
T[i][j] = A[j][i];
printf("%5d",T[i][j]);
}
printf("\n");
}
}
/* To ADD two MATRICES ( possible,only if they are of EQUAL ORDER ) */
void add_matrix(int C[M][M],int A[M][M],int B[M][M])
{
for(i=0;i<r;i++)
for(j=0;j<c;j++)
C[i][j] = A[i][j] + B[i][j];

printf("\nSum of A and B is");
/* To MULTIPLY MATRICES of ANY ORDER ( provided they follow the

MATRIX MULTIPLICATION RULE ) */
void mul_matrix_1(int C[M][M],int A[M][M],int B[M][M])
{
int k;
printf("\nProduct of A and B is..\n");
printf("\nMatrix C\n");
for(i=0;i<r1;i++)
{
for(j=0;j<c2;j++)
{
C[i][j]=0;
for(k=0;k<r2;k++)
C[i][j] = C[i][j]+(A[i][k]*B[k][j]);
printf("%5d",C[i][j]);
}
printf("\n");
}
}
/* To SUBTRACT two MATRICES ( possible,only if they are of EQUAL ORDER )
*/
void sub_matrix(int C[M][M],int A[M][M],int B[M][M])
{
for(i=0;i<r;i++)
for(j=0;j<c;j++)
C[i][j] = A[i][j] - B[i][j];
printf("\nDifference of A and B is");
}
/* A MENU driven program to perform MATRIX operations */ #include
<stdio.h>
#include <conio.h>
int main()
{
int A[M][M],B[M][M],C[M][M],T[M][M]; char ch;
clrscr( );
printf("\nEnter matrix A elements..\n"); read_matrix(A); r1=r; c1=c;
printf("\n Matrix A\n"); disp_matrix(A);
printf("\nEnter matrix B elements..\n"); read_matrix(B); r2=r; c2=c;
printf("\n Matrix B\n");disp_matrix(B);
do {
printf("\n1:Addition");
printf("\n2:Subtraction");
printf("\n3:Multiplication");
printf("\n4:Transpose");
printf("\n5:Exit");
printf("\nEnter your choice.."); ch = getche();
switch(ch)
{
case '1':
if(r1==r2 && c1==c2)
{
add_matrix(C,A,B);printf("\nMatrix C\n");
disp_matrix(C);
}
else
{
printf("\nYour entered values of r1,r2 && c1,c2
are not equal,");
printf("\nhence I cannot do this Matrix
Addition.");
printf("\nPlease enter the correct matrices.");

} break;
case '2':
if(r1==r2 && c1==c2)
{
sub_matrix(C,A,B);printf("\nMatrix C\n");
disp_matrix(C);
}
else
{
printf("\nYour entered values of r1,r2 && c1,c2
are not equal,");
printf("\nhence I cannot do this Matrix
Subtraction.");
printf("\nPlease enter the correct matrices.");
} break;
case '3':
if(c1==r2)
mul_matrix_1(C,A,B);
else
{
printf("\nColumns(c1) of Matrix A are NOT EQUAL
TO");
printf(" Rows(r2) of Matrix B.");

printf("\nHence I cannot do this Matrix
Multiplication.");
printf("\nPlease enter matrices such that c1 ==
r2.");
} break;
case '4':
%d",c1,r1); break;
printf("\nOrder of Matrix A is %d x %d",r1,c1);

tra_matrix_1(T,A);
printf("\nOrder of A transpose is %d x
case '5': printf("\nThis will terminate your program.");

break;
}
printf("\nDo you wish to run again...[y/n]?"); ch=getche();
}while(ch!='5');
return 0;
========= FIN DEL PROGRAMA =========

Cadenas
- Introduccin
- Caractersticas de las cadenas
- Operaciones con Cadenas
1.
2.
3.
4.
5.
6.
7.
Definicin de Strings
Inicializacin de Strings
Leyendo e imprimiendo Strings
Leyendo blancos embebidos
Longitud de una cadena
Cadenas y funciones
Array de Strings
Introduccin.
Los Arrays son usados para examinar cadenas, Generalmente los strings son
arrays
del tipo cadena.
Una cadena es una coleccin de caracteres incluyendo el espacio donde una
palabra es una coleccin
de caracteres excluyendo el espacios. Todas las variables del tipo string deben
tenerminar con
los caracteres \ 0 null y el valor de inicio que comienza por 0
Cada cadena tiene las siguientes caractersticas:
1. Debe ser una coleccin de caracteres (es decir, caracteres, nmeros y

caracteres especiales).
2. Cada cadena debe terminar con un carcter nulo (es decir, '\0')
3. Un nico nmero positivo llamado ndoce identifica a cada caracter de una
cadena.
4. El valor ndice debe comenzar con 0.
5. Es posible el acceso aleatorio de caracteres de una cadena
6. Una cadena que se debe declarar con un tamao fijo, como las matrices.
Por ejemplo, consideremos el siguiente ejemplo:
char str = "magic";
Una variedad de funciones de la biblioteca de cadena se utilizan para

manipular las
cadenas. Una matriz de cadenas es una matriz de matrices de tipo char.
Operaciones con cadenas.
Las cadenas pueden aceptar las siguientes operaciones.
Podemos realizar muchas mejores operaciones utilizando las funciones de la

librera
de cadenas.
1. Definicin de Strings
2. Inicializacin de Strings
3. Leyendo e imprimiendo Strings
4. Leyendo blancos embebidos
5. Longitud de una cadena
6. Cadenas y funciones
7. Array de Strings
1. Definicin de Strings
Cada variable debe ser declarada al comienzo del programa.

La definicin de variable de cadena es la siguiente.
Las cadenas deben ser inicializadas de la siguiente manera:
1. Asignacin directa indicando un tamao.
char name[10] = "Ashitha";

Asignamos "Ashitha" a name[10], el resto contendr espacios en blanco
2. Asignacin directa sin especificar tamao.
char name[] = "Ashitha";

Asignamos "Ashitha" a name y se fijar el ancho hasta el tamao de la
constante.
3. Asignacin en tiempo de diseo
char name[10];
strcpy(name, "Ashitha");
Utilizando las funciones de cadena es posible.
Pero en C no se soporta un tipo de asignacin como:
name = "Ashitha";
4. Asignacin en tiempo de ejecucin.
char name[10];
scanf("%s", name);
Acepta y asigna una constante a la variable en tiempo de ejecucin
3. Leyendo e imprimiendo Strings
C provee varios tipos de funciones de cadena para leer e imprimir una cadena
constante.
Como las listadas abajo.
Sentencias Input.
getch
getche
getchar
gets
scanf
/* no es un estandar */
/* no es un estandar */
Sentencias de salida.
putch
putchar
puts
printf
===============================================
========================
/* Program to accept and display a string */
/* 51_strings.c */
#include
int main()
{
char str[20];
scanf("%s", str);
printf("%s" str);
return 0;
}
===============================================
========================
===============================================
========================
/* Program to accept and display a string with a prompt */
/* 52_strings.c */
#include
int main( )
{
char str[20];
printf("Enter a string :"); scanf("%s", str);
printf("\nYou entered : %s", str);
return 0;
}
===============================================
========================
4. Leyendo blancos embebidos
scanf acepta cadenas, cadenas que consisten en una sola palabra,

pero nada escrito con una cadena.
Por ejemplo. Introduzca la cadena: la Ley es un pozo sin fondo.

Habr introducido slo: la
Para leer texto que contenga varios espacios en blanco usaremos

otra funcin: gets().
===============================================
========================
/*read string with embedded blanks */
/* 53_gets.c */
const int MAX = 80;
int main()
{
char str[MAX];
print("Enter a string :"); gets(str);
printf("You entered :"); puts(str);
return 0;
}
===============================================
========================
5. Longitud de una cadena
Cada cadena tiene su longitud fija dependiendo de su constante.

El siguiente programa demuestra, cmo encontrar la longitud de la cadena
===============================================
========================
/* To find the length of a given string */
/* 53_length.c */
#include
int main()
{
int i=0;
char str[50];
printf("Enter a string "); gets(str);
while(str[i] != '\0') i++;
printf("Length is %d", i);
return 0;
}
===============================================
========================
6. Cadenas y funciones
Una funcin es un bloque independiente de instrucciones que realiza una tarea

especfica.
La mejor manera de organizar cadenas.
Los siguientes son ejemplos de organizacin de cadenas mediante funciones.
===============================================
========================
/* Program to find the length of a string */
/* 54_len.c */
#include
int len_str(char s[]);
int main()
{
int l; char str[50];
l = len_str(str);
printf("\nLength of string : %d", l);
}
int len_str(char s[])

{
int l=0;
while(s[l] != '\0') l++;
return l;
}
===============================================
========================
===============================================
========================
/* Program to accept and print a string */
/* 55_str.c */
#include
void disp_str(char s[]);
int main()
{
char str[50];
disp_str(str);
return 0;
}
void disp_str(char s[])

{
int i=0;
while( s[i] != '\0' ) putch(s[i++]);
}
===============================================
========================
7. Array de Strings
Las matrices se utilizan para examinar cadenas, en general, las cadenas son
del tipo matriz.
As, podemos tener acceso a una matriz de cadenas.
Los siguientes ejemplos ilustran, Cmo se organiza una matriz de cadena.
===============================================
========================
/* Program to display an array of strings */
/* 56_display.c */
#include
void main()
{
char week[7][] = { "Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday" };
int i;
for( i = 0; i<7; i++) puts(week[i]);
}
===============================================
========================
===============================================
========================
/* Program to accept and display an array of strings */
/* 57_strings.c */
#include
void main()
{
char names[7][10]; int i;
for( i = 0; i<7; i++) gets(names[i]);
for( i = 0; i<7; i++) puts(names[i]);
}

Programacin paso a paso en C++ -- Punteros.
1. Acerca de la memoria
2. Esquema de direccionamiento
3. Cmo encontrar la direccin de una variable
4. Punteros
5. Aritmtica de punteros
6. Punteros y matrices
7. Punteros y cadenas
8. Glosario
El Equipo tiene la funcin de almacenar los datos y manipularlos. El

Almacenamiento de
datos requiere un dispositivo de almacenamiento, para un cmodo
almacenamiento y
recuperacin de datos con rapidez y precisin. Generalmente el equipo tiene
puede
comprometer los datos con los mtodos de almacenamiento.
Programacin paso a paso en C++ -- Punteros.

1.
2.
3.
4.
5.
6.
7.
8.
Acerca de la memoria
Esquema de direccionamiento
Cmo encontrar la direccin de una variable
Punteros
Aritmtica de punteros
Punteros y matrices
Punteros y cadenas
Glosario
El Equipo tiene la funcin de almacenar los datos y manipularlos. El
Almacenamiento de
datos requiere un dispositivo de almacenamiento, para un cmodo
almacenamiento y
recuperacin de datos con rapidez y precisin. Generalmente el equipo
tiene puede
comprometer los datos con los mtodos de almacenamiento.
SRAM
Memoria Esttica de acceso aleatorio (Static Random Access
Memory)
DRAM
Memoria Dinmica de acceso aleatorio (Dynamic Random
Access Memory)
EEPROM
Memoria borrable, electricamente programable, de slo
lectura.
(Electrically Erasable Programmable Read Only Memory)
Los chips de memoria pueden almacenar los datos, instrucciones y
resultados intermedios
y finales. La la memoria est organizada en bytes, cada uno capaz de
almacenar un
carcter de informacin. Cada byte de la memoria tiene una direccin o
ubicacin que es
nico y le identifica. El tamao de la memoria se mide en kilobytes (KB),
megabytes
(Mb), gigabytes o terabytes (TB).
RAM:
La memoria es un dispositivo con la capacidad de almacenar informacin.

La asignacin de recursos de memoria es vital cada vez que una variable
es declarada
en un programa en C. El tipo de variable decide el nmero de bytes de
memoria que se
asignar a cada variable.
2. Esquema de direccionamiento
(*) Nexo comn donde se unen coincidencias.
+---------------+
|Hasta 4/32 Gb |
|
|<---------80386/80486
+---------------+
/ |
|16 Mb
|<-------* /
|
Memoria
|<======\ /
|
Extendida |
\/
|
|
/\
+---------------+
/ \
| Memoria Alta |<-----*----80286
|1024 Kb (1 Mb) |
/
|
|
|<===/=++
|
+---------------+
/
\\
|
|640 Kb
|<-*-----\\--+
|
Memoria
|
\\
| Convencional |<======= 8088/8086
+---------------+
Esquema del contenido de la memoria RAM
+---------------+
|
|
+---------------+
|
|
+---------------+
|
5
|641.222 ==> Programa usuario
+---------------+
a --> Identificador (Variable)
.
.
5 --> Contenido de la variable
.
. 641.222 --> Direccin de la variable (a)
.
.
+---------------+
|
|byte 1
+---------------+
|
|byte 0
+---------------+
1. La Memoria RAM es una memoria temporal y una parte del equipo.

2. Pueden contener el valor del programa.
3. Cada byte en la RAM es identificado con un nmero positivo nico
llamado
direccin.
4. Las direcciones son como nmeros, al igual que para casas en una
calle.
5. El nmero comienza en 0 y contina 1-2-3 y as sucesivamente.
6. Si tenemos 640 KB de memoria la direccin ms alta es 655.359, para 1

mb de
memoria es 1.048.575.
7. Nuestro programa, cuando se carga en memoria, ocupa un determinado
intervalo de
estas direcciones.
8. Esto significa que todas las variables y cada funcin en el programa
se inicia
en una direccin particular.
3. Cmo encontrar la direccin de una variable
En la ltima seccin punto 8 le dice que cada funcin/variable se inicia
a una
direccin particular. Las direcciones son nmeros positivos nicos en
hexadecimal
Encontrar la direccin de una variable es una tarea sencilla mediante el
operador & (direccin
de).
/* 58_address.c */
#include <stdio.h>
int main()
{
int a = 10;
printf("\n El valor de A es : %d", a);

printf("\n La direccin de A es : %d", &a);
return 0;
Cambie el formatos de los valores marcados arriba con el siguiente

formato para
obtener la direccin absoluta en hexadecimal
0x%x
Ejemplo
printf("\nLa direccin de A es : 0x%x", &a);
Programa que busca la direccin de la funcin disp()
/* 59_address.c */
#include <stdio.h>
void disp()
{
printf("\nHola");
printf("\nCmo");
printf("\nestas?");
}
int main()
{
disp();
printf("\nLa direccin de disp() : 0x%x", &disp);
return 0;
}
4. Punteros
De acuerdo a la ltima seccin sabemos cmo encontrar y mostrar la
direccin de un
variable o funcin.
Esta vez aprenderemos acerca de cmo almacenar la direccin de una
variable o funcin en
otra variable.
Nota: Las variables pueden contener valores constantes.
Pruebe con las siguientes:
int a, b;
a = 5;
b = &a;
/* Valida */
/* No valida */
<b>Intentemoslo otra vez con lo siguiente</b>

int a, *b;
a = 5;
b = &a;
/* Valida */
/* Valida */
b = &a; correcto! S, las variables (variables generales) son incapaces

de mantener
direcciones. Pero las variables precedidas con '*' (variables puntero)
son capaces
de mantener tanto en valores constantes, as como la direccin de otras
variables
y funciones.
Puntero: Variable que contiene valores de una direccin.
Variables (en general)
Las variable generales son capaces de realizar slo operaciones
con valores constantes
Variables Puntero: (variables precedidas con '*')
Las variables puntero puede realizar dos operaciones almacenar valores

constantes,
as como valores de la direccin de otras variables y funciones
La referencia a / Puntero a / contenido en la direccin (*)
int *ptr;
Para los no iniciados se trata de una sintaxis bastante extraa. El

asterisco
significa puntero a (una direccin). As, la declaracin definira ptr
como
un puntero a una variable de tipo int. Esta es otra forma de decir que la
variable
puede contener la direccin que contine una variable de valor integer
Si lo llamamos, el tipo puntero se podra escribir como la siguiente
declaracin.
pointer ptr;
/* invalido */
El problema es que el compilador necesita saber qu tipo de variable es

el puntero
al que apunta.
Declaracin de una variable puntero
char *cptr;
int *iptr;
float *fptr;
struct emp *e;
/*
/*
/*
/*
Puntero
Puntero
Puntero
Puntero
a
a
a
a
character */
int */
float */
datos abstractos emp e */
Accediendo a la variable a travs de su direccin:

Aqu hay una forma especial de acceder al valor de una variable
utilizando la
direccin referente a su nombre.
/* 60_addr.c */
#include <stdio.h>
int main()
{
int vari1 = 11;
int *ptr;
/* variable var1 = 11 */
/* Variable ptr as pointer to */
ptr = &vari1;
almacena en ptr */
/* Devuelve la direccin de var1 y la
printf("El valor de vari1 es %d", *ptr);

return 0;
}
Si la sentencia es printf ("%d", ptr); entonces muestra el valor de ptr,

lo que significa
la direccin vari1, Pero la sentencia de abajo puede mostrar el contenido
de la direccin
que almacena la direccin de ptr.
/* 61_ptrdemo.c */
#include <stdio.h>
int main()
{
int a = 10, *p;
Entero y "p" como puntero */
p = &a;
direccin de "a" a "p" */
printf("\nEl valor de A :
de "a" */
printf("\nLa direccin de
de "a" */
printf("\nEl valor de P :
de "p" */
printf("\nLa direccin de
de "p" */
printf("\nEl contenido de
&a */
return 0;
}
/* "a" como
/* Asigna la
%d", a);
/* Contenido
A : 0x%x", &a);
/* Direccin
0x%x", p);
/* Contenido
P : 0x%x", &p);
/* Direccin
P es : %d", *p);
/* Puntero de
5. Aritmtica de punteros.
Todas las variables soportantan operaciones aritmticas, tan bien como
pudieran soportar
las operaciones normales con variables en. C/C++ tambin soporta cuatro
metdos de adicin,
sustraccin, incrementacin e incrementacin de un smbolo.
+
++
--
Adicin
Subtractin
Incrementacin
Decrementacin
Nota: La principal caracterstica de la aritmtica de punteros es que

trabajan en
bytes con referencias a sus tipos de variable.
/* 62_ptr.c */
/* Demonistration of pointer arithmetic */
#include <stdio.h>
int main()
{
int a, *p;
a = 100;
p = &a;
(*p)++;
/* Increment pointer to (content at address) by 1
*/
printf("%d", *p);
return 0;
}
Salida: 101
Demostracin de la aritmtica de puntero, incrementando el valor de la
direccin.
/* 63_ptr.c */
/* Increment the address value by 1 */
#include <stdio.h>
int main()
{
int a, *p;
/* Variable a, p puntero */
a = 100;
/* Asignamos a a=100 */
p = &a;
/* Asignamos a p la direccin de "a" */
*p++;
/* Incrementador el valor direccin de p
en 1 */
printf("%d", *p);
return 0;
}
Salida: Salida inesperada.
El programa anterior muestra los operadores aritmticos incrementado el
valor
de las direccion de "A" en "p". "p" es una variable de puntero a "A" que
se le
asigna 100, as como a p se le asigna la direccin de A.
Ahora *p++ efecta un incremento, afectado a 2 bytes de memoria para
obtener una
nueva direccin y su su contenido.
*************
Si se tratara de (*p)++, incrementaramos el contenido apuntado por "p"
que es 100,
incrementando el resultando en 101.
*************
6. Matrices y Punteros
En C/C++ los tipos de datos punteros y matrices se parecen entre s.

Las referencias "elemento de la matriz", as como "la variable puntero",
ambos se utilizan para
contener la direccin de elementos de datos en la memoria.
Piense que el puntero trabaja sobre una inmensa matriz, que es la memoria
de su equipo.
En C++ los tipo de datos punteros y arrays
char name[20];
o
char *name ;
char months[12][10];
o
char **months;
Hay una estrecha relacin entre punteros y matrices. He aqu un
comentario
matrices.
/* 64_ptrarr.c */
#include <stdio.h>
int main()
{
int i, a[5] = { 56, 43, 78, 98, 12 };
for( i = 0, i < 5; i++)
printf("\n%d", a[i]);
return 0;
}
Hay una posibilidad de acceder a elementos de matriz utilizando la

notacin de punteros.
Encontrar la salida del siguiente programa.
/* 65_ptrarr.c */
#include <stdio.h>
int main()
{
int i, a[5] = { 56, 43, 78, 98, 12 };
for( i = 0, i < 5; i++)
printf("\n%d", *(a+ i) );
return 0;
}
Observe el siguiente programa:
/* 66_ptrarr.c */
#include <stdio.h>
int main()
{
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;
p = a;
for( i = 0, i < 5; i++)
printf("\n%d", *(p+ i) );
return 0;
}
He aqu un mtodo ms sencillo para imprimir los elementos de la matriz

dada (el tamao no
es necesario).
/* 67_ptrarr.c */
#include <stdio.h>
int main()
{
int i, a[ ] = { 56, 43, 78, 98, 12 }, *p;
p = a;
while (*p)
/* or for(int i = 0; i<5; i++ ) */
printf("\n%d", *p++);
return 0;
}
7. Punteros y cadenas
Una cadena es un conjunto de caracteres con espacios incluidos. Esta vez
hablamos
sobre cmo manejar cadenas mediante punteros. No habr ms debate para
menor confusin.
Esta es la tarea simple de verificar tanto punteros como matriz de
cadenas.
Hay una sutil diferencia entre las cadenas y punteros, segua el programa.
/* 68_ptrstr.c */
#include <stdio.h>
int main()
{
char str1[ ] = "You would like to explore C.";
char *str2 = "You would like to explore C.";
puts(str1);
puts(str2);
str1++; /* Invalid expression */

str2++; /* Valid expression */
puts(str2); /* prints ou would like to */
return 0;
Cadenas como argumentos de funcin

Una variable puntero es ms flexible que las variables de la matriz, este
programa lo
demuestra y muestra una cadena con notacin de punteros.
/* 69_ptrarr.c */
#include <stdio.h>
void disp(char *p);
int main()
{
char str[ ] = "Hello!!..Hello!!.. Pointers can handle it?";
disp(str);
return 0;
}
void disp(char *p)
{
while(*p)
printf("%c", *p++);
}
Array de punteros a cadenas

No es una desventaja almacenar una matriz de cadenas, en que los sub
arrays
que mantienen la cadena todos deben tener la misma longitud. As que el
espacio se
pierde cuando las cadenas son ms cortas que los sub arrays
Aqu est la solucin:
/* 70_strings.c */
#include <stdio.h>
int main()
{
char *weeks[7 ] = { "Sunday", "Monday", "Tuesday", "Wednesday",
"Thursday",
"Friday", "Saturday" };
int i;
for( i = 0; i<7; i++)
puts(weeks[ i ] );
return 0;
Cuando las cadenas no son parte de una matriz, C/C++ los coloca
memoria contigua,
As que no hay prdida de espacios.
en la
/* An example program to hold an array of pointers of type int */

/* 71_ptrarr.c */
#include <stdio.h>
int main()
{
int *arr[4]; /* Array of int pointers */
int i = 31, j = 5, k = 19, l = 71, m;
arr[0]
arr[1]
arr[2]
arr[3]
=
=
=
=
&i;
&j;
&k;
&l;
for(m = 0; m <= 3; m++)

printf("\n%d", *(arr[m]) );
return 0;
}
Una mirada sobre las funciones de biblioteca

Ya estamos familiarizados con las funciones de cadena estndar. Tienen
cadena
argumentos que se especifican usando la notacin de puntero,
Si tenemos claro el concepto de punteros y cadenas, podemos escribir
nuestra propias
funciones de cadena.
He aqu un programa ejemplo para copiar cadenas.
/* Copies one string to another with pointers */

/* 72_strcpy1.c */
#include <stdio.h>
void strcpy1(char * dest, char *src);
int main()
{
char *str1 = "How can I learn more about C/C++ !!!";
char *str2;
strcpy1(str2, str1);
puts(str2);
return 0;
}
void strcpy1(char * dest, char *src)
{
while(*src)
*dest++ = *src++;
*dest = \0;
}

10. Programacin C/C++ paso a paso - Estructuras -Structure-
1. Introduccin
2. Declaracin de la Estructura
3. Definicin de una variable de estructura
4. Inicializar una variable de estructura
5. Asignacin directa de estructuras
6. Clculo del tama&nacute;o de la estructura
7. Estructuras anidadas
8. Matriz de estructuras
9. Las matrices dentro de las estructuras
10. Pasar estructuras a una funcin
11. Devolver Estructuras de Funciones
12. Punteros a estructuras
13. Estructuras que contienen punteros
14. Estructuras Auto referenciadas.
1. Introduccin
2. 10. Programacin C/C++ paso a paso - Estructuras -Structure1. Introduccin

6. Clculo del tamao de la estructura
7. Estructuras anidadas
8. Matriz de estructuras
9. Las matrices dentro de las estructuras
10. Pasar estructuras a una funcin
11. Devolver Estructuras de Funciones
12. Punteros a estructuras
13. Estructuras que contienen punteros
14. Estructuras Auto referenciadas.
1. Introduction
int a[4] = { 3, 4, 5, 6 };
int a[4] = { 3, 4.23, 5, 6 };
int a[4] = { 3, "Siglov", 5,3}
/* Expresin vlida */
/* Expresin invlida */
/* Expresin invlida */
Por qu las dos ltimas expresiones no son vlidas? Una matriz

puede almacenar valores del mismo tipo. En cambio una
estructura puede tener ms de un tipo de datos de acuerdo a su
definicin.
* Un grupo de una o ms variables de tipos diferentes de datos
organizados conjuntamente bajo un mismo nombre se denomina
una estructura o
* Una coleccin de heterogneos (distintos) tipos de datos
agrupadas bajo un mismo nombre se denomina una estructura o
* Una estructura es un conjunto de variables simples. La
variable en una estructura puede ser de diferentes tipos. Los
datos los elementos de una estructura se llaman
miembros de las estructuras.
Cuando una estructura es definida todo el grupo queda referenciado
a travs del nombre de la estructura. Los componentes individuales
presentes en la estructura son llamados como miembros de la
estructura y pueden ser accedidos y procesados por separado.
Ejemplo:
3.
4. struct date
{
int day;
int month;
int year;
};
struct student
{
int sno;
char name[20];
int marks;
float avg;
};
5.
6.
Para la definicin de una variable de estructura es la
misma que la de la definicin de un caulquier tipo de datos
como por ejemplo int.
Ejemplos
7.
8.
+) */
C++
int a;
date d;
/* valido */
/* valido (Pero slo en C+
struct date d;
/* valido tanto en C como
*/
9.
10.
Los miembros de la estructura se pueden inicializar al igual que
otras
variables. Esto se puede hacer en el momento de la declaracin o en
el tiempo de diseo.
1. Inicializacin en Declaracin.
11.
12. struct ddate
{
int day;
int month;
int year;
} d = { 06, 01, 2011 };
13.
14.
2. Inicializacin en Definicin
struct ddate d = { 06, 01, 2011 };
1. Iniciacin en tiempo de diseo:
ddate d;
d.day = 06;
d.month = 01;
d.year = 2011;
4. Inicializacin en tiempo de ejecucin:
scanf("%d%d%d", &d.day, &d.month, &d.year);
Ejemplo
15.
16. /* Escribir un programa para aceptar e imprimir los detalles de
un empleado */
/* 73_struct.c */
#include <stdio.h>
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e;
printf("Introducir el nmero de empleado
:"); scanf("%d",
&e.eno);
printf("Introducir el nombre de empleado
:"); scanf("%s",
e.name);
printf("Escriba el salario del empleado
:"); scanf("%d",
&e.sal);
printf("\n\nLos detalles del empleado son los siguientes.:\n");
printf("%d
%s
%d\n", e.eno, e.name, e.sal);
return 0;
}
17.
18.
La asignacin de ms de una variable es posible utilizando
estructuras.
19.
20. struct emp a, b = {1001, "Vimal", 6700.00 };
a = b;
/* Valid */
printf("%d %s %d" , a.eno, a.name, a.sal );
21.
22.
Salida:
1001 Vimal 6700.00
6. Clculo del tamao de la estructura
Cualquier tipo de dato en C/C++ tiene un tamao especfico, por
ejemplo "int" tiene dos bytes de tamao, float tiene 4 bytes y
as, cualquier cosa. Aqu esta una forma de encontrar el tamao
de una variable de la estructura.
sizeof :tamao de
Esta funcin es utilizada para averiagar el

una variable.
23.
24. printf("%d", sizeof(int));
printf("%d", sizeof(float));
printf("%d", sizeof(struct emp));
/* 2 */
/* 4 */
/* Muestra el tamao
de la estructura emp */
25.
26.
7. Estructuras anidadas.
Estructura con estructuras en conocido como estructuras anidadas.
Para acceder a los miembros de la estructura anidada tenemos que
aplicar el punto
operador dos veces para los miembros de la estructura de la
llamada.
Ejemplo.:
27.
28. /* programa para demostrar estructura anidada con la estructura
de los empleados */
/* 74_nested.c */
#include <stdio.h>
struct emp
{
int eno;
char name[10];
float sal;
struct
{
} addr;
/* Estructura anidada */
street char[10];
city char[10];
};
int main()
{
struct emp e;
printf("\n\nIntroduzca emp_no, emp_name, emp_sal, street, city:
");
scanf("%d%s%d%s%s", &e.eno, e.name, &e.sal, e.addr.street,
e.addr.city );
printf("\n\nLos detalles del empleado son los siguientes:\n\n");
printf("%d%s%d%s%s", e.eno, e.name, e.sal, e.addr.street,
e.addr.city );
return 0;
}
29.
30.
8. Array de Estructuras
Podemos crear una matriz de estructuras. La matriz tendr
estructuras
individuales como sus elementos.
31.
32. /* Escribir un programa para aceptar e imprimir los detalles de
un empleado */
/* 75_array.c */
#include <stdio.h>
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e[10];
int i;
for(i = 0; i<10; i++)
{
printf("Introducir nmero empleado
&e[i].eno);
printf("Introducir nombre empleado
e[i].name);
:"); scanf("%d",
:"); scanf("%s",
printf("Introducir sueldo empleado

&e[i].sal);
}
:"); scanf("%d",
printf("\n\nLos detalles del empleado son los siguientes.\n");

for(i = 0; i<10; i++)
printf("\n%d
%s
%d", e[i].eno, e[i].name,
e[i].sal);
}
return 0;
33.
34.
Nada es nuevo en el programa anterior. Todo el programa es el mismo

como simple programa estructurado, excepto los datos marcados.
9. Arrays dentro de Structures
Puede haber una situacin en la que quiera utilizar matrices dentro
de
estructuras. Cmo lograr arrays de estructuras. Aqu est el
enfoque
con un simple programa.
35.
36. /* Programa para aceptar e imprimir informacin de los
estudiantes */
/* 76_array.c */
#include <stdio.h>
struct stud
{
int sno;
char name[10];
int marks[5];
/* Array dentro de
estructura */
};
int main()
{
struct stud s;
int i;
printf("Escriba el nmero del estudiante: ");
scanf("%d", &s.sno);
printf("Escriba el nombre del estudiante: ");
scanf("%d", s.name);
for( i = 0; i<3; i++)
{
printf("Introducir estudiantes marcadas
"); scanf("%d", &s.marks[i]);
}
printf("\n\nLos registros de los estudiantes son los
siguientes.\n");
printf("%d %s %d %d %d", s.sno, s.name, s.marks[0],
s.marks[1], s.marks[2] );
return 0;
}
37.
38.
10. Pasar Structures a Functions
Es posible enviar estructuras completas a funciones como argumentos
en la llamada a una funcin. La variable de estructura es tratada
como cualquier variable ordinaria.
39.
40. /* Programa que pasa una variable de estructura a una funcin */
/* 77_funct.c */
#include <stdio.h>
struct emp
{
int eno;
char name[10];
float sal;
};
void display(struct emp temp);
int main()
{
struct emp e;
display(e);
return 0;
}
void display(struct emp temp)
{
printf("%d %s %d", temp.eno, temp.name, temp.sal );
}
41.
42.
11. Devolviendo Structures desde functions
Podemos devolver estructuras de las funciones. S, las estructuras
pueden ser devueltas desde funciones as como las variables de
cualquier
otro tipo.
43.
44. /* Returning structure object from a function */
/* 78_funct.c */
struct emprec
{
int eno;
char name[10];
};
struct emprec read();
void write(struct emprec t);
int main()
{
struct emprec e;
e = read();
write(e);
return 0;
}
void write(struct emprec t)
{
printf("\n\n%d %s", t.eno, t.name);
}
struct emprec read()
{
struct emprec t;
printf("Insertar nmero empleado
:"); scanf("%d", &t.eno);
printf("Insertar nombre empleado
:"); scanf("%s", t.name);
return t;
}
45.
46.
12. Puntero a Structure
Hasta ahora hemos visto que los miembros de una estructura
pueden ser de tipos de datos tales como int, char, float etc...
C/C++ tambin permite declarar una variable de puntero
como miembro de una estructura. Las variables puntero se pueden
utilizar para almacenar la direccin de una variable de
la estructura tambin. E puntero puede ser declarado como si
se apuntara a un tipo de estructura de datos.
47.
48. /* Programa para demostrar el proceso de puntero a la estructura
*/
/* 79_pointer.c */
#include <stdio.h>
struct employee
{
int eno;
char name[10];
};
struct employee *emp;
int main()
{
emp = (struct employee * )malloc(sizeof(emp));
printf("Introduzca detalles del empleado (nmero
nombre) ..:");
scanf("%d%s%", &emp->eno, emp->name);
printf("\n\n%d
%s", emp->eno, emp->name);
return 0;
}
49.
50.
Los marca de datos es esencial para aplicar punteros a la
estructura.
La siguiente declaracin es opcional, pero es mejor utilizar para
organizar mejor la gestin de memoria.
emp = (struct employee * )malloc(sizeof(emp));
13. Structures que contienen punteros.
Una variable puntero puede ser utilizado como un miembro en la
estructura.
El siguiente programa contiene puntero a los miembros contenidos
por una variable de puntero de la estructura.
51.
52. /* programa para demostrar el uso de estructuras que contienen
punteros */
/* 80_pointers.c */
#include <stdio.h>
struct
{
int *a;
int *b;
} *temp;
int main()
{
int x, y;
x = 20; y = 50;
rk -> a = &x;
rk -> b = &y;
printf("%d %d ", *temp->a, *temp->b );

return 0;
53.
54.
Salida:
20
50
14. Estructuras auto referenciadas.
Las estructuras pueden tener miembros, que son del tipo de la misma
estructura en la que se incluyen. Esto es posible con los
punteros y el fenmeno se denomina estructuras auto-referenciadas.
55.
56. struct emp
{
int eno;
char name[10];
struct emp *e;
};
57.
58.
Las estructuras auto-referencial puede ser utilizados
principalmente en la
organizacin de datos, ordenar, buscar elementos, insercin,
eliminacin
de elementos y as sucesivamente.
Esta forma de planteamiento conduce a las estructuras de datos
(es decir, listas enlazadas, pilas, colas, rboles y grafos).

11. Programacin C/C++ paso a paso - Unions
Unions
1.
2.
3.
4.
5.
6.
7.
Introduccin
Acerca de la Union
Declaracin de la Union
Definicin de una variable de la Union
Diferencias entre Structure y Union
Operaciones con Unions
mbito de aplicacin de una Union
11. Programacin C/C++ paso a paso - Unions

Unions
1.
2.
3.
4.
5.
6.
7.
Introduccin
Acerca de la Union
Declaracin de la Union
Definicin de una variable de la Union
Diferencias entre Structure y Union
Operaciones con Unions
mbito de aplicacin de una Union
1. Introduccin
/* 81_union.c */
#include <stdio.h>
struct s_emp
{
int eno;
char name[20];
float sal;
};
union u_emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct s_emp se;
union u_emp ue;
printf("\nTamao de la estructura Empleados
sizeof(se));
printf("\nTamao de la Union Empleados...
sizeof(ue));
return 0;
}
%d",
%d",
Salida:
Tamao de la estrucutra Empleados : 26
Tamao de la Union Empleados
: 20
2. Acerca de la Union
Cuando un gran nmero de variables requieren utilizarse en un programa.
Estos
ocuparn gran cantidad de memoria. Las Unions ofrecen una forma ms fcil
de
ahorrar memoria utilizando la tcnica de reemplazo. Utiliza misma
posicin de
memoria para todo tipo de variables.
Una Unions es un tipo de datos en C, que permite la superposicin de ms
de una
variable en la misma rea de memoria.
2.1 Caractersticas de las Unions:
1. Union almacena valores de diferentes tipos en un solo lugar en la
memoria.
2. Una Union puede contener uno de los muchos diferentes tipos de
valores,
pero slo uno se almacena en un momento.
3. La Union slo tiene un valor para un tipo de datos. Si se hace una

nueva
asignacin, el valor anterior ya no tiene validez.
4. Cualquier nmero de miembros de la Union puede estar presente. Pero,
la
variable tipo de unin tiene la mayor memoria ocupada por sus
miembros.
3. Declaracin de la Union
Union es un tipo de datos a travs del cual los objetos de diferentes
tipos y
tamaos se pueden almacenar en diferentes momentos. La definicin de una
Union
es la misma que una estructura.
El nico cambio en la declaracin es la sustitucin de la las palabras
union
por la palabra clave struct.
Ejemplo:
union ddate
{
int day;
int month;
int year;
};
union student
{
int sno;
char name[20];
int marks;
float avg;
};
4. Definicin de una variable de la Union

La Definicin de una variable Unin es la misma que la de la estructura y
que para la definicin de incorpora un tipo de datos como int.
int a;
union date d;
/* Valido */
/* Valido tanto en C como C++ */
Calcular el tamao de Union

Cada tipo de datos en C/C++ tiene un tamao especificado, es decir, int
tiene 2 bytes de tamao, float tiene 4 bytes de tamao y as
sucesivamente.
Esta es la manera de encontrar el tamao de una variable de Unin.
sizeof: - Esta funcin se utiliza para encontrar el tamao de una
variable dada.
printf("%d", sizeof(int));
printf("%d", sizeof(float));
printf("%d", sizeof(union emp));
emp */
/* 2 */
/* 4 */
/* Muestra el tamao de la Union
5. Diferencias entre Structure y Union

Estas son las diferencias entre las Structures y las Unions
Structure
Union
1. Puede llevar diferentes tipos

(variables) en un solo lugar
2. Puede contener ms de un tipo
(variable), pero slo uno se
almacena en un momento.
3. Se requiere tamao de memoria
para todos sus miembros.
1. Puede llevar diferentes tipos

(variables) en diferentes lugares.
2. Puede contener ms de un tipo
(variable) todos se almacenan en
la memoria a la vez.
3. Cualquier nmero de miembros de
la union puede estar presente.
Sin embargo, la variable tipo de
union tiene la mayor memoria
ocupada por sus miembros.
4. En su proceso a todos los miembros
se pueden acceder en cualquier mome
4. En su proceso a un solo miembro

se puede acceder en cualquier
momento dado.
5. El alcance de la estructura es
la nica funcin. A los miembros
de la estructura no se pueden
acceder directamente en el programa.
5. El alcance de la union es la funci

y el alcance de sus miembros es tam
igual que el propio sindicato. (Se
acceder directamente en el programa
6. Operaciones con Unions

Una Union es tambin similar a la estructura en el que pueden realizar
todas las
operaciones como en las estructuras. Las operaciones con Union se
enumeran a
continuacin.
* Una variable de unin se puede asignar a otra variable de la unin.
* La variable Union se puede pasar a una funcin como un parmetro
* La direccin de la variable de la unin puede ser extrada mediante el
operador
de direccin (&).
* Una funcin puede aceptar y devolver una Union o un puntero a una
Union.
/* 82_union.c */
#include <stdio.h>
union u_emp
{
int eno;
char name[20];
float sal;
};
int main()
{
union u_emp ue;
printf("Nmero del empleado : "); scanf("%d", &ue.eno);
printf("Nombre del empleado : "); scanf("%s", ue.name);
printf("Sueldo del empleado : "); scanf("%f", &ue.sal);
printf("\n\nLos detalles del empleado son los siguientes...\n");
printf("%d %s %f ", ue.eno, ue.name, ue.sal);
return 0;
}
Cul es la salida?
Slo ue.sal es correcto. Qu pasa con resto de variables.
En cualquier instante slo una de las variables de la unin tendr un
valor
significativo.
Slo que ese miembro, que es el ltimo escrito, es el que se puede leer.
En este punto, las otras variables contienen basura. Es responsabilidad
del programador realizar un seguimiento de la variable activa (es decir,
las variables que se accedieron por ltima vez).
Esta es la mejor manera de aceptar y mostrar los registros de un
empleado.
/* 83_emp.c */
#include <stdio.h>
union u_emp
{
int eno;
char name[20];
float sal;
};
int main()
{
union u_emp ue;
printf("\nNmero del empleado
printf("\n%d", ue.eno);
printf("\nNombre del empleado
printf("\n%s", ue.name);
printf("\nSueldo del empleado
printf("\n%f",ue.sal);
return 0;
}
: "); scanf("%d", &ue.eno);

: "); scanf("%s", ue.name);
: "); scanf("%f", &ue.sal);
7. Alcances de la Union
El alcance de la unin es diferente a la estructura. Una variable de la
estructura puede tener acceso a sus funciones solamente. Mientras que en
el caso de la union, ella y sus miembros pueden accesibles por las
funciones
/* 84_scope.c */
#include <stdio.h>
int main()
{
union
{
int i;
char c;
float f;
};
i = 10; c = 'a'; f = 4.5;
printf("El valor de C es : %c", c);
return 0;
}
/* Union members */

11. Programacin C/C++ paso a paso - Ficheros
Controlando ficheros.
Introduccin
Intente averiguar la salida del siguiente programa.

#include <stdio.h>
int main()
{
int sno, sub1, sub2, sub3;
char name[20];
printf("Introduzca un registro con los campos:

sno, name, sub1, sub2, sub3, respectivamente");
scanf("%d %s %d %d %d\n", &sno, name, &sub1, &sub2, &sub3);
return 0;
}
11. Programacin C/C++ paso a paso - Ficheros
Controlando ficheros.
Introduccin
Intente averiguar la salida del siguiente programa.
#include <stdio.h>
int main()
{
char name[20];
printf("Introduzca un registro con los campos sno, name, sub1,
sub2, sub3, respectivamente");
}
return 0;
S, se acepta un registro de informacin de los estudiantes y lo muestra.

Aqu est el mismo programa, que incluye las mismas declaraciones con
algunas modificaciones.
#include <stdio.h>
int main()
{
char name[20];
FILE *fp = fopen("emp.dat", "a+");
printf("Introduzca un registro con los campos sno, name, sub1,
sub2, sub3, respectivamente");
return 0;
}
Los dos programas son los mismos, pero el segundo programa contiene una
destacada
declaracin (FILE *fp = fopen("emp.dat", "a+");) y algunas modificaciones
como
fprintf, fp. Slo unas pocas modificaciones incluidas. Estas
modificaciones afectan
a las transferencias de datos desde la consola al disco en el fichero
"stud.dat". Este proceso
se conoce como control de archivos/gestin de archivos/organizacin de
archivos.
Se trata de una forma ms fcil de transferir la salida del monitor a un
archivo usando
la declaracin del control de archivos.
En realidad, el procesamiento de archivos lleva invulcrado un montn de
operaciones, as
como los mtodos para ponerlos en prctica. Aqu est el proceso real
para manejar archivos.
Manejar Ficheros
Generalmente cada programa presenta los valores resultantes en la
pantalla
(el programa 1 ilustra esto). Pero esos valores se eliminan de la memoria
Cuando se termina el programa. Si queremos mantener registros de forma
permanente,
habr que guardarlos en un archivo. Cada archivo tiene unas pocas
operaciones.
Aqu persentamos unas cuantas.
_____________
_______
/
|
|
|
|
|
|
|
/
\ |
|
|Regis-| |
|
| Tro | |
|
\____/ |
|
\ Campo
/
|
\
\_______/
/
\
Fichero
/
\_____________/
Diagrama de Venn
|
|
|
|
____
Fichero:
Registro:
Campos:
Es una coleccin de registros.

Es una coleccin de campos
Un campo es un elemento de dato individual
Eno
Name
Sal
1001
Pedro
4500
1002
Maria
8900
1009
Angela
5600
Aqu est la lista de sentencias para procesar ficheros
Operaciones con ficheros:

Abir un fichero existente:
Cerrar el fichero:
fopen
fclose/close
Operaciones con registros:

Aadir un registro
Recuperar un registro del inicio:
Insertar un registro:
Recuperar un registro desde puntero:
fprintf
fscanf
fwrite
fread
Navegar por registros.

Colocar el puntero al principio del fichero: rewind
Mover el puntero desde un registro a otro:
fseek
Buscar un registro en la posicin del puntero:
ftell
Comprobar si se ha llegado al fin del fichero:
feof/eof
Operaciones miscelneas de Entrada/Salida.
Leer/escribir un caracter en el fichero:
Leer/scribir una cadena en el fichero:
fgetc/fputc,
fgetchar / fputchar
fgets / fputs
Operaciones con Ficheros.
fopen
Abre la secuencia de nombre de archivo en el modo y si tuvo xito,
Devuelve un puntero al flujo de reciente apertura, o nulo de otra forma.
Syntax
FILE *fopen(const char *filename, const char *mode);
Ejemplo:
FILE *fp = fopen("stud.dat", "r");
FILE *fp = fopen("emp.dat", "w");
FILE *fp = fopen("emp.dat", "a+");
/* Read from file */

/* Write to file */
/* Read and Write on file */
Modo:
La cadena modo utilizado en las llamadas a fopen, tendr uno de los
siguientes
valores:
Modo Descripcin
r
w
Abre para lectura solamente

Crear para escribir (Si un archivo con ese nombre ya existe,
se sobrescribir).
a
Anexar; abre para escritura al final del archivo, o crea
escribiendo
escritura)
escritura).
r+
w+
a+
si el archivo no existe.
Abre un archivo existente para actualizacin (lectura y
Crea un nuevo archivo actualizando (lectura y
Si un archivo con ese nombre ya existe, se sobrescribir.
Abre para aadir, har una actualizacin al final del
archivo, o
lo crear si el archivo no existe.
Para especificar que un determinado archivo se abre o se crea en modo

texto,
aadir "t" a la cadena rt, w+t, etc.).
Para especificar el modo binario, aadir "b " para la cadena
(wb, a+b, etc.)..).
fclose
Cierra el fichero apuntado por fp y devuelve 0 si tiene xito, se
devuelve EOF en
caso de error
Syntax
int fclose(FILE *fp);
Ejemplo
fclose(fp);
fclose(stud);
fcloseall();
fprintf
Enva el formato de salida a un stream. Utiliza el mismo formato que los
especificadores
printf, pero enva la salida a la secuencia especificada. Devuelve el
nmero de bytes
de salida o EOF en caso de error.
Syntax
Ffrintf(fptr, "Control String", list);
Ejemplo
fprintf(fp, "%d %s %d %d %", sno, name, sub1, sub2, sub3);

fprintf(emp, "%d %s %d", eno, name, sal);
fscanf
Esta funcin se utiliza para leer datos de un formato de un archivo
especificado.
Syntax:
fscanf(fptr, "Control String", list);
Ejemplo
fscanf(fp, "%d %s %d %d %d", &sno, name, &sub1, &sub2, &sub3);
fscanff(emp, "%d %s %d", &eno, name, &sal);
fwrite
Fwrite agrega un nmero especificado de elementos de datos de igual
tamao a una salida
archivo.
Syntax:
Size_t fwrite(const void *ptr, size_t size, size_t n, FILE*stream);
Argumento
Qu es/Hace
Ptr
posicin ptr
Size
N
stream
Apunta a cualquier objeto; comienza a escribir en la

Longitud de que cada items de datos
Nmero de los items data a ser aadido
Especficia el fichero de salida
El nmero total de bytes escritos es (n * size)

fread
Fread recupera un nmero especificado de elementos de datos del mismo
tamao de un
archivo de entrada.
Syntax
Size_t fread(void *ptr, size_t size, size_t n, FILE*stream);.
Argumento
Qu es/Hace
Ptr
posicin ptr
size
n
stream
Coloca el puntero sobre un objeto; comienza a leer en la

Longitud de cada item de los datos
Nmero de los items data a ser aadidos
Especifica el fichero salida.
El nmero total de bytes leidos es (n * size)

rewind
Reposiciona el puntero al comienzo del archivo.
Syntax
void rewind(FILE *stream);
Ejemplo
fewind(fp);
Rewind(stream) es equivalente a fseek(stream, 0L, SEEK_SET)

excepto por que rewind limpia el end-of-file (fin de fichero)
y los indicadores de error, mientras que fseek slo limpia el
indicador de en-of-file. Tras rewind la siguiente operacin es
una actualizacin del fichero para cada entrada o salida.
fseek
El puntero de fichero para el stream es posicionado a travs del nmero
"offset"
que se calcula desde la posicin "whence". El offset puede ser cero,
negativo o
positivo. Los simbolos definidos SEEK_CUR, SEEK_SET & SEEK_END se
utilizan para
especificar la actual posicin, la posicin inicial (BOF) y final (EOF)
del
fichero respectivamente. Retorna 0 si ha habido xito y un nmero
distinto de
cero en caso de error.
Syntax
int fssek(FILE *stream, long offset, int whence);
ftell
Devuelve la actual posicin del puntero en el fichero, en caso de xito o
un valor negativo en caso de error.
Syntax
long ftell(FILE *stream);
feof
Es una macro que return nonzero si se encuentra end-of-file en el stream.
Syntax
int feof(FILE *stream);
eof
Comprueba cualquier posicin marcada en el fichero y comprueba si se ha
llegado
al final del fichero. Si fuera s, devuelve 0, 1 si la posicin marcada
NO es es el
eof y un error indicado errno, si el valor es distinto de 1.
Syntax
int eof(int handle);
fgets/fputs
La funcin fgets/fputs, como gets/puts en una cada (de tamao nbytes) en
el
fichero escribe y recuera valores, devuelve end-of-file en error.
Syntax
char *fgets(char *s, int n, FILE *stream);
fgetc/fputc
Syntax
Lee / escribe un caracter desde un stream.
int fgetc/fputc(FILE *stream);
fgetchar/fputchar
Es un equivalente a fgetc/fputc
Escribe un programa que lee datos de un estudiante y los almacena en un

fichero de datos.
/* Program to create a student data file */

/* 85_write.c */
#include <stdio.h>
#include <ctype.h>
/* #include <conio.h> */ /* Esta librera no es estandar en Linux */
int main()
{
char name[10],ch;
FILE *fp = fopen("stud.dat", "w");
do{
/* clrscr(); */
printf("Escriba el nmero del estudiante: "); scanf("%d",
&sno);
printf("Escribe el nombre del estudiante: "); scanf("%s",
name);
printf("Escriba 3 marcas subjetivas
");
scanf("%d%d%d", &sub1, &sub2, &sub3);
fprintf(fp, "%d %s %d %d %d\n", sno, name, sub1, sub2, sub3);
printf("\n\nDeseas continuar?... (y/n)"); ch = getche();
}while(toupper(ch) != 'N');
fclose(fp);
return 0;
}
Escribe un programa que recupera los datos desde un fichero de datos de

estudiantes.
/* Program to retrieve data from a student data file */

/* 86_read.c */
#include <stdio.h>
/* #include <conio.h> */ /* Esta librera no es estandar en Linux */
int main()
{
char name[10];
FILE *fp = fopen("stud.dat", "a+");
/* clrscr(); */
printf("Los registros de los estudiantes son los
siguientes....\n");
do{
fscanf(fp, "%d%s%d%d%d\n", &sno, name, &sub1, &sub2, &sub3);
printf("%5d%15s%3d%3d%3d\n", sno, name, sub1, sub2, sub3);
}while(!feof(fp));
fclose(fp);
return 0;
}

13. Programacin C++ paso a paso - Programacin Orientada a Objetos.
1. Paradigma Orientado a Objetos

2. Caractersticas del lenguaje orientado a objetos
- Objetos
- Clases
- Abstraccin(extraccin) de datos
- Encapsulacin de datos
- Herencia
- Polimorfismo
- Enlace dinmico
- El paso de mensajes
3. Historia de C++
4. Clases y Objetos
5. Funciones miembros definidos fuera de la clase
6. Matriz de objetos
7. Objetos como argumentos
8. Devolviendo objetos desde funciones
9. Constructor
10. Destructores
11. La sobrecarga de constructor
12. Datos estticos de clase
13. Miembros de Funciones estticas
14. Funciones Friend
13. Programacin C++ paso a paso - Programacin Orientada a Objetos.

- Objetos
- Clases
- Abstraccin(extraccin) de datos
- Encapsulacin de datos
- Herencia
- Polimorfismo
- Enlace dinmico
3. Historia de C++
4. Clases y Objetos
5. Funciones miembros definidos fuera de la clase
6. Matriz de objetos
8. Devolviendo objetos desde funciones
9. Constructor
10. Destructores
11. La sobrecarga de constructor
12. Datos estticos de clase
13. Miembros de Funciones estticas
14. Funciones Friend
La idea bsica detrs del Paradigma Orientado a Objetos es combinar
dentro de una "simple unidad" tanto datos como funciones que operan
sobre esos datos.
Esta "unidad" se llama un objeto.
A travs de este mtodo no podemos acceder a los datos directamente.
Los datos estn ocultos, as, estn a salvo de alteraciones accidentales.
Los datos y sus funciones se dice que estn encapsulados en una nica
entidad. La encapsulacin de los datos y su ocultacin son los trminos
clave en la descripcin del lenguaje orientado a objetos.
Un programa C++ generalmente consiste en una serie de objetos, que se
comunican entre s mediante llamadas a funciones de alguno de sus
miembros.
==============================================================
La organizacin de un programa C++ se muestra en esta figura.
stos son algunos elementos importantes de los lenguajes orientados a
objetos.
-
Objetos
Clases
Abstraccin (extraccin) de datos
Encapsulacin de datos
Herencia
Polimorfismo
Enlace dinmico
Objetos
El objeto es una instancia de una clase. Combinando ambos, datos y
miembros de
funciones.
Los objetos son las entidades bsicas de tiempo de ejecucin en un
sistema
orientado a objetos.
Clases
Una plantilla o modelo que define las caractersticas de un objeto y
describe cmo el objeto debe verse y comportarse.
Abstraccin de datos
Identificacin de las caractersticas distintivas de una clase o un
objeto sin
tener que procesar toda la informacin sobre la clase o el objeto. Cuando
usted
crea una clase n por ejemplo, un conjunto de caractersticas puede
utilizarlo
como una entidad nica en lugar de realizar el seguimiento individual de
los
componentes y su interaccin.
La encapsulacin de datos
Es un trmino de la programacin orientada a objetos sobre la capacidad
de contener y ocultar informacin acerca de un objeto, as como
estructuras internas de datos y cdigo.
La encapsulacin asla la complejidad interna sobre la operacin de un
objeto del resto de la aplicacin. Por ejemplo, al establecer el ttulo
propiedad en un botn de comando, no necesita saber cmo est la cadena
almacena.
Herencia
Es un trmino de la programacin orientada a objetos. La capacidad de una
subclase de tomar las caractersticas de la clase en la que se basa. Si
las caractersticas de la clase padre cambian, la subclase de la que
hereda
esas caractersticas. Heredar las cualidades de la clase en la que se
basa
Polimorfismo
Es Un trmino de programacin orientada a objetos. La capacidad de tener
mtodos con el mismo nombre, pero con contenidos diferentes, para las
clases
relacionadas. El procedimiento para su uso se determina en tiempo de
ejecucin
por la clase del objeto. Por ejemplo, objetos relacionados podran tener
mtodos
de dibujo. Un procedimiento, pasa un parmetro como un objeto, puede
llamar
al mtodo de dibujo sin necesidad de saber Qu tipo de objeto del
parmetro es?
Enlace dinmico
Dinmica se refiere a la vinculacin de una llamada a un procedimiento

para ejecutar como respuesta a la llamada. Enlace dinmico significa que
el cdigo asociado con un determinado procedimiento llamada no se conoce
hasta el momento que se produce la llamada en tiempo de ejecucin. Est
asociada con el polimorfismo y la herencia. Una llamada de funcin
asociada a una referencia polimrfica depende del tipo dinmico de esa
referencia.
El paso de mensajes
Un programa orientado a objetos consiste en un conjunto de objetos que
se comunican entre s. El proceso de programacin en un lenguaje
orientada
a objetos por lo tanto implica los siguientes pasos bsicos:
1. Creacin de clases que definen los objetos y su comportamiento.
2. Creacin de objetos a partir de las definiciones de clase.
3. El establecimiento de la comunicacin entre objetos.
3. Historia de C++
Year
Language
Developed by
1960
ALGOL
International Committee
demasiado abstracto
1963
CPL
Cambridge University
de implentar
1967
BCPL
Martin Richards
problemas
1970
B
problemas
Ken Thompson AT&T Bell Labs
Remarks
Demasiado general,
Duro de aprender, dificil
Poda hacer frente slo a
especficos
Poda hacer frente slo a
especficos
1972
C
Dennis Ritchie AT&T Bell Labs Pierde la generalidad de
BCPL y restaura
ka de B
80s
C++
Bjarne Stroustrup AT&T
C con introduccin a OOP
C++ es un lenguaje de programacin orientado a objetos. Se denominaba
"C con clases", C++ fue desarrollado por Bjarne Stroustrup en
AT&T Bell Laboratories en Murray Hill, Nueva Jersey, EE.UU., a
principios de los ochenta.
BS, un admirador de Simula67 (un lenguaje de programacin orientada
a objetos) y una fuerte partidario de la C, quera combinar lo mejor
de ambos lenguajes y crear uno ms potente con la elegancia de C.
El resultado fue de C++.
C++ es un verdadero lenguaje orientado a objetos, as. Es una
coleccin de clases y objetos.
4. Clases y Objetos
Una clase es una forma de enlazar los datos y sus funciones asociadas
entre s. Permite que los datos se oculten, si es necesario, de uso
externo. Cuando definimos una clase, estamos creando un nuevo tipo de
datos abstractos que se pueden tratar como cualquier otro tipo de datos
integrado. Por lo general, una clase tiene dos partes:
1. Declaracin de la clase
2. Clase definicin de la funcin
La declaracin especifica el tipo y el alcance de los datos y miembros
de las funciones de la clase. Donde de definicin especifica el cdigo
ejecutable de la funcin.
La forma general de una declaracin de clase es:
class class_name
{
private:
variable
function
public:
variable
function
};
declarations;
declarations;
declarations;
declarations;
La declaracin de la clase es similar a la declaracin de una estructura.

La palabra clave class especifica que los datos y las funciones sern
privadas
por defecto. Si, una palabra clave struct especifica que los datos y las
funciones deben ser pblicos de forma predeterminada. Las palabras claves
public y private que se conocen como etiquetas de visibilidad.
Aqu est una clase de ejemplo para implementar una clase de empleados.
+-----------------Palabra reservada Class

|
class emp<----------Nombre de la clase
{
private :<-----------------------Palabra reservada y dos
puntos
int eno;
\
char name[10];
| --Funciones y datos privados
float sal;
/
public :<-----------------------Palabra reservada y dos
puntos
void getdata()
\
{ cin >> eno >> name >> sal; } \
Funciones y
void putdata()
| -datos
{ cout << eno << name << sal; } /
pblicos
};
^
|
+------ Punto y coma
Lo siguiente es un programa completo de la clase "emp"
// Programa que acepta y muestra informacin de los empleados

#include <iostream>
class emp
// definicin de clase
{
private :
// private, funciones y datos privados
int eno;
char name[10];
float sal;
public :
//public, funciones y datos pblicos
void getdata()
{ cin >> eno >> name >> sal; }
void putdata()
{ cout << eno << name << sal; }
};
/* ------- Programa principal ------------- */
int main()
{
emp e;
e.getdata();
e.putdata();
return 0;
}
5. Las funciones miembros (de la clase) esta definidas fuera de ella.

Existe la posibilidad de definir funciones miembros fuera de la
clase mediante el operador de resolucin de mbito: operator (::).

#include <iostream>
class emp
// class definition
{
private :
// private data, functions
int eno;
char name[10];
float sal;
public :
// public data, functions
void getdata();
void putdata();
};
void emp::getdata()
{
cin >> eno >> name >> sal; }
void emp::putdata()
{
cout << eno << name << sal; }
int main()
{
emp e;
e.getdata();
e.putdata();
return 0;
}
6. Array de objetos
El Compilador C++ tambin es compatible con gran variedad de objetos.
Siguiente ejemplo ilustra la ventaja de usar objetos utilizando matrices.

#include <iostream>
class emp
// class definition
{
private :
int eno;
char name[10];
float sal;
public :
void getdata()
{ cin << eno << name << sal; }
void putdata()
{ cout >> eno >> name >> sal; }
};
int main()
{
emp e[10];
declaration of array of objects
for(i = 0; i <10; i++)
//
// accessing
objects properties and methods

e[i].getdata();
for(i = 0; i< 10; i++)
e[i].putdata();
return 0;
}

Pasar objetos a funciones es similar a pasar estructuras o matrices a
funciones.
El siguiente programa muestra cmo los objetos se pasan a funciones.

#include <iostream>
class emp
// class definition
{
private :
int eno;
char name[10];
float sal;
public :
void getdata()
void putdata()
};
void operate(emp t);
int main()
{
emp e;
operate(e);
}
/* ------- Funcin ------------- */
void operate(emp t)
{
t.getdata();
t.putdata();
return 0;
}
8. Devolver objetos de funciones
Hemos visto objetos que se pasan como argumentos a funciones, ahora vamos
a
discutir sobre la forma de devolver los objetos de las funciones.

#include <iostream>
class emp
// class definition
{
private :
int eno;
char name[10];
float sal;
public :
void getdata()
void putdata()
};
/* -------- Declaraciones de funcin ------- */
emp get();
void put(emp t);
int main()
{
emp e;
e = get();
put(e);
return 0;
}
/* ------- Funcin ------------- */
emp get()
{
emp t;
t.getdata();
return t;
}
/* ------- Funcin ------------- */
void put(emp t)
{
t.putdata();
}
9. Constructor
El siguiente ejemplo muestra dos maneras de dar valores a los elementos

de datos en un objeto. A veces, sin embargo, es conveniente que un objeto
pueda inicializarse cuando se crea por primera vez, sin la necesidad de
hacer una llamada independiente a una funcin miembro.
La inicializacin automtica comienza usando un especial miembro de
funcin
llamado "constructor". Un constructor es una funcin miembro (de la
clase) que
se ejecuta automticamente cada vez que se crea un objeto.
// Programa que acepta y muestra informacin de los empleados usando

constructors
#include <string.h>
#include <iostream>
class emp
{
private :
int eno;
char name[10];
float sal;
public :
// class definition
emp() { ; }
// constructor without arguments
emp(int teno, char tname[10], float tsal) // constructor with

arguments
eno = teno;
strcpy(name, tname);
sal = tsal;
void getdata()
void putdata()
{ cout << eno << name << sal << endl;
};
int main()
{
emp e1(1001, "Magic", 6700.45);
emp e2;
e2.getdata();
e1.putdata();
e2.putdata();
return 0;
}
El programa de ejemplo anterior acepta los valores de dos maneras con

constructores y el uso de las funciones miembro. Un objeto, siempre que
se
declara automticamente se inicializa con los valores indicados con los
constructores. Cuando como objeto e2 es accesible por su funcin de
nico miembro.
Un ejemplo ms de distinguir el uso del constructor.
// Objects represents a counter variable

#include <iostream>
class counter
{
private :
int count;
// variable count
public :
counter()
{ count = 0; }
// constructor
void inc_count() { count++; }
// increment
count
int get_count()
{ return count; } // return
count
};
/* ------- Programa principal
int main()
{
counter c1, c2;
cout << "\nC1 = "
cout << "\nC2 = "
c1.inc_count();
c2.inc_count();
c2.inc_count();
cout << "\nC1 = "
cout << "\nC2 = "
return 0;
}
------------- */
// define and initialize
// display
<< c1.get_count();
<< c2.get_count();
<< c1.get_count();
<< c2.get_count();
//
//
//
//
increment c1
increment c2
increment c2
display again
Un constructor tiene las siguientes caractersticas.

Inicializacin automtica
Retorna valores que no fueron aceptadas
Igual nombre que el de la clase
Mensaje con formato
10. Destructores
Un destructor tiene el mismo nombre que el constructor (con el mismo
nombre que el de la clase), pero precedido de una tilde:
// Demostracin de un destructor
#include <iostream>
class temp
{
private :
public :
int data;
temp() { data = 0;
Constructor (same name as class)
~temp() { }
destructor (same name with tilde)
}
//
//

int main()
{
temp t;
return 0;
}
11. Sobrecarga de un constructor

La capacidad para la clase relacionada de tener funciones con el mismo
nombre, pero diferente contenido. El procedimiento a utilizar se
determina en tiempo de ejecucin por la clase del objeto.
// Demostracin de un constructor overloading

#include <iostream>
class ttime
{
private :
int hh, mm, ss;
public :
ttime() {hh = 0; mm = 0; ss = 0; } // Constructor with
initialization
ttime(int h, int m, int s)
// Constructor with 3
arguments
{
hh = h; mm = m ; ss = s;
}
ttime(int h, int m)
arguments
hh = h; mm = m; ss = 0;
}
argument
ttime(int h)
{
hh = h; mm = 0; ss = 0;
}
~ttime() { }
// Destructor
void get_time()
{
cin >> hh >> mm >> ss;
}
};
void put_time()
{
cout << endl << hh << "
}
" << mm <<"

int main()
{
ttime t1, t2(12, 12, 12), t3(4, 5), t4(11);
constructors
t1.get_time();
t1.put_time();
t2.put_time();
t3.put_time();
t4.put_time();
return 0;
}
" <<
ss;
// Calling
12. Clase de datos estticos

Si un elemento de datos en una clase se define como algo esttico, slo
un elemento, se crea para toda la clase, no importa cuntos objetos hay.
Un elemento de datos esttico es til cuando todos los objetos de la
misma clase deben comparten un elemento comn de informacin. Una
variable
miembro define como esttica caractersticas similares a una variable
esttica normal: slo es visible dentro de la clase, pero su vida es
para todo el programa.
// Demostracin de un datos esttico

#include <iostream>
class temp
{
private :
static int count;
// Only one data item for all objects
public :
temp() { count++; }
// increment count when object created
int getcount() { return count; }
// return count
};
int main()
{
temp t1, t2, t3;
// create three objects
cout << "\nCount is
" << t1.getcount( ); // each object
cout << "\nCount is
" << t2.getcount( ); // sees the same
cout << "\nCount is
" << t3.getcount( ); // value of count
return 0;
}
La salida del programa de arriba es la siguiente: ( si permanece esttica

)
Count is 3
Count is 3
Count is 3
Salida del progrma (si es automtica)
Count is 1
Count is 1
Count is 1
13. Funciones miembros (de la clase) estticas
Como variable miembro esttica, tambin puede tener funciones miembro
estticas.
Una funcin miembro que se declara esttica tiene las siguientes
propiedades.
- Funciones estticas que pueden tener acceso a los miembros estticos de
otros
(funciones o variables) declarados en la misma clase.
- Una funcin miembro esttica puede ser llamada usando el nombre de
clase (en
lugar de sus objetos) de la siguiente manera:
nombre-de-clase :: nombre-funcin;
// Programa que demuestra funciones estticas de miembro (de la clase)

#include <iostream>
class test
{
int code ;
static int count;
// static member variable
public:
void setcode() { code = ++count; }
void showcode() { cout << "Object number :" << code << endl; }
function
static void showcount()

{
};
cout << "Count
// static member
:" << count << endl;
int test :: count;

int main()
{
test t1, t2;
t1.setcode();
t2.setcode();
test::showcount(); // accessing static function
test t3;
t3.setcode();
test::showcount();
t1.showcode();
t2.showcode();
t3.showcode();
return 0;
}
14. Funciones friend

A los miembros privados no puede accederse desde fuera de la clase. Es
decir
una funcin de terceros no puede tener acceso a los datos privados de una
clase. Sin embargo, podra haber una situacin donde nos gustara que dos
clases compartieran una funcin en particular. Simplemente se logra a
travs de
"Funciones de amigo."
Una funcin friend posee ciertas caractersticas particulares:
* No est acotada slo al mbito de la clase a la que ha sido declarada
como
amigo.
* Dado que no est en el mbito de la clase, no puede ser llamado
con el objeto de la clase. Se puede invocar como una funcin normal
sin la ayuda de ningn objeto.
* A diferencia de las funciones de miembro (de clase), no puede acceder
directamente a los nombres de miembros y tiene que utilizar un operador
de
membresa de nombre y punto de objeto con cada uno del miembro.
* Se puede declarar en pblico o en la parte privada de una clase sin
afectar
a su significado.
* Por lo general, tiene objetos como argumentos.
// Programa que demuestra las funciones friend

#include <iostream>
class test
{
int a;
int b;
public:
void setvalue() { a = 25; b = 40; }
friend float sum(test s);
};
/* ------- Funcin friend de la clase
float sum(test s)
{
return float (s.a + s.b ) / 2.0;
members
were accessible
// FRIEND declared
------------- */
// s.a & s.b are the private
// of class test but they
// by friend function
}
int main()
{
test x;
x.setvalue();
cout << "Mean value = " << sum(x) << endl;
return 0;
}
Un ejemplo ms de funciones para implementar funciones friend

como puente entre dos clases.
El siguiente programa crea dos objetos de dos clases y una funcin
amigable para las dos clases.
En este ejemplo la funcin friend es capaz de acceder a los
datos de los miembros de la clases y calcular el mayor de ambas clases
de miembros de datos.
#include <iostream>
class second;
class first
{
int a;
public:
first(int temp) { a = temp; }
friend void max(first, second);
};
class second
{
int b;
public:
second(int temp) { b = temp; }
friend void max(first, second);
};
/* ------- Funcin Friend ------------- */
void max(first f, second s)
{
if ( f.a > s.b )
// both first, second data
members can be
cout << "Max "<< f.a;
// accessed thru friend max
function
else
cout << "Max "<< s.b;
}
int main()
{
first f(20);
second s(30);
max(f, s);
return 0;
}

14. Programacin C++ paso a paso - Programacin - Herencia
Herencia
Introduccin
Clase derivada y clase base
Especificacin de la clase derivada
Derivado de Constructores de Clase
Epecificadores de acceso
Pblica
Privada
Protegidas
Especificadores de acceso sin herencia
Especificador de acceso protegido
mbito de aplicacin de especificadores de acceso
Los especificadores de acceso con herencia
Tipos de Herencia
Herencia simple
Herencia mltiple
Herencia multinivel
Herencia hbrida
Jerarqua de herencia
14. Programacin C++ paso a paso - Programacin - Herencia
Herencia
Introduccin
Clase derivada y clase base
Derivado de Constructores de Clase
Epecificadores de acceso
Pblica
Privada
Protegidas
Especificadores de acceso sin herencia
Especificador de acceso protegido
mbito de aplicacin de especificadores de acceso
Los especificadores de acceso con herencia
Tipos de Herencia
Herencia simple
Herencia mltiple
Herencia multinivel
Herencia hbrida
Jerarqua de herencia
Introduccin
La herencia es la caracterstica ms potente de la programacin orientada
a objetos.
La herencia es el proceso de crear nuevas clases, llamados derivadas de
las clases actuales o clases base. La clase derivada hereda todas las
las capacidades de la clase base, pero puede aadir adornos y

refinamientos propios.
Una clase, llamada la clase derivada puede heredar las caractersticas de
otra clase, llamada la clase base.
Traspasar las cualidades de la clase base a la clase derivada se conoce
como
herencia.
El nombre herencia la conocemos por nuestra vida cotidiana, utilizamos el
concepto de clases que se derivan en subclases. Por P. ej Un vehculo es
una
clase dividida a su vez en ciclomotores, motos, Autos, camiones,
autobuses,
etc.
Aqu vehculo se conoce como la clase base y los elementos derivados se
conocen
como las clases derivadas o subclases.
En general todas las clases de base tiene una lista de cualidades y
caractersticas.
El tema principal de la herencia es para compartir todas las
caractersticas comunes
de la clase base, con las clases derivadas.
CLASE BASE
+-----------------------+
|
|
| +----------------+
|
| |CARACTERISTICA A|
|
| +----------------+
|
/|
+----------------+ |
/|
|CARACTERISTICA B| |
/ |
+----------------+ |
/
|
|
/
+-----------------------+\
/
|
\
/
|
\
/
|Clase Dos
\
Clase Uno
Clase Tres
+-----------------------+
+-----------------------+
+-----------------------+
| +----------------+
|
| +----------------+
|
+----------------+
|
| |Caracteristica A|
|
| |Caracteristica A|
|
Caracteristica A|
|
| +--+----------------+ |
+-+--+-----------+-+----+
+----------------+ |
|
|Caracterstica B| |
|Caracterstica B|Carac-|
Caracterstica B| |
+----+-----------+----+ |
+----------------+Teris-|
+-----------+----+ |
|Caracterstica C|
|
|Caracterstica C|Tica D|
Caracterstica F|
|
\
\|
\| |
| +-|
+----
+-----------------------+
+----------------+------+
+-----------------------+
CLASES DERIVADAS
La herencia tiene una importante caracterstica que permite la
reutilizacin. Uno
de los resultados es la facil distribucin de las libreras de clases. Un
programador puede utilizar una clase creada por otra persona o empresa,
y, sin
modificaciones, derivar otras clases de ella que se adapten a situaciones
particulares.
Clases derivadas y clases base.
Una clase, llamada clase derivada puede heredar las caractersticas de
otra clase,
llamada clase base.
La clase derivada puede aadir otras caractersticas propias, por lo que
se convierte
en una versin especializada de la clase base. La herencia proporciona
una forma
potente de ampliar las capacidades de las clases existentes, y disear
programas que
utilizan relaciones jerrquicas.
La Accesibilidad de los miembros de la clase base desde las clases
derivadas y de
los objetos de clases derivadas es una cuestin importante. Los objetos
de clases
derivadas podran acceder a datos o funciones de la clase base que estn
precedidos
por la palabra clave protected de las clases derivadas, pero no. Las
clases pueden
ser pblicamente privadas derivadas de (otras) clases base. Los objetos
de una
clase derivadadamente pblicas puede tener acceso a miembros pblicos de
la clase
base, mientras que los objetos de una clase derivadamente privada no
puede.
Diagrama muestra cmo se hereda la clase derivada.
CLASE BASE
+-----------------------+
|
|
| +----------------+
|
|
| +----------------+
|
|
|
|
+----------------+ |
|
|CARACTERISTICA B| |
|
+----------------+ |
|
|
la
pero
desde
derivada
dentro
|
|
+-----------------------+
|
|
Clase Derivada
+-----------------------+
| +----------------+
|<
Definido en
| \
Clase Base
| +----------------+
Accesible
+----------------+ | /
|
|CARACTERISTICA B| |<
|
+----------------+ |
| +----------------+
|<
| |CARACTERISTICA C|
| \
| +----------------+
| |
|
+----------------+ | /
|
|CARACTERISTICA D| |<
|
+----------------+ |
+-----------------------+
La clase
Definido
de la clase
derivada
Una clase puede ser derivada de ms de una clase base. Esto se llama
herencia
mltiple. Una clase tambin puede ser contenida dentro de otra clase.
La declaracin de una clase es fcil utilizando las palabras clave, as
como la
declaracin de la clase derivada, la clase base debe estar al final
precedido del
especificador, para comenzar con : y el nombre de la clase derivada.
Sintaxis para declarar una clase derivada:
Class <Class_name> : <Access_Specifier> <Base_Class_Name> .
Por ejemplo: class result
: public stud;
/* program to accept and display a student record

#include <iostream>
class add
{
private :
char str[20];
*/
char city[20];
int pin;
public :
void get_add()
{
cout << "Enter Address street,city,pin";
cin >> street >>city>>pin;
}
void put_data()
{
cout << "Address is
"<< str
<< endl << city << endl << pin;
}
};
class stud : public add
{
private :
int sno;
char name[20];
int m1,m2,m3;
public :
void get_data()
{
cout << "Enter Student No. "; cin >> sno;
cout << "Enter Student Name "; cin >> name;
cout << "Enter Student 3subjects marks ";
cin >> m1 << m2 << m3;
}
void put_data()
{
cout << "Student number :" << sno;
cout << "Student name
:" << name;
cout << "Student marks
:" << m1 << " " <<m2<<"
"<<m3;
}
};
int main()
{
stud s;
s.get_add();
s.get_data();
s.put_add();
s.put_data();
return 0;
}
Constructores de Clase Derivadas

Si una clase se declara con sus propios constructores, es una clase base
de otra.
La clase derivada tambin tendr sus propios constructores. Si un objeto
es
declarado el cual es constructor se ejecutar? No hay duda, ejecutar el
constructor de la clase derivada. Todava desea ejecutar el constructor
de la clase base o ambos derivadas y los constructores de clase base,

simplemente
llame al constructor Base en el constructor de la clase derivada.
/* Constructors in derived class */

#include <iostream>
class Add
{
protected :
unsigned int a;
public :
Add() { a = 0; }
Add( int c ) { a = c; }
int get_val(){
return a; }
Add operator ++ ()
{
a++;
return
return Add(a);
object
}
count
};
class Sub : public Add
{
public:
Sub() : Add() { }
Sub(int c) : Add(c) { }
Sub operator -- ()
return
{
object
a--;
Value
return Sub(a);
}
};
int main()
{
Sub ob1;
Sub ob2(100);
cout << "\nOb1 =" <<
cout << "\nOb2 =" <<
ob1++; ob1++; ob1++;
cout << "\nOb1 =" <<
ob2--; ob2--;
cout << "\nOb2 =" <<
Sub ob3=ob2--;
cout << "\nOb3 =" <<
return 0;
}
// NOTE : not private

//
//
//
//
constructor , no args
constructor , one args
return A value
increment count
// increment count,
// an unnamed temporary
// initialized to this
// Constructor, no args
// Constructor, one args
// decrement value of A,
// an unnamed temporary
//initialized to this
// class Sub
ob1.get_val();
ob2.get_val();
ob1.get_val();
ob2.get_val();
ob3.get_val();
//
//
//
//
//
//
//
//
display
display
increment ob1
display
decrement ob2
display
create ob3 from ob2
display
ESPECIFICADORES DE ACCESO
Especificadores de acceso se utilizan para controlar, ocultar, proteger
los
datos y los miembros de funciones. Los especificadores de acceso son de 3
tipos
1. Especificador de acceso pblico
2. Especificador de acceso privado
3. Especificador de acceso protegido
public :
Si un miembro o dato es pblico puede ser utilizado por cualquier
funcin en
la clase y en sus clases derivadas tambin.
En C++ los miembros de una estructura o unin son pblicas de forma
predeterminada.
Los miembros pblicos de una clase pueden heredarse a la clase derivada
cuando la
clase es heredada pblicamente, pero no (as) las funciones miembro (en
privado).
private :
Las funciones miembro y friend de la clase en la que son
declaradas slo pueden
ser utilizadas
Los miembros de una clase son privados por defecto.
Los miembros privados de una clase no pueden heredase a una clase
derivada cuando
la clase base es heredada pblica o privadamente. Tendremos que escribir
las
funciones miembro, que devuelvan, esos valores.
protected :
Es el acceso para casos particulares, adems, el miembro puede ser
utilizado
por funciones de miembros y friends de clases derivadas de la
clase declarada
pero no slo en objetos del tipo derivado.
El miembro protegido de una clase puede heredar a la siguiente clase
derivada.
Pero no a clases posteriores
Los especificadores de acceso sin herencia
+------------------------------------------------------------------------------+
|Las funciones miembros de
Clase C
|
|la Clase C, pueden acceder
+-------------------------------+
|
|a ambos miembros "public" y
|
+---------------+
|
|
|"private"
+-------|------->|PRIVATE
|<. |
|
|
|
|
+---------------+
: |
|
|
|
|
+---------------+
: |
|
|
+-------|------>|PUBLIC
|<---+ |
|
|
|
|
+---------------+
| |
|
|
|
+---+------------------------|--+
|
|
|
|
|
|
|
+-----------+ +----------------+
| Un objeto de
la
|
|
| Objeto clase C |---+ Clase C slo
|
|
+----------------+
podrn
acceder a|
|
los miembros
|
|
pblicos de
C
|
+------------------------------------------------------------------------------+
Ms sobre los especificadores de acceso protegido.
Para proporcionar la funcionalidad sin necesidad de modificar la clase.
Protected
puede acceder a si misma y a derivados de miembros de clases-protegidas,
pero slo
en los objetos o subderivados de la clase o fuera de la clase
mbito de aplicacin de especificadores de acceso:
Acceso
Accesible desde
desde
Especificador Nuestra clase
fuera de la clase
Public
Si
Protected
Si
Private
Si
Accesible desde
Accesible
Clase derivada
Objetos
Si
Si
No
Especificadores de Acceso con herencia

Tipos de herencia:
1.- Herencia simple
Cuando una clase deriva directamente de otra clase
se le denomina herencia simple
A -> B
La clase B hereda las caractersticas de A
Si
No
No
2.- Herencia Mltiple

Si yna clase es derivada de ms de una clase base, a esto se
le llama herencia mltiple.
A
B
C
|
|
|
+-------+-------+
|
D
La la clase D hereda caractersticas de las clase A, B y C
3.- Herencia multinivel
Si una clase se deriva de una clase derivada, se le llama
herencia multinivel
A
|
B
|
C
4.- Herencia hbrida
La clase resultante es una combinacin de una herencia
multinivel y una rencia mltiple
A
|
B
C
|
|
+-------+-------+
|
D
5.- Herencia Jerrquica
Consiste de una clase base extraer varias clases derivadas.
La clase Base tiene habilitado el control de todas las
clases derivadas
A
|
+---------------+---------------+
B
C
|
|
+-------+-------+
+-------+-------+
D
E
F
G
H
I
/* Program to demonstrate Multiple Inheritance

#include <iostream>
class M
{
protected :
int m;
public :
void getm()
{
*/
cout << "\nEnter M value

cin >> m;
:";
};
class N
{
protected :
int n;
public :
void getn()
{
cout << "\nEnter N value
cin >> n;
}
};
class P : public N, public M
{
public :
void disp()
{
cout << "\n
cout << "\n
cout << "\n
}
};
M
=
N
=
M*N =
:";
" << m;
" << n;
" << m*n;
int main()
{
P p;
p.getm();
p.getn();
p.disp();
return 0;
}
Si una clase base es pblicamente heredada entonces los miembros

pblicos,
pueden acceder a las funciones miembro de la clase derivada y a los
objetos tambin donde como si de una clase base heredaran privadamente
con ello
los miembros de la clase base son heredados a las funciones miembro de la
clase
derivada slo, pero no sus objetos
/* A program to demonstrate Multilevel Inheritance

class student
{
int rno;
public:
void getrno()
{
cout << "Enter Number :";
*/
};
cin >> rno;

}
void showrno()
{
cout << "Student Number:" << rno;
}
class test : public student

{
int m1,m2;
public :
void getmarks()
{
cout << "Enter marks 1
cout << "Enter marks 2
}
int retm1()
{
return m1;
}
int retm2()
{
return m2;
}
};
:" ; cin >> m1;

:" ; cin >> m2;
class result : public test

{
int tot;
public:
void get()
{
getrno();
getmarks();
}
void showresult();
void show()
{
showrno();
showresult();
}
};
void result::showresult()
{
int s1,s2;
s1=retm1();
s2=retm2();
tot=s1+s2;
cout << "\nMarks " << s1 << " "<< s2;
cout << "\nTotal marks " << tot;
}
int main()
{
result a;
a.get();
a.show();
return 0;
}
/* Program to demonstrate Hybrid Inheritance */

#include <iostream>
class student
{
int rno;
public:
void getrno()
{
cout << "Enter Number :";
cin >> rno;
}
void showrno()
{
cout << "\nStudent Number
}
};
:" << rno;
class test : public student

{
protected :
int m1,m2;
public :
void getmarks()
{
cout << "Enter marks 1 :" ; cin >> m1;
cout << "Enter marks 2 :" ; cin >> m2;
}
void showmarks()
{
cout << "\nMarks of 2 subjects " << m1 << "
}
};
class sports
{
protected :
int score;
public :
void getscore()
{
cout << "Enter
cin >> score;
}
};
Score
:";
class result : public test, public sports
" << m2;
{
public :
void getdata()
{
getrno();
getmarks();
getscore();
}
void putdata()
{
showrno();
showmarks();
cout << "\nScore is " << score;
cout << "\n Total marks
" << m1+m2;
}
};
int main()
{
result r;
r.getdata();
r.putdata();
return 0;
}
La representacin pictrica del programa anterior:
+--------------+
|
Stud
|
+-------+------+
|
+---------------+---------------+
|
|
+---------------+
+---------------+
|
Test
|
|
Sports
|
+---------------+
+---------------+
|
|
+---------------+---------------+
|
+-------+------+
|
Results
|
+--------------+
En la clase de figura estudiante arriba heredada a consecuencia de dos
maneras. Uno de ellos es a travs de la prueba otra es a travs de los
deportes a continuacin, dos grupos de miembros, los miembros funciones
comunes para los estudiantes de la clase base son heredados de la clase
derivada resultado en el momento de la ejecucin del sistema conseguir
confundir a usar lo que el conjunto de funciones miembro de clase base.
Esto puede evitarse haciendo que la clase base comn fuera clase base
virtual.
Ejemplo
class student { };
class test : virtual public student { };

class sports : virtual public student { };
class result : public test, sports { };

15. Programacin C/C++ paso a paso - Sobrecarga de Operadores
1. Introduccin
2. Operador
* Reglas de la sobrecarga de operadores
* Restricciones de sobrecarga de operadores
3. Sobrecarga de operadores unarios
4. Sobrecarga de operadores binarios
5. Sobrecarga de operadores con cadenas
1. Introduccin
15. Programacin C/C++ paso a paso - Sobrecarga de Operadores
1. Introduccin
2. Operador
* Reglas de la sobrecarga de operadores
* Restricciones de sobrecarga de operadores
5. Sobrecarga de operadores con cadenas
1. Introduccin
===============================================
=====
// Assign a variable to another
#include <iostream>
int main()
{
int a = 10, b;
b = a;
// valid
cout << b;
return 0;
}
===============================================
=====
===============================================
=====
// Assign an object to another
#include <iostream>
class emp
{
public:
int eno;
float sal;
};
int main()
{
emp e1= { 1001, 2300.45 },e2 ;
cout << endl << e1.eno << e1.sal;

e2 = e1;
// valid

return 0;
}
===============================================
=====
Las expresiones son comunes en todos los lenguajes, una expresin
es un coleccin de operandos y operadores. En caso de que una
operacin sea una coleccin de expresiones.
Estos dos programas demuestran cmo las variables / objetos fueron

asignado juntos.
Ambos programas son vlidos, se muestra el uso del operador

equalto (=) (igual a)
===============================================
=====
// Assign an object to another
#include <iostream>
class emp
{
public:
int eno;
float sal;
};
int main()
{
emp e1= { 1001, 2300.45 },e2=e1,e3 ;
e3 = e1 + e2;
// Operacin Estructura Ilegal.

return 0;
}
===============================================
=====
La sobrecarga de operadores es una de las caractersticas ms

interesantes de programacin orientada a objetos. Se utiliza para
superar la situacin como la operacin por encima listada de la
estructura ilegal. Puede transformar un programa oscuro y complejos,
en un listado intuitivamente obvio.
A travs de la sobrecarga de operadores podemos ver cmo los

operadores de C++ normales pueden recibir nuevos significados cuando
se aplica a los tipos de datos definidos por el usuario.
El operador de la palabra clave se utiliza sobrecargar un operador y

el operador resultante adoptar el significado suministrado por el
programador.
Por ejemplo, utilizando objetos podemos realizar la asignacin de

una operacin de asignacin directa de cadena
===============================================
=====
// Program to assign a string to other
#include <string.h>
#include <stdio.h>
#include <iostream>
class string
{
char *str;
public:
string() { }
string(char *s) { str = s; }
void putstring()
{
cout << str;
}
};
int main()
{
string s1("LinuxParty");
string s2;
s2 = s1;
s2.putstring();
return 0;
}
===============================================
=====
2. Operador
Tipo de operador operador-smbolo (parmetro de la lista)
La palabra clave del operador declara una funcin que especifica qu

significa el operador-smbolo y cuando se aplica a las instancias de
una clase. Este le da al operador ms de un significado, o
"sobrecarga" que el compilador distingue entre los diferentes
significados de un operador mediante el examen de los tipos de sus
operandos.
Reglas de sobrecarga de operadores
* Se pueden sobrecargar los siguientes operadores:
<
>
+=
-=
^=
&=
|=
<<
>>
<<=
<=
>=
&&
||
++
--
()
[]
new
delete
*=
/=
%=
!=
->
->*
&
>>= ==
Si un operador puede utilizarse como un otro operador unario

o binario, puede sobrecargar cada uso por separado.
Se puede sobrecargar un operador utilizando una funcin no

esttica o miembro o una funcin global que es un amigo
(friend) de una clase. Una funcin global debe tener por lo
menos un parmetro que sea de tipo de clase o una referencia al
tipo de clase.
Si un operador unario est sobrecargado utilizando una funcin

miembro, no toma ningn argumento. Si se est sobrecargado con
una funcin global, toma un argumento.
Si un operador binario est sobrecargado utilizando una funcin

miembro, tomar un argumento. Si se est sobrecargado utilizando
una funcin global, tomar dos de los argumentos.
Restricciones a la sobrecarga de operadores
No se pueden definir nuevos operadores, tales como **.
No puede cambiar la prioridad o agrupacin de un operador,

Tampoco podr cambiar el nmero de operandos que acepta.
No se puede redefinir el significado de un operador cuando

se aplica a tipos de datos incorporados.
Los Operadores sobrecargados no pueden tomar argumentos

predeterminados.
No puede sobrecargar cualquier smbolo de preprocesador,

ni se pueden sobrecargar los siguientes operadores:
.*
::
?:
El operador de asignacin tiene algunas restricciones adicionales.

Puede ser sobrecargado slo como una funcin miembro no esttica, no
como a un funcin friend. Es el nico operador que no puede ser
heredado, una clase derivada no puede utilizar el operador de
asignacin de una clase base
Vamos a empezar por la sobrecarga de un operador unario. Los

operadores unarios actan en un solo operando. (Un operando es
simplemente una variable actuada por un operador). Ejemplos de
operadores unarios son el incremento y decremento ++ y --, y el
unario minus.
Ejemplo:
El siguiente ejemplo muestra el uso del operador de incremento ++.
===============================================
=====
#include <iostream>
class counter
{
private:
unsigned int count;
public:
counter(){ count = 0; }
int get_count() { return count; }
counter operator ++()
{
count++;
counter temp;
temp.count = count;
return temp;
}
};
int main()
{
counter c1, c2;
// c1 = 0, c2 = 0
cout << "\nC1 = " << c1.get_count();
// display
++c1;
c2 = ++c1 ;
// c1 = 1
// c1 = 2, c2 = 2

cout << "\nC2 = " << c2++.get_count();
// display again
// c2 = 3
return 0;
}
===============================================
=====
Un ejemplo ms sobre la sobrecarga del unuario minus.
===============================================
=====
#include <iostream>
class subtract
{
int a;
int b;
public:
void getdata(int x, int y)
{
a = x; b = y;
}
void putdata()
{
cout<< endl << "A = " << a <<"B = " << b;
}
void operator -()
// operador minus
{
a = -a; b = -b;
}
};
int main()
{
subtract s;
s.getdata(34, -6);
cout << endl << "S : ";
s.putdata();
-s;
cout << endl << "S : ";
s.putdata();
return 0;
}
===============================================
=====
Los operadores binarios se pueden sobrecargar la misma facilidad que

los operadores unarios.
Veremos ejemplos de que los operadores aritmticos de sobrecarga,

operadores de comparacin y aritmticos de asignacin
Acabamos de ver cmo se sobrecarga un operador unario. El mismo

mecanismo puede ser usado para sobrecargar un operador binario.
===============================================
=====
// Overloading + operator
#include <iostream>
class time
{
int hh; int mm; int ss;
public:
time( ) { }
time(int h, int m, int s)
{
hh =h; mm = m; ss = s;
}
void disp_time()
{
cout << endl << hh<< " : "

<< mm << " : " << ss;
}
time operator+(time);
};
time time::operator+(time t)
{
time temp;
temp.hh = hh + t.hh;
temp.mm = mm + t.mm;
temp.ss = ss + t.ss;
return temp;
}
int main()
{
time t1(12,1,24) , t2(5, 23, 45), t3;
t3 = t1 + t2;
t3.disp_time();
return 0;
}
===============================================
=====
5. Operador de sobrecarga con cadenas
C y C++ tratan las cadenas de manera muy diferente; nosotros nunca

copiaremos, concatenaremos o compararemos cadenas utilizando
operadores como en otros lenguajes. C y C++ ha construido funciones
para realizar lo anterior. Pero C++ proporciona la posibilidad de
hacer todas las cosas de cadenas utilizando los operadores. Eso
significa que tenemos que poner responsabilidad extra sobre los
operadores que realizan tales cosas.
El ejemplo siguiente muestra la comparacin entre dos

cadenas mediante el operador de comparacin de cadenas ==.
===============================================
=====
// Program to compare two strings using operator overloading
#include <string.h>
#include <stdio.h>
#include <iostream>
enum boolean{ false, true };
class string
{
char *str;
public:
string() { *str = NULL; }
int operator ==(string ts)

{
if (strcmp(str, ts.str) >= 0)
return true;
else
return false;
}
};
int main()
{
string s1("Computer");
string s2("Computers");
if(s1 == s2)
cout << "Equal";
else
cout << "Not Equal";
return 0;
}
===============================================
=====
===============================================
=====
// concatenation of two strings
#include <string.h>
#include <stdio.h>
#include <iostream>
class string
{
char *str;
public:
string()
{
str = new char[30] ;
*str = NULL;
}
string operator +(string ts)
{
string t;
strcat(t.str, str);
strcat(t.str, ts.str);
return t;
}
void putstring()
{
cout << endl << str;

}
};
int main()
{
string s1("LinuxParty"); string s2("Instituto");
s1.putstring(); s2.putstring();
string s3;
s3 = s1 + s2;
s3.putstring();
return 0;
}

16. Programacin C/C++ paso a paso C/C++ --- Polimorfismo
1.
2.
3.
4.
5.
6.
7.
8.
9.
Funcin de Sobrecarga
Polimorfismo
Tipos de polimorfismo
Accesos con punteros a miembros de funciones Normal
Funcin Virtual
Funcin Pura.
Asignacin y copia-inicializacin
El constructor COPY
El puntero "this"
---------------------------------------1. Funcin de sobrecarga

Si una funcin con igual nombre difiere por comportamiento de argumentos
que se le pasen, se denomina polimorfismo de funciones o
sobrecarga de funcin. Si, podan haberlo llamado polimorfismo por
argumentos, pero lo llamaron polimorfismo por sobrecarga.
16. Programacin C/C++ paso a paso C/C++ --- Poliformismo
1. Funcin de Sobrecarga
2. Polimorfismo
3. Tipos de polimorfismo
4. Accesos con punteros a miembros de funciones Normal
5. Funcin Virtual
6. Funcin Pura.
7. Asignacin y copia-inicializacin
8. El constructor COPY
9. El puntero "this"
--------------------------------------------------------1. Funcin de sobrecarga
Si una funcin con igual nombre difiere por comportamiento de argumentos

que se le pasen, se denomina polimorfismo de funciones o
sobrecarga de funcin. Si, podan haberlo llamado poliformismo por
argumentos, pero lo llamaron poliformismo por sobrecarga.
===============================================
================
// Un programa ejemplo para demostrar el uso de la funcin de sobrecarga
#include <iostream>
// ------------------------void printline()
{
for(int i=0;i<=80; i++) cout << "-";
}
// ------------------------void printline(int n)
{
for(int i =0 ;i<=n;i++) cout << "-";
}
// ------------------------void printline(int n,char ch)

{
for(int i=0;i<=n; i++) cout << ch;
}
// ------------------------int main()
{
printline();
printline(5);
printline(10, "*");
return 0;
}
===============================================
================
Polimorfismo
El polimorfismo es una de las caractersticas fundamentales de la POO.

Simplemente significa: un nombre, multiples formas. Ya hemos visto cmo
el concepto de polimorfismo se implementa mediante funciones
sobrecargadas
y operadores. La sobrecarga de funciones "member" son seleccionados para
invocar haciendo coincidir argumentos, tanto el tipo y nmero. El
compilador conoce esta informacin y lo compila en tiempo de compilacin,
por lo que es capaz de seleccionar la funcin adecuada para una llamada en
particular en el momento de la compilacin en s. Esto se llama primer
enlace o enlace esttico o vinculacin esttica.
Tambin conocido como tiempo de compilacin polimrfica, el enlace

primero simplemente significa que un objeto est obligado a sus
funciones de llamada en tiempo de compilacin.
Ahora consideremos una situacin en la que el nombre de funcin y el

prototipo es la misma la base y clases derivadas. Por ejemplo, considera
las siguientes definiciones de clase.
===============================================
================
#include <iostream>
// ------------------------class A
{
int x;
public : void show();
};
// ------------------------class B : public A
{
int y;
public : void show();
};
// ------------------------int main()
{
B b;
b.show();
return 0;
}
===============================================
================
Cmo utilizamos la funcin miembro show() para imprimir los valores de

los objetos tanto en las clases A y B? Dado que el prototipo de show() es
la misma en ambos lugares, la funcin no est sobrecargada y por lo

tanto la vinculancin no es aplicable. De hecho, el compilador no sabe
qu hacer y aplazar la decisin.
Sera agradable si la funcin de miembro apropiada pudiera ser seleccionada

mientras que el programa se est ejecutando. Esto se conoce como
polimorfismo en tiempo de ejecucin. Cmo sucede? C++ es compatible
con un mecanismo conocido como funcin virtual para conseguir el
polimorfismo en tiempo de ejecucin. En tiempo de ejecucin, cuando se
sabe qu clase objetos estn bajo consideracin, se llama a la funcin
adecuada.
Dado que la funcin est enlazada con una clase particular, tras la
compilacin, este proceso se denomina como "el enlace". Tambin es
conocido como enlace dinmico o la vinculacin dinmica, porque
la seleccin de las funciones correspondientes se realiza de forma
dinmica en tiempo de ejecucin.
-------------------------------------------------------------3. Tipos de polimorfismo
Hay dos tipos de polimorfismo, llamados:
1 Polimorfismo en tiempo de compilacin

O.. Early binding (enlace temprano)
O.. Static binding (enlace esttico)
O.. Static linking polymorphism. (enlace esttico polifrmico)?
Cuando Un objeto est vinculado a su funcin de llamada en tiempo de

compilacin
2 Runtime polymorphism (poliformismo en tiempo de ejecucin)

O.. late binding (enlace)
O.. Dynamic binding (enlace dinmico)
O.. Dynamic linking polymorphism. (enlace dinmico polifrmico)?
La seleccin y funcin apropiada se hace dinmicamente en tiempo de

ejecucin.
Enlace dinmico es una de las potentes caractersticas de C++. Esto requiere

la
el uso de punteros a objetos. Vamos a discutir en detalle cmo los objeto
punteros y funciones virtuales se utilizan para implementar el enlace
dinmico.
4. Funciones miembros "Normal" consultado con punteros.
La continuacin del programa consistir en una clase base
===============================================
================
/* Funciones Normales accedidas desde punteros */
/* Poliformismo con classes (Sin utilizar poliformismo VIRTUAL) */
#include <iostream>
// ------------------------class BASE
{
public :
void disp() { cout << "\nEsts en la clase BASE class"; }
};
// ------------------------class DERIVED1 : public BASE

{
public :
void disp() { cout << "\nEsts en la clase DERIVED1 class"; }
};
// ------------------------class DERIVED2 : public BASE

{
public :
void disp() { cout << "\nEsts en la clase DERIVED2 class\n"; }
};
// ------------------------int main()
{
DERIVED1 d1;
// d1 objecto derivado de la primera clase
DERIVED2 d2;
// d2 objecto derivado de la segunda clase

// Ambas son derivadas de la clase BASE.
BASE *b;
// Puntero a clase BASE
b=&d1;
// Asignacin de la direccin de d1 en el puntero b
b->disp();
// Llamada a disp()
b=&d2;
// Asignacin de la direccin de d2 en el puntero b
b->disp();
// call to disp()
cout << "\n Fantstico \n";

return 0;
}
===============================================
================
El programa de arriba demuestra:
* Una clase BASE

* DERIVED1, DERIVED2 son clases derivadas de BASE
* Objetos derivados de clases (d1,d2)
* *b es un puntero a la clase BASE
Salida:
Ests en la clase BASE class

Ests en la clase BASE class
5. Funcin Virtual
Virtual significa que existe en efecto pero no en la realidad.

Una funcin puede haber sido hecha como una funcin virtual por el
procedimiento
de la funcin miembro.
En este ejemplo si llamamos a los mtodos de la clase B:
Bptr = &b;
// Bptr tiene ahora la direccin de B
Bptr->show();
Bptr->disp();
// Base class member
llamaremos a la funcin virtual que hay en ella, pero si llamamos a los

mtodos
que hay en la funcin D:
Bptr=&d;
// Bptr tiene ahora la direccin de d, que es derivada b
Bptr->show();
// derived class members
Bptr->disp();
Los mtodos de la funcin virtual que hay en B no se mostrar, llamando a la

funcin normal show (de B) y disp (de D)
Mira el ejemplo:
===============================================
================
/* Poliformismo con Clases (Virtual polymorphism) */
#include <iostream>
// ------------------------class B
{
public :
void show(){ cout << "\nclass B method Show() "; }
// esta es la funcin virtual disp

virtual void disp() { cout << "\n (virtual) class B method disp()"; }
};
// ------------------------class D : public B
{
public :
void show(){cout << "\nclass D method Show() "; }
void disp(){ cout << "\nclass D method disp()"; }
};
// ------------------------int main()
{
D d1;
/* Objeto d1 de la clase D */
d1.show();
d1.disp();
// Miembro de la clase Base
cout << "\nArriba salida d1.show y d1.disp\n";
B b;
/* Objeto b, de la clase B */
D d;
/* Objeto d, de la clase D */
B *Bptr;
/* Bptr es un puntero a clase B */
Bptr = &b;
Bptr->show();
// Bptr tiene ahora la direccin de B
Bptr->disp();
cout << "\nArriba salida... Bptr=&b; Btrp->show y Btrp->disp\n";
Bptr=&d;
// Bptr tiene ahora la direccin de d, que es derivada b
Bptr->show();
// derived class members
Bptr->disp();
cout << "\nArriba salida Bptr=&d; Btrp->show y Btrp->disp\n";
return 0;
}
===============================================
================
(Compilamos escribiendo...)
g++ d1.cpp ; ./a.out
Salida:
class D method Show()

class D method disp()
Arriba salida d1.show y d1.disp
class B method Show()

(virtual) class B method disp()
Arriba salida... Bptr=&b; Btrp->show y Btrp->disp

Arriba salida Bptr=&d; Btrp->show y Btrp->disp
6. Funcin pura
Una funcin definida en una clase base y sin definicin respecto a una
clase derivada se llama funcin pura. En palabras simples es una funcin pura
una funcin virtual con ningn cuerpo.
===============================================
================
#include <iostream>
// ------------------------class B
{
public :
void show(){ cout << "\nclass B method Show() "; }
virtual void disp() = 0; // pure virtual function
};
// ------------------------class D : public B
{
public :
void show(){cout << "\nclass D method Show() "; }
void disp(){ cout << "\nclass D method disp()"; }
};
// ------------------------int main()
{
D d1;
d1.show(); // Class D method show()
d1.disp(); // Class D method disp()
D d;
B *Bptr;
Bptr=&d;
Bptr->show(); // Class B method show()
Bptr->disp(); // Class D method disp()
return 0;
}
===============================================
================
Salida:
class D method Show()

Atrevete a hacer algunas modificaciones en el programa, aade por encima de

la
sentencia "return 0;" estas lnas y lo compilas, para ver que pasa...
--------------------D *Dptr;
Dptr=&d;
Dptr->show(); // Qu saldr?
Dptr->disp(); // Qu saldr?
----------------------
===============================================
================
/* Programa para desmostrar la ventaja de las funciones virtuales puras */
#include <iostream>
enum boolean { FALSE, TRUE };
// ------------------------class NAME
{
protected : char name[20];
public :
void getname()
{ cout << "Introduce nombre :"; cin >> name; }
void showname()
{ cout << "\nEl nombre es: "<< name; }
boolean virtual isGradeA() = 0; // pure virtual function

};
// ------------------------class student : public NAME

{
private : float avg;
public :
void getavg()
{
cout << "\nIntroduce media del estudiante :";
cin >> avg;
}
boolean isGradeA()
{ return (avg>=80) ? TRUE : FALSE ; }
};
// ------------------------class employee : public NAME

{
private : int sal;
public :
void getsal()
{ cout << "\nIntroduce un sueldo "; cin >> sal; }
boolean isGradeA()
{ return (sal>=10000) ? TRUE : FALSE ; }
};
// ------------------------int main()
{
NAME *names[20];
// es un puntero a NAME
student *s;
// Puntero a student
employee *e;
// Puntero a employee
int n = 0;
// Nmero de nombres en la lista
char choice;
do{
cout << "Introduce e[S]tudiante o [E]mpleado (s/e) ";
cin >> choice;
if(choice=='s')
{
s = new student; // crea un nuevo student
s->getname();
s->getavg();
names[n++]=s;
}
else
{
e = new employee; // crea un nuevo employee
e->getname();
e->getsal();
names[n++]=e;
}
cout << " Introducir otro (y/n) ?"; // otra vez?
cin >> choice;
} while(choice=='y');
for(int j=0; j<n; j++)

{
names[j]->showname( );
if(names[j]->isGradeA( )==true)
cout << "He is Grade 1 person";
}
return 0;
}
===============================================
================
7. Asignacin y copia-inicializacin
El compilador C++ siempre est ocupado en su nombre, haciendo cosas que

usted no se ha
tomado la molestia de hacer. Si usted lo asumiera, lo aplazara a su juicio;
de lo contrario, hara las cosas a su manera. Dos ejemplos importantes de este
proceso son el operador de asignacin y el constructor de copia.
Ha utilizado el operador de asignacin muchas veces, probablemente sin

pensar
mucho al respecto. Supongamos que a1 y a2 son objetos. A menos que le diga
la
compilador de lo contrario, la declaracin.
a2 = a1;
// Asignar a a2 el vaor a1
Har que el compilador copie los datos de a1, miembro por miembro, en
a2. Esta es la accin predeterminada del operador de asignacin,
Tambin est familiarizado con la inicializacin de variables, la inicializacin

de un objeto con otro objeto, tal como:
alpha a2(a1);
// Inicializa a2 con el valor a1
Provoca una accin similar. El compilador crea un nuevo objeto, a2, y copia
los datos de a1, miembro por miembro, en a2. Esta es la accin
predeterminada de
el constructor de copia.
Ambas actividades se ofrecen por defecto, de forma gratuita, por el

compilador.
Si la copia miembro por miembro es lo que usted quiere, usted no necesita
hacer nada ms
que adoptar estas nuevas medidas. Sin embargo, si desea que la asignacin
de inicializacin
haga algo ms complejo, a continuacin, puede reemplazar las funciones por
defecto. Nosotros
discutiremos las tcnicas de la sobrecarga del operador de asignacin y el
constructor
de copia por separado.
Sobrecarga del operador de asignacin
===============================================
================
// Overloading the Assignment ( = ) Operator
#include <iostream>
// -------------------------
class alpha
{
private:
int data;
public:
alpha() { } // no-arg constructor
alpha( int d )
{ data = d; } // one-arg constructor
void display()
{ cout << data; } // Display data
alpha operator =(alpha & a) // overloaded = operator

{
data = a.data; // not done automatically
cout << "\n Assignment operator invoked ";
return alpha(data);
}
};
// ------------------------int main()
{
alpha a1(37);
alpha a2;
a2 = a1; // Invoke overloaded =

cout << "\n a2 = "; a2.display(); // display a2
alpha a3 = a2; // does NOT invoke =

cout << "\n a3 = "; a3.display(); // display a3
cout << "\n";
return 0;
}
===============================================
================
Salida:
a2 = 37
a3 = 37
8. El constructor COPY
Como ya comentamos, podemos definir y al mismo tiempo iniciar un objeto

al valor de otro objeto con dos tipos de declaracin:
alpha a3(a2);
// Copy initializing
alpha a3 = a2;
// copy initialization, alterando la sintaxis
Ambos estilos de la definicin de invocar a un constructor de copia: es decir,

un
constructor que copia su argumento en un nuevo objeto. La copia por defecto
constructor, que se proporciona de forma automtica por el compilador para
cada
objeto, realiza una copia miembro por miembro. Esto es similar a lo hace el
operador de asignacin, la diferencia es que el constructor de copia, tambin
crea
un nuevo objeto.
En el ejemplo siguiente se muestra el constructor de copia.
===============================================
================
#include <iostream>
// ------------------------class alpha
{
private :
int data;
public:
alpha( ) { }
alpha(int d) { data = d; }
alpha(alpha& a)
// no-args constructor
// one-arg constructor
// copy constructor
{
data = a.data;
cout << "\nCopy constructor invoked";
}
void display( )
{ cout << data; }
void operator = (alpha& a)
// overloaded = operator
{
data = a.data;
cout << "\nAssignment operator invoked";
}
};
// ------------------------int main()
{
alpha a1( 37 );
alpha a2;
a2 = a1; // invoke overloaded =

cout << "\na2 = "; a2.display(); // display a2
alpha a3( a1 ); // invoke copy constructor
// alpha a3 = a1; // equivalent definition of a3
cout << "\na3 = "; a3.display(); // display a3

cout << "\n";
return 0;
}
===============================================
================
El programa de arriba sobrecarga ambos, tanto el operador de asignacin y la

copia
constructor.
El operador de asignacin sobrecargado es similar a la del ejemplo anterior.
9. El puntero "this"
C++ utiliza una palabra clave nica llamada "this" que representa un objeto
que invoca
a una funcin miembro. Este es un puntero que apunta al objeto para el que
esta funcin fue llamada.
Estos punteros simplemente realizan la tarea para volver al mismo objeto.
El siguiente programa define los objetos i, j y a "i" se le asigna el

valor 5 y todo objeto de i es asignado por su funcin de miembro a j
===============================================
================
#include <iostream>
// ------------------------class A
{
int a;
public:
A() { }
A(int x)
{ a = x; }
void display()
{
cout << a;
}
A get()
{
return *this; // Return it self
}
};
// -------------------------
int main()
{
A i(5);
cout << "\ni.display()\n"; i.display();
A j;
j = i.get();
cout << "\nj.display()\n"; j.display();
cout << "\n";
return 0;
}
===============================================
================
Salida:
i.display()
5
j.display()
5
Ref: Programacin Orientada a Objeto en Turbo C++: Robert Lafore
Recomendamos encarecidamente usar el compilador GCC tanto en Windows
como en Mac. Por supuesto en Linux se utiizar siempre gcc para compilar los
programas en C y g++ para C++, si lo desea puede utilizar en todo momento
g++ que en Ubuntu lo han llamado g.
EOF.

Tutorial de C

Uploaded by

Document Information

Original Description:

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Tutorial de C

Uploaded by

Copyright:

Available Formats

Tutorial de C/C++, programar paso a paso, para Linux,

Tutorial de C++, entrega N 1

Tambin es fundamental hacerlo desde la lnea de comandos, por lo que por

g++ -o hola hola.cpp

Sufijos en nombres de archivo.

.C .cc .cpp .c+

fuente en C++; se recomienda .cpp

fuente en lenguaje ensamblador

archivo para preprocesador (encabezados), no suele figurar en

Usaremos como ejemplo este sencillo programa de prueba, circulo.c:

/* Circulo.c: calcula el rea de un crculo.

El ensamblador se denomina as:

El enlazador se denomina ld. El comando para enlazar

No se crea el archivo circulo.o; el cdigo objeto intermedio se crea y destruye

Enlace dinmico y esttico.

Ejemplo de enlazado esttico:

Tutorial de C++, Entrega N 2

II. Fundamentos de la programacin

Introduccin al lenguaje y las expresiones

Desarrollo del lenguaje C

C como un lenguaje de propsito general

general el lenguaje de programacin C se asemeja a algunos otros lenguajes

Demasiado general, demasiado

Duro de aprender, difcil de

Slo podra hacer problemas

Ken Thompson AT & Slo podra hacer problemas

Dennis Ritchie AT & Restructurado, perdi la

Bjarne Stroustrup AT Introdujo la Programacin

- Lenguaje de bloques estructurado

II. Fundamentos de la programacin

1. Tipo de datos numricos: Funciona slo con nmeros. Estos nmeros

2, 147, 483, 647 N/a

1.7 x 10-308 1.7 x 10308

long double3.4 x 10-4932 3.4 x 10-4932

Tutorial de C++, Entrega N 3

Para Debian/Ubuntu, instale el compilador GCC C (como root) mediante el uso de

sudo apt-get install g

Si no puede convertirse en root, obtenga el tarball de ftp://ftp.gnu.org/ y siga las

1.2. Para Mac OS X

Ir a la http://www.bloodshed.net/devcpp.html, elija la versin que desea, haga clic

Inicie el IDE y la experiencia de su primer proyecto!

Compilacin: (el compilador puede ser g, o gcc)

Tutorial de C++, Entrega N 4

de valor de retorno > main ( arg-list )

<p>Necesita un navegador que use frames

Bell(beep) "alarma sonora"

Desde "final de la lnea" (from feed)

Muestra una nica \

Muestra comillas simples

Muestra comillas dobles.

2. Programa que imprime mensaje tras una nueva lnea.

3.- Programa que muestra la direccin de una persona.

Utilizando variables en los programas.

| -3.4 x 10^38 | 3.4 x 10^38 |

| -3.4 x 10^4932| 3.4 x 10^4932

4. Programa que resuelve la suma de dos valores.

5. Programa que resuelve la suma de dos valores, con un mensaje

/* Espera un valor decimal */

/* Espera un valor de cadena */

scanf("%d%d%d", &m1, &m2, &m3);

/* Espera tres valores separados

6. Programa que resuelve la suma de dos valores usando scanf

7. Programa que resuelve la suma de dos valores con mensajes de salida.