Notas Digitales: B.Tech (I Año - Ii Sem) (2018-19)

PROGRAMACIÓN ORIENTADA A OBJETOS
NOTAS DIGITALES
B.TECH
(I AÑO - II SEM)
(2018-19)
DEPARTAMENTO DE CSE & IT
LNVETOLEARN&LEARNTO
MALLA REDDY COLLEGE OF ENGINEERING & TECHNOLOGY

(Institución autónoma - UGC, Gobierno de la India)
Reconocido bajo 2(f) y 12 (B) de UGC ACT 1956 (Afiliado a JNTUH, Hyderabad, Aprobado por AICTE -
Acreditado por NBA & NAAC - Grado 'A' - Certificado ISO 9001:2015) Maisammaguda, Dhulapally (Post Via.
Hakimpet), Secunderabad - 500100, Estado de Telangana, India.
I Año B.Tech II SEM L T/P/D C

4 1/-/- 3
(R18A0502)PROGRAMACIÓN ORIENTADA A OBJETOS
Objetivos
• Enseñar al alumno los conceptos de programación orientada a objetos y a procedimientos
• Diferenciar entre funciones, clases y objetos
• Aprender a sobrecargar funciones y operadores
• Diseñar aplicaciones utilizando técnicas de gestión dinámica de la memoria
• Enseñar al alumno a aplicar la programación genérica y el tratamiento de excepciones
Unidad I
Introducción a la Programación Orientada a Objetos: Paradigma orientado a objetos-Diferencias
entre Programación Orientada a Objetos y Programación Orientada a Procedimientos, Conceptos
básicos de la Programación Orientada a Objetos, Encapsulamiento, Herencia y Polimorfismo,
Beneficios de la POO, Estructura de un programa C++, Espacio de nombres, Tipos de datos, Tokens C+
+, Identificadores, Variables, Constantes, Operadores, Estructuras de control y Bucles.
Unidad-II
Funciones, clases y objetos:
Introducción de Clases, Definición de Clases, Definición de Miembros, Objetos, Control de Acceso,
Ámbito de Clase, Operador de Resolución de Ámbito, Funciones Inline, Asignación de Memoria para
Objetos, Miembros de Datos Estáticos, Funciones de Miembros Estáticos, Arrays de Objetos, Objetos
como Argumentos de Funciones, Funciones Amigas.
Unidad-III
Constructores, destructores, herencia:
Introducción a los Constructores, Constructores por defecto, Constructores parametrizados, Copiar
Constructores, Múltiples Constructores en una Clase, Destructores.
Herencia :
Introducción a la herencia, Definición de clases derivadas, Herencia simple, Herencia múltiple,
Herencia multinivel, Herencia jerárquica, Herencia híbrida.
Unidad-IV
Punteros, funciones virtuales y polimorfismo:
Introducción a la gestión de memoria, operador new y operador delete, punteros a objetos, punteros
a clases derivadas, polimorfismo, polimorfismo en tiempo de compilación, polimorfismo en tiempo
de ejecución, funciones virtuales, sobrecarga - sobrecarga de funciones, sobrecarga de operadores.
Unidad-V
Plantillas y gestión de excepciones:
Introducción a las Plantillas, Plantillas de Clases, Plantillas de Clases con Múltiples Parámetros,
Plantillas de Funciones, Plantillas de Funciones con Múltiples Parámetros.
Gestión de excepciones:
Fundamentos del manejo de excepciones, tipos de excepciones, mecanismo de manejo de
excepciones, mecanismo de lanzamiento y captura, relanzamiento de una excepción, especificación
de excepciones.
Resultados:
• Diferenciar la programación orientada a objetos de la programación procedimental.
• Construir clases, funciones y objetos
• Para implementar los constructores, destructores y la herencia
• Desarrollar programas utilizando técnicas de gestión dinámica de la memoria
• Aplicar el tratamiento de excepciones y la programación genérica.
Libros de texto:
1. Programación orientada a objetos con C++ por Balagurusamy
2. C++, the Complete Reference,4ª edición, Herbert Schildt, TMH.
Referencias:
1. C++ Primer,3.ª edición, S.B.Lippman y J.Lajoie, Pearson Education.
2. El lenguaje de programación C++,3ª edición, B.Stroutstrup, Pearson Educ.
UNIDAD -1
Conceptos de Programación Orientada a Objetos: Paradigma orientado a objetos-diferencias entre

Programación Orientada a Objetos y Programación Orientada a Procedimientos, Conceptos básicos de
Programación Orientada a Objetos,Encapsulación, Herencia y Polimorfismo. Estructura de un programa C++,
espacio de nombres, tipos de datos, tokens C++, identificadores, variables, constantes, operadores, estructuras
de control y bucles.
Visión general del lenguaje C:

1. El lenguaje C se conoce como lenguaje orientado a estructuras o lenguaje orientado a procedimientos
2. Emplea un enfoque de programación descendente en el que un problema se considera una secuencia de tareas
que hay que realizar.
3. Todo el código de programa de c se puede ejecutar en C++ pero a la inversa muchos no son posibles
4. La sobrecarga de funciones y la sobrecarga de operadores no son posibles.
5. Las variables locales sólo pueden declararse al principio del bloque.
6. Los controles del programa se realizan mediante saltos y llamadas a subrutinas.
7. El polimorfismo, la encapsulación y la herencia no son posibles.
Para resolverlos, el problema se divide en varios módulos. Cada módulo es un subprograma.
8. La propiedad de abstracción de datos no está soportada por el lenguaje orientado a procedimientos.
9. Los datos en lenguaje orientado a procedimientos son abiertos y cualquier función puede acceder a ellos.
Visión general del lenguaje C++:

1. C++ puede considerarse como una versión incremental del lenguaje c que consta de todas las construcciones
del lenguaje de programación con nuevas características añadidas de programación orientada a objetos.
2. c++ es un lenguaje de programación orientado a estructuras (procedimientos) y a objetos.
3. La extensión de archivo del programa C++ es ".CPP".
4. Son posibles la sobrecarga de funciones y la sobrecarga de operadores.
5. Las variables pueden declararse en línea, es decir, cuando sea necesario
6. En c++ se da más importancia a los datos que a los procedimientos
7. El polimorfismo, la encapsulación y la herencia son posibles.
8. La propiedad de abstracción de datos está soportada por c++.
9. El acceso a los datos es limitado. Se puede acceder a ella proporcionando varios modos de visibilidad tanto
para los datos como para las funciones miembro. allí proporcionando seguridad a los datos mediante la ocultación
de los mismos.
10. La unión dinámica es compatible con C++
11. Soporta todas las características del lenguaje c
12.Se puede denominar como una versión incremental del lenguaje c
Diferencia entre la programación orientada a procedimientos (POP) y la programación orientada a objetos
(POO)
Programación orientada a procedimientos Programación orientada a objetos

programa se divide en pequeñas partes
1
programa se divide en partes denominadas objetos.
llamadas funciones.
No se da importancia a los datos , sino a las Se da más importancia a los datos que a los
2
funciones, así como a la secuencia de procedimientos o funciones porque funciona como
acciones que deben realizarse. el mundo real.
3 La programación orientada a objetos sigue un
sigue el enfoque Top Down.
enfoque ascendente.
La programación orientada a objetos tiene
4 No tiene ningún especificador de acceso. especificadores de acceso denominados Público,
Privado, Protegido, etc.
Los datos pueden pasar libremente de una los objetos pueden moverse y comunicarse entre
5
función a otra del sistema. sí mediante funciones miembro.
Añadir nuevos datos y funciones en POP no es La programación orientada a objetos permite
6
tan fácil. añadir fácilmente nuevos datos y funciones.
La mayoría de las funciones utilizan datos En la programación orientada a objetos, los datos
7 globales para compartir a los que se puede no se pueden mover fácilmente de una función a
acceder libremente de una función a otra del otra, sino que se pueden mantener públicos o
sistema.
No tiene ninguna forma adecuada de ocultar los privados para queorientada
La programación podamos acontrolar el acceso a
objetos proporciona
8
datos, por lo que es menos seguro. más seguridad al ocultar los datos.
En la programación orientada a objetos, la
9 La sobrecarga no es posible. sobrecarga es posible en forma de sobrecarga de
funciones y sobrecarga de operadores.
Ejemplo de procedimiento orientado Ejemplos de programación orientada a objetos

10
Programación son : C, VB, FORTRAN, Pascal. son : C++, JAVA, VB.NET, C#.NET.
Principios (o características) de la programación orientada a objetos:

1. Encapsulación
2. Abstracción de datos
3. Polimorfismo
4. Herencia
5. Vinculación dinámica
6. Transmisión de mensajes
Encapsulación: Envolver los datos y las funciones como una sola unidad se conoce como encapsulación. Por
defecto, los datos no son accesibles al mundo exterior y sólo son accesibles a través de las funciones que se
envuelven en una clase. la prevención del acceso directo de datos por el programa se llama ocultación de datos u
ocultación de información
Abstracción de datos :
La abstracción se refiere al acto de representar características esenciales sin incluir los detalles
de fondo o la explicación. Las clases utilizan el concepto de abstracción y se definen como una lista de atributos
como tamaño, peso, coste y funciones para operar sobre estos atributos. Encapsulan todas las propiedades
esenciales del objeto que se va a crear. Los atributos se denominan miembros de datos, ya que contienen datos, y
las funciones que operan con estos datos se denominan funciones miembro.
Las clases utilizan el concepto de abstracción de datos por lo que se denominan tipos de datos abstractos
(ADT)
Polimorfismo: Polimorfismo proviene de las palabras griegas "poli" y "morfismo". "poly" significa muchos y
"morfismo" significa forma, es decir, muchas formas. Polimorfismo significa la capacidad de adoptar más de una
forma. Por ejemplo, una operación tiene un comportamiento diferente en distintas instancias. El comportamiento
depende del tipo de datos utilizados en la operación.
Diferentes formas de conseguir polimorfismo en un programa C++:
1) Sobrecarga de funciones 2) Sobrecarga de operadores
#include<iostream>
utilizando el espacio de nombres
std; int main() {inta=4; a=a<<2;
cout<<"a="<<a<<endl;
Devuelve 0;
}
Herencia: La herencia es el proceso por el cual un objeto puede adquirir las propiedades de otro.
La herencia es el concepto más prometedor de la programación orientada a objetos, que ayuda a hacer realidad el
objetivo de construir software a partir de partes reutilizables, en lugar de codificar a mano cada sistema desde
cero. La herencia no sólo favorece la reutilización entre sistemas, sino que también facilita directamente la
extensibilidad dentro de un sistema. La herencia, junto con el polimorfismo y la vinculación dinámica, minimiza
la cantidad de código existente que hay que modificar mientras se mejora un sistema.
Cuando la clase hija hereda la clase padre, la clase hija se denomina clase derivada (subclase) y la clase
padre, clase base (superclase). En este caso, la clase hijo tiene dos partes: una parte derivada y una parte
incremental. La parte derivada se hereda de la clase padre. La parte incremental es el nuevo código escrito
específicamente para la clase hijo.
Encuadernación dinámica:
La vinculación se refiere a la vinculación de la llamada al procedimiento con el código que se ejecutará en
respuesta a la llamada. La vinculación dinámica (o vinculación tardía) significa que el código asociado a una
llamada a un procedimiento determinado no se conoce hasta el momento de la llamada en tiempo de ejecución.
Paso de mensajes:
Un programa orientado a objetos consiste en un conjunto de objetos que se comunican entre sí.
Los objetos se comunican entre sí enviando y recibiendo información .
Un mensaje para un objeto es una solicitud de ejecución de un procedimiento y por lo tanto invocar la
función que se llama para un objeto y genera resultado
Ventajas de la programación orientada a objetos ( POO)

> , ........................... . . Reutilización: En los programas OOP s las funciones y módulos escritos por un usuario pueden ser
reutilizados por otros usuarios sin ninguna modificación.
Herencia: A través de ella podemos eliminar código redundante y extender el uso de clases existentes.
Ocultación de datos: El programador puede ocultar los datos y funciones de una clase a otras clases. Ayuda al programador a
crear programas seguros.
Complejidad reducida de un problema: El problema dado puede verse como una colección de objetos diferentes. Cada
objeto es responsable de una tarea específica. El problema se resuelve interconectando los objetos. Esta técnica reduce la
complejidad del diseño del programa.
Fácil de mantener y actualizar: La programación orientada a objetos facilita el mantenimiento y la modificación

del código existente, ya que se pueden crear nuevos objetos con pequeñas diferencias respecto a los ya existentes. La
complejidad del software puede gestionarse fácilmente.
Paso de mensajes: La técnica de comunicación de mensajes entre objetos facilita la interfaz con sistemas externos.
Modificabilidad: es fácil realizar pequeños cambios en la representación de datos o en los

procedimientos de un programa OO. Los cambios dentro de una clase no afectan a ninguna otra parte de
un programa, ya que la única interfaz pública que el mundo externo tiene con una clase es a través del uso
de métodos.
ESTRUCTURA BÁSICA DEL LENGUAJE C++ : El programa escrito en lenguaje C++ sigue esta estructura
básica. La secuencia de las secciones debe ser la misma que en la estructura básica. Un programa en C debe tener
una o varias secciones, pero hay que seguir la secuencia de las secciones.
1. Sección de documentación
2. Sección de enlaces
3. Sección de definición
4. Sección de declaración global y declaraciones de clase
5. Definición de la función miembro
6. Función principal
section main() {
Sección de declaración Sección ejecutable
1. SECCIÓN DE DOCUMENTACIÓN : viene en primer lugar y se utiliza para documentar el uso de
la lógica o las razones en su programa. Se puede utilizar para escribir el objetivo del programa, el desarrollador y
los detalles lógicos. La documentación se realiza en lenguaje C con /* y */ . Lo que se escribe entre estos dos se
llama comentario.
2. SECCIÓN DE VINCULACIÓN : Esta sección indica al compilador que vincule
determinadas apariciones de palabras clave o funciones de su programa con los archivos de cabecera
especificados en esta sección.
por ejemplo, #include<iostream>
using namespace std;
hace que el preprocesador añada el contenido del archivo iostream al programa. Contiene declaraciones para cout y cin.
>
cout es un objeto predefinido que representa el flujo de salida estándar. El operador << es un
operador de inserción, hace que la cadena entre comillas dobles aparezca en la pantalla.
La sentencia cin>>n; es una sentencia de entrada y hace que el programa espere a que el usuario teclee un
número. El número tecleado se coloca en la variable "n". El identificador cin es un objeto predefinido en C++ que
corresponde al flujo de entrada estándar. El operador >> se conoce como operador de extracción. Extrae el valor
del teclado y lo asigna a la variable de valor situada a su derecha.
3. SECCIÓN DE DEFINICIÓN : Se utiliza para declarar algunas constantes y asignarles

algunas
p.ej. #define MAX 25
Aquí #define es una directiva del compilador que indica al compilador que siempre que se
encuentre MAX en el programa lo sustituya por 25.
4. SECCIÓN DE DECLARACIÓN GLOBAL : Aquí se declaran las variables y definiciones de clase
que se utilizan a lo largo del programa (incluyendo la función principal y otras funciones) para hacerlas globales
(es decir, accesibles a todas las partes del programa). Una CLASE es una colección de datos y funciones que
actúan o manipulan los datos. Los componentes de datos de una clase se denominan miembros de datos y los
componentes de funciones de una clase se denominan funciones miembro
Una clase también se denomina blue print o prototipo que define las variables o funciones comunes a
todos los objetos de un determinado tipo. Es un tipo de datos definido por el usuario
Por ejemplo
int i; //esta declaración se hace fuera y antes de main()
5. SECCIÓN DE SUBPROGRAMAS O FUNCIONES : Contiene todos los subprogramas o funciones

que necesita nuestro programa.
void display()
{
cout<<"C++ es mejor que C";
}
SIMPLE PROGRAMA "C++":
#include<iostream>
void display()
{
cout<<"C++ es mejor que C";
}
int main()
{
mostrar()
Devuelve 0;
}
6. SECCIÓN DE LA FUNCIÓN PRIN CIPAL : Indica al compilador dónde debe comenzar la ejecución
desde main()
{
punto de inicio de la ejecución
}
La función principal tiene dos secciones
1. sección de declaración : En ella se declaran las variables y sus tipos de datos.
2. Sección ejecutable o sección de instrucciones : Tiene la parte del programa que realmente realiza la
tarea que necesitamos.
espacio de nombres:
se utiliza para definir un ámbito que podría contener identificadores globales.
ex:-ámbito del espacio de nombres para la biblioteca estándar de c++.
Las clases, funciones y plantillas se declaran en el espacio de nombres denominado
std using namespace std;-->se puede utilizar la directiva.
espacio de nombres definido por el usuario:

para definir el espacio de nombres es
espacio_nombre_del_nombre
{
//declaraciones de variables.funciones,clases etc...
}
ex:
#include<iostream>
espacio de nombres sample
{`
int m;
void display(int n)
{
cout<<"en el espacio de nombres
} N="<<n<<<endl;
}
using namespace sample;

int main()
{
int a=5;
m=100;
pantalla(200);
cout<<"M en el espacio de nombres de la muestra:"<<muestra::m;
return 0;}
#include<iostream>
Esta directiva hace que el preprocesador añada el contenido del archivo iostream al programa. algunas
versiones antiguas de C++ usaban iostream.h .si el compilador no soporta ANSI (american nation
standard institute) C++ entonces usa el archivo de cabecera iostream.h
TIPOS DE DATOS:
Un tipo de datos se utiliza para indicar el tipo de valor de datos almacenado en una variable. Todos los
compiladores de C admiten diversos tipos de datos. Esta variedad de tipos de datos permite al
programador seleccionar el tipo adecuado a las necesidades tanto de la aplicación como de la máquina.
ANSI C admite las siguientes clases de datos
Tipos de datos primarios:

1.tipo de datos entero
2 Tipo de datos .character
3 .tipo de datos de coma flotante
4 Tipo de datos booleanos
5.tipo de datos void
tipo de datos entero:-
Este tipo de datos se utiliza para almacenar números enteros. Estos números no contienen la parte decimal. El tamaño del
entero depende de la longitud del mundo de una máquina (16 o 32 bits). En una máquina de 16 bits, el rango de valores
enteros es de -32.768 a +32.767.Las variables enteras se declaran mediante la palabra clave int. C proporciona control sobre
el rango de valores enteros y el espacio de almacenamiento ocupado por estos valores a través de los tipos de datos: short int,
int, long int tanto en formas con signo como sin signo.
Enteros con signo: (máquina de 16 bits):

Un entero con signo utiliza 1 bit para el signo y 15 bits para la magnitud del número
Un número entero con signo utiliza 1 bit para el signo y 15 bits para la magnitud del número. ( -215a +215-1).
Ej: firmado tx=100;
0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0
, । । .......
Bit con signo Magnitud
MSB(bit más significativo)
100(10)=00000000001100100(2)
Representación de un número negativo :
-100(10)=1111111110011100(2)
15 14 13 12 11 10 9 8 7 -1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2

+1*2 +
6 5 4 3 2 1 0
0*2 +0*2 +1*2 +1*2 +1*2 +0*2 +0*2
= -32768+16384+8192+4096+2048+1024+512+256+128+0+0+26+8+4+0+0 =-
100(10)
NOTA: Bit con signo (MSB BIT): 0 representa números enteros positivos, 1 representa números negativos
Enteros sin signo: Los enteros sin signo utilizan los 16 bits para almacenar la magnitud. Almacena los números
no tiene ningún signo & Calificador de tamaño y rango de tipo de datos entero en una máquina de 16 bits y se
muestran en la tabla:
MEMORIA NECESARIA
GAMA ESPECIFIC
O TAMAÑO DE
TIPO DE DATOS ALMACENAMIENTO EN BYTES ADOR DE
TURBO C GCC/ TURBO C ( 16 BITS) CCG FORMATO
( 16 BITS) COMPILADORES (32 BIT)
EN LINUX (32 BITS)
int corto
-32768
o 2 2 A 32767 %hd
-32768
int corto con signo A 32767 (-2 a +2 -1) (-2 a +2 -1)
int corto
0 a 65535 (0 a +2 -1) 0 a 65535 (0 a +2 -1)
o int corto
con signo 2 2 %hu
-2.147.843.648 a
2 4
-32768 2.147.843.647 (-2 a +2
int con signo o int %d o %i
A 32767 (-2 a +2 -1) -1)
unsigned int 0 a 65535 0 a 4.294.967.295 (0 a2 -1 )
2 4 (0 a +2 -1) %u
long int o signed
long int -2.147.843.648 a -2.147.843.648 a
4 4 2,147,843,647 2,147,843,647 %ld
31 31
(-2 a +2 -1) (-2 a +2 -1)
unsigned long int 0 a 4.294.967.295 0 a 4.294.967.295 (0 a2 -1 )
4 4 (0 a2 -1 ) %lu
long long int o -9223372036854775808
firmado largo largo A
No se admite 8 ------- 9223372036854775807 (- %Ld
int
263
a +263-1)
Tipo de datos de carácter: (char)

Un único carácter puede definirse como un tipo de datos de caracteres. El tipo de dato carácter ocupa un byte de
memoria para el almacenamiento del carácter. Los calificadores signed o unsigned pueden aplicarse al tipo de
datos char. char es la palabra clave utilizada para declarar variables
El tamaño y el rango del tipo de datos de caracteres en una máquina de 16 o 32 bits pueden mostrarse a
continuación
Tipo de datos MEMORIA NECESARIA O GAMA ESPECIFICADOR DE

TAMAÑO DE FORMATO
ALMACENAMIENTO (en bytes)
char o char con signo 1 -128 a 127(-2 7a 2 -1) %c
Carácter sin signo 1 0 a 256 (0 a 2 -1) %c
Tipos de coma flotante:
El número en coma flotante representa un número real con 6 dígitos de precisión que ocupa 4 bytes de memoria.
Las variables de coma flotante se declaran mediante la palabra clave float.
El tipo de datos de coma flotante doble ocupa 8 bytes de memoria y proporciona 14 dígitos de precisión. También
se conocen como números de doble precisión. Las variables se declaran mediante la palabra clave double long double
se refiere a un tipo de datos de coma flotante que suele ser más preciso que double precision.
El tamaño y el rango de los tipos de datos de coma flotante se muestran en la tabla:
Tipo de datos Tamaño (memoria) Gama especificador de
(palabra clave) formato
Flotador 32 bits (4 bytes) 3.4E-38t03.4E+38 %f
Doble 64 bits (8 bytes) 1,7E-308 a I,7E +308 %lf
doble largo 80 bits (10 bytes) 3,4E-4932 a 1,1E+4932 Lf
B tipo de datos
ooleanos:-
El tipo de datos booleano o lógico es un tipo de datos que tiene dos valores (normalmente denotados como
verdadero y falso), destinado a representar los valores de verdad de la lógica y el álgebra booleana. Debe su
nombre a George Boole, que definió por primera vez un sistema algebraico de lógica a mediados del siglo XIX.
El tipo de datos booleano es el resultado principal de las sentencias condicionales, que permiten diferentes
acciones y cambian el flujo de control dependiendo de si una condición booleana especificada por el programador
se evalúa como verdadera o falsa.
C99 añadió un tipo booleano (verdadero/falso) que se define en la cabecera <stdbool.h> La variable
booleana se define mediante la palabra clave bool; Ej:
bool b;
donde b es una variable que puede almacenar verdadero (1) o falso (0)
Tipo de vacío
El tipo void no tiene valores. Suele utilizarse para especificar el tipo de retorno de las funciones. Tipo de función que se dice
que es void cuando no devuelve ningún valor a la función que la llama. También se utiliza para declarar un puntero de
propósito general llamado puntero void.
Tipos de datos derivados.
Los tipos de datos derivados son Arrays , punteros y referencias son ejemplos de tipos de datos
derivados.
Tipos de datos definidos por el usuario:
Los tipos de datos definidos por el usuario se denominan tipos de datos definidos por el usuario.
Son estructura, unión, clase y enumeración.
Fichas C
IDENTIFICADORES: Los identificadores son los nombres que reciben los distintos elementos del programa,
como variables, funciones y matrices. Son nombres definidos por el usuario que constan de una secuencia de
letras y dígitos.
Reglas para declarar identificadores:
El primer carácter debe ser un alfabeto o un guión bajo.
> Debe constar únicamente de letras, dígitos y guión bajo.
Los identificadores pueden tener cualquier longitud, pero sólo son significativos los 31 primeros caracteres.
> No debe contener espacios en blanco ni en blanco.
No debemos utilizar palabras clave como identificadores.
> Las mayúsculas y las minúsculas son diferentes.
Ejemplo: ab Ab aB AB se tratan de forma diferente
Ejemplos de identificadores válidos:
a, x, n, num, SUM, fact, grand_total, sum_of_digits, sum1
Ejemplos de identificadores no válidos: $amount, ³num', grand-total, suma de dígitos, 4num.

$importe: Carácter especial no permitido
grand-total: no se permite el guión.
suma de dígitos : no se admiten espacios en blanco entre las palabras.
4num : no debe empezar por un número (el primer carácter debe ser una letra o un guión bajo)
Nota: Algunos compiladores de C sólo reconocen los 8 primeros caracteres, por lo que son incapaces de
distinguir identificadores con palabras de longitud superior a ocho caracteres.
Variables:Una posición de memoria con nombre se denomina variable.

O
Es un identificador utilizado para almacenar el valor de un tipo de datos concreto en la memoria.
Dado que el nombre de la variable es un identificador, utilizamos las siguientes reglas, que son las mismas
que las del identificador
Reglas para declarar nombres de
Variables:
> El primer carácter debe ser un alfabeto o un guión bajo.
Debe constar únicamente de letras, dígitos y guión bajo.
> Los identificadores pueden tener cualquier longitud, pero sólo son significativos los 31 primeros caracteres.
No debe contener espacios en blanco ni en blanco.
> No debemos utilizar palabras clave como identificadores.

Las mayúsculas y las minúsculas son diferentes.
Los nombres de las variables deben ser únicos en el ámbito dado
> Ej:int a,b,a;//está en válido
Int a,b;//es válido
Declaración de variables: La declaración de la variable da el nombre para la ubicación de memoria y su

tamaño y el rango de valor que puede almacenarse en esa
especifica
Sintaxis:
ubicación.
Nombre de la variable de
tipo de datos; a 10 2000
Ex:
int a=10; x 2.300000 5000
float x=2.3;
PALABRAS CLAVE :
Hay ciertas palabras, llamadas palabras clave (palabras reservadas) que tienen un significado
predefinido en el lenguaje "C++" . Estas palabras clave sólo deben utilizarse para los fines previstos y no como
identificadores.
La siguiente tabla muestra las palabras clave estándar de "C
auto romper caso char const continuar
por defecto do doble si no enum externo
float para ir a si int largo
regístrese en devolver corto firmado tamaño de estático
struct interruptor typedef unión sin signo void
volátil mientras que clase amigo nuevo borrar
este público privado protegido en línea pruebe
tirar captura plantilla
CONSTANTES:
Las constantes se refieren a valores que no cambian durante la ejecución de un programa.
Las constantes pueden dividirse en dos grandes categorías:
1.Constantes primarias:
a)Constantes numéricas
Constantes enteras.
Punto flotante (real)
b)Constantes de carácter
Constantes de un solo carácter Constantes de cadena
2.Constantes secundarias:
Constantes de enumeración.
Constantes simbólicas.
Matrices, uniones, etc.
Reglas para declarar constantes:
1 No se permiten comas ni espacios en blanco dentro de la constante.
2 La constante puede ir precedida del signo menos (-) si es necesario.
3 El valor de una constante debe estar dentro de los límites mínimos de su tipo de datos especificado.
Constantes enteras: Una constante entera es un número de valor entero. Consiste en una secuencia de dígitos. Las
constantes enteras pueden escribirse en tres sistemas numéricos diferentes:
1 Número entero decimal (base 10).
2 Número entero octal (base 8).
3 Hexadecimal (base 16).
Constante entera decimal: Consta de un conjunto de dígitos, del 0 al 9.
Declaración válida: 0, 124, -56, + 67, 4567 etc.
Declaración no válida: 245 $, 2,34, 34 345, 075.
También es una declaración no válida.
Nota: No se permiten espacios, comas, caracteres ni símbolos especiales entre los dígitos.
Pueden ir precedidos de un signo + o ± opcional.
Número entero octal: Consta de un conjunto de dígitos, de 0 a 7.

Ej: 037, 0, 0765, 05557 etc. (representación válida)
Es una secuencia de dígitos precedidos de 0.
Ej: Representaciones no válidas
0394: la cifra 9 no está permitida (sólo cifras de 0 a 7)
235: no empieza por 0. (El número inicial debe ser 0).
Número entero hexadecimal: Consiste en un conjunto de dígitos del 0 al 9 y los alfabetos A, B, C, D, E y F. Un

entero hexadecimal es una secuencia de dígitos precedidos por 0x o 0X. También podemos utilizar de a a f en
lugar de A a F.
Ej: 0X2, 0x9F, 0Xbcd, 0x0, 0x1. (Representaciones válidas)
Ej: Representaciones no válidas: 0af, 0xb3g, 0Xgh.
0af: no empieza por 0x o 0X.
0xb3g, 0Xgh: caracteres ilegales como g, h. (sólo se permiten de a a f)
La magnitud (valor máximo) de una constante entera puede oscilar entre cero y algún valor máximo que varía de
un ordenador a otro.
Los valores máximos típicos para la mayoría de los ordenadores personales son: (máquinas de 16 bits)
Constante entera decimal: 32767 (215-1)
Constante octal entera: 077777
Constante entera hexadecimal: 0X7FFF
Nota: El valor más grande que se puede almacenar depende de la máquina.
Constantes de coma flotante o constantes reales : Los números con partes fraccionarias se denominan
constantes reales.
Son los números de base 10 que contienen una parte decimal o un exponente (o ambos). Representación: Estos
números pueden representarse en notación decimal o en notación de exponentes (notación científica).
Notación decimal: 1234,56, 75,098, 0,0002, -0,00674 (notaciones válidas)
Exponente o notación científica:
Forma general: Mantisa e exponente
Mantisa: Es un número real expresado en notación decimal o en notación entera.
Exponente: Es un número entero con un signo más (+) o menos (-) opcional.
E o e: La letra que separa la mantisa de la parte decimal.
Ej: (Anotaciones válidas)
3
1.23456E+3(1.23456×10 )
1
7.5098 e+1(7.5098×10 )
-4
2E-4(2×10 )
Estas notaciones exponenciales son útiles para representar números muy grandes o muy grandes.
pequeño. Ej: 0,00000000987 equivale a 9,87e-9
Constantes de caracteres:-
Constantes de un solo carácter: Es el carácter(o cualquier símbolo o dígito) encerrado entre comillas simples.
Ej: "a" "1" "*
Todas las constantes de carácter tienen valores enteros conocidos como valores ASCII
ASCII:- ASCII son las siglas de American Standard Code for Information Interchange. Pronunciado ask-ee, ASCII es un
código para representar caracteres ingleses como números, asignando a cada letra un número del 0 al 255.Los ordenadores
sólo pueden entender números, por lo que un código ASCII es la representación numérica de un carácter como "a" o "@" o
una acción de algún tipo
.A Los códigos SCII representan texto en ordenadores, equipos de comunicaciones y otros dispositivos que utilizan texto. La
mayoría de los sistemas modernos de codificación de caracteres se basan en ASCII, aunque admiten muchos caracteres
adicionales. A continuación se muestra la tabla de caracteres ASCII, que incluye descripciones de los 32 primeros caracteres
no imprimibles.
Constantes de cadena o literales de cadena:
Una constante de cadena es una secuencia de cero o más caracteres entre comillas dobles.
Por ejemplo:
"MRCET" "12345" "*)(&%"
Constantes de secuencias de escape o caracteres de barra invertida
El lenguaje C admite algunos caracteres no imprimibles, así como la barra invertida ( \ ) que se puede expresar
como secuencias de escape. Una secuencia de escape siempre comienza con una barra invertida seguida de uno o
más caracteres especiales.
Por ejemplo, un carácter de nueva línea se representa "\n" o endl
Se utilizan para dar formato a la pantalla de salida, es decir, la secuencia de escape se utiliza en
funciones de salida. A continuación se indican algunas secuencias de escape:
Secuencia de escape Carácter

"a' alerta sonora
"b' espacio trasero
"f formulario feed
"n' nueva línea
"e' pestaña horizontal
pestaña vertical
cotización única
cita doble
«\23 signo de interrogación
"W Barra diagonal inversa
No. Nulo
OPERADORES Y EXPRESIONES
Un operador es un símbolo que representa una operación concreta que puede realizarse con los datos. Un operando es el
objeto sobre el que se realiza una operación.
Combinando los operadores y los operandos formamos una expresión. Una expresión es una secuencia de operandos y
operadores que se reduce a un único valor.
Los operadores C pueden clasificarse en

1. Operadores aritméticos
2. Operadores relacionales
3. Operadores lógicos
4. Operadores de asignación
5. Operadores de incremento o decremento
6. Operador condicional
7. Operadores por bits
8. operador unario
9. Operarios especiales
10. Operadores adicionales en c++
1. OPERADORES ARITMÉTICOS : Todos los operadores aritméticos básicos están presentes en C. operador
Significado
+ añada
- restar
* multiplicar
/ división
% modulo división(resto)
Una operación aritmética en la que sólo intervienen operandos reales (u operandos enteros) se denomina
aritmética real (o aritmética entera). Si una combinación de aritmética y real se denomina aritmética de modo
mixto.
/*Programa en C sobre expresiones aritméticas de números enteros*/
#include<iostraem.h>
void main()
{
int a, b;
cout<"Introduce dos enteros cualesquiera";
cin>>a>>b;
cout<<"a+b"<< a+b;
cout<<"a-b"<< a-b;
cout<<"a*b"<< a*b;
cout<<"a/b"<< a/b;
cout<<"a%b"<< a%b;
}
SALIDA:
a+b=23
a-b=17
a*b=60
a/b=6
a% b=2
2. OPERADORES RELACIONALES : A menudo comparamos dos cantidades y dependiendo de su relación

tomamos ciertas decisiones para esa comparación utilizamos operadores relacionales.
operador Significado
> es inferior a
> es mayor que
> = es menor o igual que
> = es mayor o igual que
== es igual a
!= no es igual a
/* Programa en C sobre operadores relacionales*/
#include<iostream.h>
void main()
{
int a,b;
clrscr();
cout<<"Introduce los valores a, b:";
cin>>a>>b;
cout<<"a>b"<< a>b;
cout<<"a>=b"<< a>=b;
cout<<"a<b"<< a<b;
cout<<"a<=b"<< a<=b;
cout<<"a==b"<< a==b;
cout<<"a!=b"<< a!=b;
}
SALIDA:
Introduzca los valores a, b: 5 9
a>b: 0 //falso
a<b: 1 //verdadero
a>=a: 1 //verdadero
a<=b: 1 //verdadero
a==b: 0 //falso
a!=b: 1 //verdadero
3 .OPERADORES LÓGICOS:
Datos lógicos: Un dato se denomina lógico si transmite la idea de verdadero o falso. En C++ utilizamos el tipo de datos int
para representar datos lógicos. Si el valor del dato es cero, se considera falso. Si es distinto de cero (1 o cualquier número
entero distinto de 0) se considera verdadero. C++ dispone de tres operadores lógicos para combinar valores lógicos y crear
nuevos valores lógicos:
Tablas verdadero-falso de los operadores AND (&&) y X Y X&&Y X/Y

OR (ID ): 0 0 0 0
1 tabla ruth tor operador NO I (!): 0 1 0 1
x 'X
0 1 1 0 0 1
1 0 1 1 I 1
Nota: Este programa funciona con compiladores que soportan el estándar C99.
#include<stdbool.h>
int main()
{
bool a,b;
/*lógico y*/
a=0;b=0;
cout<<" a&&b"<< a&&b<<<endl;
a=0;b=1;
a=1;b=0;
a=1;b=1;
/*lógico o*/
a=0;b=0;
cout<<" a||b"<< a||b<<<endl;
a=0;b=1;
a=1;b=0;
a=1;b=1;
/*lógico no*/
a=0;
a=1;
Devuelve 0;
}
SALIDA: 0&&0=0
0&&1=0
1&&0=0
1&&1=1
0||0=0
0||1=1
1||0=1 1||1=1 !0 =1 !1 =0
4 .OPERADOR DE ASIGNACIÓN:
La expresión de asignación evalúa el operando situado a la derecha del operador (=) y coloca su valor en
la variable situada a la izquierda.
Nota: El operando izquierdo de una expresión de asignación debe ser una única variable.
Existen dos formas de asignación:
-Asignación simple
-Asignación compuesta
Asignación simple :
En las expresiones algebraicas encontramos estas expresiones.
Ej: a=5; a=a+1; a=b+1;
Aquí, el operando de la izquierda debe ser una variable pero no una constante. La variable del lado
izquierdo debe poder recibir un valor de la expresión. Si el operando izquierdo no puede recibir un valor y
le asignamos uno, obtenemos un error de compilación.
Asignación de compuestos:
Una asignación compuesta es una notación abreviada para una asignación simple. Requiere que el
operando izquierdo se repita como parte de la expresión derecha. Sintaxis: operador variable+=valor
Ex:
A+=1; equivale a A=A+1;
Ventajas de utilizar el operador de asignación abreviado:

1. Lo que aparece en el lado izquierdo no tiene por qué repetirse y, por tanto, resulta más fácil de escribir.
2. La declaración es más concisa y fácil de leer.
3. La declaración es más eficaz.
El operador ++ suma uno a su operando mientras que el operador - - resta uno a su operando. Estos operadores son
operadores unarios y adoptan la siguiente forma:
Operador Descripción
Tanto el operador de incremento como el de decremento
pueden preceder o seguir al operando. --a Preincremento
Aumento/Disminución de Postfix :( a++/a--) a++ Post-incremento
En el incremento (decremento) postfijo el valor se -a Pre-decremento
incrementa (decrementa) en uno. Así, el a++ tiene el a- Post-decrement
mismo efecto que
En la siguiente tabla se muestran algunos de los operadores de asignación abreviados más utilizados :
Declaración con operador de asignación simple Declaración con operador abreviado
a-=1
a=a+l
a=a-l a-=l
a=a*l a*=i
a=a/1 a-1
a=a% 1 a%=l
a=a*(n-l) a*=n+1
5.OPERADORES DE INCREMENTO (++) Y DECREMENTO (--):
a=a+1; a--tiene el mismo efecto que a=a-1.
La diferencia entre a++ y a+1 es que si ++ va después del operando, el incremento se produce después de evaluar la
expresión.
El operando de una expresión postfija debe ser una variable.
Ex1:
int a=5;
B=a++; Aquí el valor de B es 5. el valor de a es 6.
Ex2:
int x=4; y=x--; Aquí el valor de y es 4, el valor de x es 3
Prefijo Aumento/Disminución (++a/ --a)
En el incremento (decremento) del prefijo, el efecto se produce antes de que se evalúe la expresión que contiene el operador.
Es la operación inversa a la postfija. ++a tiene el mismo efecto que a=a+1.
--a tiene el mismo efecto que a=a-1.
Ej: int b=4;
A= ++b;
En este caso el valor de b sería 5 y A sería 5.
Los efectos del incremento postfijo y prefijo son los mismos: la variable se incrementa en
1. Pero se comportan de forma diferente cuando se utilizan en expresiones como las mostradas anteriormente. La ejecución
de estos operadores es rápida en comparación con la sentencia de asignación equivalente.
int main()
{
int a=1;
int b=5;
++a;
--b;
cout<<"b="<<b<<endl;
cout<<"a="<<a++<<endl;
cout<<"b="<<b--<<endl;
cout<<"b="<<b<<endl;
Devuelve 0;
}
a=2
b=4
a=2
a=3
b=4
b=3
6 .OPERADOR CONDICIONAL U OPERADOR TERNARIO:
Un operador ternario requiere dos operandos para funcionar

Sintaxis:
void main()
{
int a, b,c;
cout<<"Introduce los valores a y b:";
cin>>a>>b;
c=a>b?a:b;
cout<<"mayor de a y b es"<<c;
}
Introduzca los valores a y
b:1 5
7 . OPERADORES A NIVEL DE BIT : C soporta operadores especiales conocidos como operadores de bits
para la manipulación de datos a nivel de bits. No se aplican a float ni a double.
operador Significado
& Y bit a bit
^ Exclusivo bit a bit O

<< desplazamiento a la izquierda
>> desplazamiento a la derecha
~ complemento personal
Operador AND (&)
El operador bitwise AND es un operador binario que requiere dos operandos integrales (carácter o entero). Realiza una
comparación bit a bit como se muestra a continuación:
Bit del primer operando Bit del segundo Opel y Opel
0 operando
0 0
0 1 0
1 0 0
1 1 1
Operador bit a bit OR ( |)

El operador bitwise OR es un operador binario que requiere dos operandos integrales (carácter o entero).
Realiza una comparación bit a bit como se muestra a continuación:
Bit del primer operando Bit del segundo operando Opel | Opel
0 0 0
0 1 1
1 0 1
1 1 1
Operador bit a bit OR EXCLUSIVO ( A )

El operador OR EXCLUSIVO bit a bit es un operador binario que requiere dos operandos integrales (carácter
o entero). Realiza una comparación bit a bit como se muestra a continuación:
Bit del primer operando Bit del segundo operando Opel A Opel
0 0 0
0 1 1
1 0 1
1 1 0
Operadores de turno
Los operadores de desplazamiento mueven los bits a la derecha o a la izquierda. Son de dos tipos: . -Operador de
desplazamiento de bits a la derecha
. -Operador de desplazamiento bit a bit a la izquierda
Operador bitwise de desplazamiento a la derecha
Es un operador binario que requiere dos operandos integrales. El primer operando es el valor a desplazar y el segundo
especifica el número de bits a desplazar. Cuando los bits se desplazan a la derecha, se eliminan los bits del extremo
derecho y se inserta un cero en el bit MSB.
void main()
{
int x,shift;
cout<<"Introduce un número:");
cin>>x;
cout<<"introduce ahora muchas veces para desplazar a la derecha: ";
cin>>desplazamiento;
cout<<"Antes del desplazamiento a la derecha:"<<x;
x=x>>desplazamiento;
cout<<"Después del desplazamiento a la derecha:"<<x;
}
Corre1:
Introduzca un número:8
introducir ahora muchas veces a la derecha shift:1
Antes del cambio a la derecha:8
Después del cambio a la derecha:4
Explicación: El número introducido a través del teclado como entrada es 8 y su correspondiente

número binario es 1000.
0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
15 14 13 12 11 10 9 876543 21 0
Tras la ejecución del programa, los datos de entrada x se desplazan 2 bits a la derecha. La respuesta en forma
binaria sería la siguiente:
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
15 14 13 12 11 10 9 876543 21 0
El operador de desplazamiento a la derecha divide el número dado por una potencia de 2. Si desplazamos un
número binario dos posiciones hacia la derecha, estamos dividiendo el número dado por 4 (2').
Operador bitwise de desplazamiento a la izquierda
Es un operador binario que requiere dos operandos integrales. El primer operando es el valor a desplazar y
el segundo especifica el número de bits a desplazar a la izquierda.
Cuando los bits se desplazan hacia la izquierda, se borran los bits del extremo izquierdo.
Ej: int a=2;

a"=3;
Shift left es el operador opuesto a shift right. El operador de desplazamiento a la izquierda multiplica el
número dado por una potencia de 2. Si desplazamos un número binario tres posiciones a la izquierda,
estamos multiplicando el número dado por 8 (23).
Complemento a uno o Bitwise NOT
El NOT o complemento a nivel de bit es una operación unaria que realiza la negación lógica de cada bit.
formando el complemento a unos del valor binario dado. Las cifras que eran 0 se convierten en I, y viceversa.
Ex: NOT 0111 (decimal 7) = 1000 (decimal 8)
En C, el operador bitwise NOT es (tilde). Tabla de verdad:
Valor de expresión ~ Expression
0 1
1 (distinto de cero) 0
Nota: El operador de complemento a uno (Bitwise NOT) es diferente del operador Logical NOT. Utilizamos
este operador en los procesos de codificación y descodificación.
8.5 OPERADORES ESPECIALES
Estos operadores que no encajan en ninguna de las clasificaciones anteriores son ,(coma), sizeof, operadores de
puntero(& y *) y operadores de selección de miembros (. y ->). El operador coma se utiliza para unir expresiones
relacionadas.
El tamaño del operador:
Devuelve el número de bytes ocupados por el operando. El operando puede ser una variable, una constante
(valor de datos) o un calificador de tipo de datos.
Ej: int a. c, f, d;
c=sizeof(a); aquí c=2,el operador sizeof devuelve el tamaño de la variable a que es de tipo int f=sizeof(long
double); el valor de f es 10 que es el tamaño del calificador de tipo long double d=sizeof(23.345); el valor de d
es 4 que es el tamaño del valor de la constante float
El operador sizeof se utiliza normalmente para determinar la longitud de matrices y estructuras. También se
utiliza para asignar espacio dinámicamente a la variable s durante la ejecución de un programa.
El operador coma (,)
El operador coma se puede utilizar para vincular el expreso relacionado de expresiones se evalúa de izquierda
a derecha y el valor de la de la expresión combinada.
Ej: a=(x=10, y=20, x+y);
Primero asigna el valor 10 a x, luego asigna 20 a y y fina

Tiene la precedencia más baja entre todos los operadores.
Utilizamos el operador coma en las sentencias de bucle y declarativas del mismo tipo.
Operador Descripción
4- Unario más
9.OPERADOR UNARIO: el operador que opera - Unario menos
sobre un único operando se denomina operador unario — Incremento
— Disminución
& Dirección
— Un complemento
Tamaño de Tamaño del operador
Tipo Fundición de tipo
Operadores en c++: Todos los operadores anteriores del lenguaje c también son válidos en c++.Los nuevos
operadores introducidos en c++ son
Sno Operador Símbolo

1. Operador de resolución de alcance
2. Puntero a un declarador de miembro ::*
3. Puntero al operador miembro ->*,->
4. Puntero al operador miembro .*
5. nuevo Operador de asignación de memoria
6. borrar Operador de liberación de memoria
7. endl Operador de alimentación de línea
8. setw Operador de anchura de campo
9. inserción <<
10. Extracción >>
8.6 cope Operador de resolución:

Ámbito:-La visibilidado disponibilidad de una variable en un programa se denomina ámbito. Existen dos tipos
de ámbito. i)Ámbito local ii)Ámbito global
Ámbito local: la visibilidad de una variable es local a la función en la que se declara.
Ámbito global: visibilidad de una variable para todas las funciones de
un programa Operador de resolución de ámbito en "::" .
Se utiliza para acceder a variables globales si las mismas variables se declaran como locales
y PROGRAMA global1.2:-
int a=5;
void main()
{
int a=10;
cout<<"Local a="<<a<<endl;
cout<<"Global a="<<::a<<<endl;
}
Resultado esperado:
Local a=10
Global a=5
Operador de desreferenciación de miembros:-
2. Puntero al operador miembro ->*,->
Puntero a un declarador de miembro ::*
Este operador se utiliza para declarar un puntero al miembro de la clase #include<iostream.h>
muestra de clase
{público:
int x;
};
int main()
{ muestra s; //objeto
int muestra ::*p;//declaración de puntero s.*p=10;//correcto
cout<<s.*p;
} Salida:10
2.Puntero a operador miembro ->*
#include<iostream.h> class sample
{
público:
int x;
void display()
{
cout<<"x="<<x<<endl;
}
};
int main()
{
muestra s; //objeto
muestra *ptr;
int muestra::*f=&muestra::x;
s.x=10;
ptr=&s;
cout<<ptr->*f;
ptr->display();
}
3. Puntero a operador miembro .*

muestra de clase
{
public: int x;
};
int main()
{
muestra s; //objeto
int muestra ::*p;//declaración de punteros
s.*p=10; //correcto
cout<<s.*p;
}
Manipuladores:
Los manipuladores son los operadores utilizados para dar formato a los datos que se van a mostrar en
pantalla.Los manipuladores más utilizados son endl y setw
endl:-se utiliza en la sentencia de salida e inserta un salto de línea. Es similar al carácter de nueva línea ("\
n")
ej: cout<<"a=2"<<endl;
cout<"nombre=sunil"<<endl;
Salida:
a=2
name=sunil
setw:-
este manipulador permite especificar la anchura de un campo que se va a imprimir en pantalla
Esta función está disponible en el fichero de cabecera iomanip.h
#include<iomanip.h>
int main()
{
int s=123;
cout<<"s="<<setw(10)<<s ;
}
salida
s= 123
Operadores de inserción (<<) y extracción (>>):
los operadores se utilizan con objetos de salida y de entrada
ex:
cout<<"Introduce n";
cin>>n
Sentencias de control:-El flujo de ejecución de las sentencias de un programa se denomina control. La

sentencia de control es una sentencia que controla el flujo de ejecución del programa. Las declaraciones de
control se clasifican en las siguientes categorías.
1.Declaraciones de control secuencial
2.Sentencias de control condicional
(tipo) expresión;
3.Declaraciones de control incondicional O
1.Secuencial control declaraciones:- tipo (expresión); Instrucciones de control
declaraciones garantiza que el secuencial(o
) se ejecutan en el mismo orden en que
aparecen en el programa, es decir, Por por defecto sistema
ejecuta las sentencias en el orden del en secuencial
programa.
2.Sentencias de control condicional :Sentencias que se ejecutan cuando una condición es verdadera. Estas
declaraciones se dividen en tres categorías, a saber
1.Declaraciones para la toma de decisiones
2.Cambiar la declaración de control de casos o
3.Sentencias de control de bucle o repeticiones
1 Sentencias de toma de decisiones:- Estas sentencias se utilizan para controlar el flujo de ejecución de un
programa tomando una decisión en función de una condición, de ahí que se denominen sentencias de toma de
decisiones.
Las declaraciones para la toma de decisiones son de cuatro tipos
1.Simple si
2.si no
3.nested if else
4.1 f si no escalera
1.51 Ejemplo de sentencia if: si la expresión de prueba es verdadera, la sentencia if ejecuta las sentencias que
siguen inmediatamente a if
Sintaxis:
If(expresión de prueba)
Lista de declaraciones;
/*mayor de dos números*/

#include<stdio.h>
int main()
{
int a,b;
cout<<"Introduce dos enteros cualesquiera:";
cin>>a>>b;
si(a>b)
cout<<"A es mayor que B\n A="<<a;
si(b>a)
cout<<"B es mayor que A\n A="<<b;
Devuelve 0;
}
2 . sentencia if -else:
Si la expresión de prueba es verdadera, se ejecuta el bloque de sentencias que sigue a if y si la expresión
de prueba es falsa, se ejecutan las sentencias del bloque else if (expresión de prueba)
{
declaración bloque1;
}
si no
{
declaración bloque2;
}
/*mayor de dos números*/
int main()
{
int a,b;
cout<<"Introduce dos enteros cualesquiera:";
cin>>a>>b;
if(a>b) cout<<"A es mayor que B\n A="<<a;
cout<<"B es mayor que A\n A="<<b;

si
no Devuelve 0;
3 Anidamiento de sentencias if-elseTambién esposible anidar una sentencia if dentro de otra. cuandohay que tomar una serie de
decisiones.
Sentencia if -else colocada dentro de otra sentencia if else Sintaxis:
If(expresión de prueba ) {If(expresión
de prueba) { //declaraciones } else
{ //declaraciones } } else
{If(expresión de prueba) {
//declaraciones } else {
//declaraciones }
} /*mayor de tres números*/
#include<conio.h> int main() { int a,b,c;
cout<<"Introduce los valores a,b,c:";
cin>>a>>b>>c;
if(a>b) {
if(a>c) {
cout<<"A ia
mayor entre
tres números\
n"; cout
"A="<<a;
} else {
cout<<"C ia
mayor entre
tres números\n"; cout<<"c="<<c;
} } else {if(b>c) {
cout<<"B ia mayor entre tres números\n"; cout<<"B="<<b;
}
si no
{
cout<<"C ia mayor entre tres números\n";
cout<<"c="<<c;
}
}
getch();
Devuelve 0;
}
4.1 f si no escalera
si(condición1)
declaración1;
else if(condición2)
enunciado 2;
else if(condición3)
declaración n;
si no
declaración por defecto.
declaración-x;
El anidamiento de if-else depende de las condiciones con las que tengamos que tratar.
La condición se evalúa de arriba a abajo.Si una condición es verdadera se ejecuta la sentencia asociada a ella.
Cuando todas las condiciones sean falsas, se ejecutará la parte final else que contiene las sentencias por defecto.
void main()
{
int per;
cout<<"Introducir
porcentaje"; cin>>per;
si(per>=80)
cout<<"Asegurado
Distinción"<<endl; else if(per>=60)
cout<<"Asegurado Primero
División"<<endl; else if(per>=50)
cout<<"Asegurado
Segunda División"<<endl;
else if(per>=40)
cout<<"Asegurado
División"<<endl; Terce
si no ra
cout<<"Fallo"<<endl
EL ESTADO DEL INTERRUPTOR o la SELECCIÓN DE VARIAS VÍAS:

Además de la selección bidireccional, la mayoría de los lenguajes de programación proporcionan otro concepto de
selección conocido como selección multidireccional. La selección multidireccional elige entre varias alternativas. C tiene
dos formas diferentes de implementar la selección multidireccional: la sentencia switch y la construcción else-if
Si suponemos que tenemos más de una opción válida entre las que elegir, podemos utilizar la sentencia
switch en lugar de las sentencias if.
switch(expresión)
{.
caso valor-1:
bloque-1
romper;
caso valor-2:
bloque-2
romper;
por defecto:
bloque por defecto;
/*programa para simular una calculadora simple */ #include<iostream.h>

int main()
{
float a,b;
char opr;
cout<<"Introducir número1 operador número2 : ";

cin>>a>>oper>>b;
switch(opr)
{
caso '+':
cout<<"Suma :"<<(a + b)<<endl;
romper;
caso '-': cout<<"Diferencia :"<<(a -b)<<endl;
romper;
case '*': cout<<"Producto :"<<a * b<<<endl;
romper;
case '/': cout<<"Cociente :"<<(a / b)<<endl;
romper;
por defecto: cout<<"¡Operación no válida!"<<endl;
}
Devuelve 0;
}
Sentencias de control de bucle o repeticiones:

Un bloque o grupo de sentencias ejecutadas repetidamente hasta que se satisface alguna condición se
denomina Bucle. El grupo de sentencias encerradas entre llaves se denomina bloque o sentencia compuesta.
Tenemos dos tipos de estructuras de bucle.
Uno en el que la condición se comprueba antes de entrar en el bloque de sentencia llamado control de entrada.
El otro, en el que la condición se comprueba a la salida, se denomina bucle controlado a la salida.
Las sentencias de bucle pueden dividirse en las tres categorías siguientes
1 .declaración de bucle while
2 .do declaración de bucle while
3 .declaración de bucle for
1 .SENTENCIA WHILE :
While(condición de prueba)
{
cuerpo del bucle
}
Se trata de un bucle controlado por entrada. La condición se evalúa
y si es verdadera entonces se ejecuta el cuerpo del bucle. Después de la
ejecución del cuerpo la condición se evalúa una vez más y si es verdadera el
cuerpo se ejecuta una vez más. Esto continúa hasta que la condición de
prueba se convierte en falsa.
c programa para hallar la suma de n números naturales */

int main()
{
int i = 1,suma = 0,n;
cout<<"Introduce N"<<end;
cin>>n;
while(i<=n)
{
suma = suma + i;
i = i + 1;
}
cout<<"La suma de los primeros"<<n<"números naturales es:"<<suma<<<endl; return 0;

}
2 .DO DECLARACIÓN WHILE :
tlo-mientras - ( Salida controlada )

El bucle while no permite que se ejecute el cuerpo si la condición de prueba es falsa. El do while es un
bucle de salida controlada y su cuerpo se ejecuta al menos una vez.
do
{
cuerpo
}while(condición de prueba);
/*c programa para hallar la suma de n números naturales */

#include<stdio.h>
int main()
{
int i = 1,suma = 0,n;
cout<<"Introduce N"<<endl;
cin>>n
do{
suma = suma + i;
i = i + 1;
} while(i<=n);
cout<<"Suma de los primeros"<< n<<" números naturales.
es:"<<suma; return 0;
}
Nota: si la condición de prueba es falsa antes de que se ejecute el bucle, el bucle While se ejecutará cero veces, mientras
que el bucle do--while se ejecutará una vez.
3.FOR LOOP : También es un bucle de control de entrada que proporciona una estructura
más concisa
Sintaxis:
for(inicialización; expresión de prueba; incremento/decremento) {
declaraciones;
}
El enunciado For se divide en tres expresiones, cada una de
ellas separada por dos puntos y coma;
1.la expresión de inicialización se utiliza para inicializar
variables
2.expresión de prueba es responsable de continuar el bucle.
Si es verdadera, el flujo de control del programa entra en el
bucle y ejecuta el bloque de sentencias asociado a él. Si la
expresión de prueba es falsa, el bucle termina. 3. La
expresión de incremento/decremento consiste en un operador
de incremento o decremento. Este proceso continúa hasta que
se satisface la condición de prueba.

#include<stdio.h>
int main()
{
int i ,suma = 0,n;
cout<<"Introduce N";
cin>>n;
for(i=1;i<=n;i++)
{
suma = suma + i;
}
cout<<"La suma de los primeros"<<n<<" números naturales es:%d"<<suma; return 0;
Bucles anidados:Escribir una sentencia de control de bucle dentro de otra sentencia de control de bucle se
denomina sentencia de bucle anidado
Ex:
for(i=1;i<=10;i++)
for(j=1;j<=10;j++) cout<<i<<j;
/*programa para imprimir números primos hasta un número dado*/

#include<stdio.h>
#include<conio.h>
void main()
{
int n,i,fact,j;
clrscr();
cout<<"introduce el número:";
cin>>n
for(i=1;i<=n;i++)
{hecho=0;
//ESTE BUCLE COMPROBARÁ QUE UN NO ES UN NO PRIMO. O
NOT. for(j=1;j<=i;j++)
{
if(i%j==0) fact++;
}
if(hecho==2)
cout<<i<<"\t";
}
getch( );
}
Salida:
Introduzca el número : 5
2 35
Declaraciones de control incondicional:

Declaraciones que transfieren el control de una parte del programa a otra.
incondicionalmente Las diferentes afirmaciones incondicionales son
1)goto
2)romper
3)continuar
1.goto :- La sentencia goto se utiliza para la ramificación incondicional o la transferencia de la ejecución
del programa a la sentencia etiquetada.
La sentencia goto para bifurcarse incondicionalmente de un punto a otro del programa. El goto requiere una
etiqueta para identificar el lugar en el que se va a realizar la sucursal. Una etiqueta es cualquier nombre de
variable válido, y debe ir seguida de dos puntos (;). La etiqueta se coloca inmediatamente
antes de la sentencia a la que se va a transferir el control. La forma general de goto es la siguiente
abajo:
Ir a la etiqueta:
etiqueta; declaración;
etiqueta:
declaració Ir a la
n; etiqueta;
Salto hacia delante Salto hacia atrás
La etiqueta: puede estar en cualquier parte del programa, ya sea antes o después de la etiqueta goto;
declaración.
Si la etiqueta: se coloca después de la etiqueta goto;, algunas sentencias se saltarán y el salto se conoce como
Salto hacia adelante.
Si la etiqueta: se coloca antes de la etiqueta goto; se formará un bucle algunas sentencias se ejecutarán
repetidamente. Un salto de este tipo se conoce como salto hacia atrás.

#include<stdio.h>
int main()
{
int i ,suma = 0,n;
cin>>n;
i=1;
L1:
suma = suma + i;
i++;
if(i<=n) goto L1;
cout<<"La suma de los primeros "<<n<" números naturales es"<<suma; return 0;

break:-cuandose encuentra una sentencia break dentro de un bucle, se sale
inmediatamente del bucle y el programa continúa con las sentencias que siguen
inmediatamente al bucle.
#include<stdio.h>
int main()
{
int i ,suma = 0,n;
cin>>n;
i=1;
L1:
suma = suma + i;
i++;
if(i>n) break;
ir a L1;
cout<<"La suma de los primeros"<<n<<"números naturales es: "<<suma; return 0;

}
Continue:Se utiliza para continuar la iteración de la sentencia del bucle saltándose las
sentencias posteriores a la sentencia continue. Hace que el control pase directamente a la
condición de prueba y luego continúe el bucle.
/*c programa para hallar la suma de n números positivos leídos del teclado*/
#include<stdio.h>
int main()
{
int i ,suma = 0,n,número;
cout<<Introduzca N";
cin>>n;
for(i=1;i<=n;i++)
{
cout<<"Introduce un número:";
cin>>número;
if(number<0) continuar;
suma = suma + número;
}
cout<<"La suma de"<<n<<" números es:"<<suma;
Devuelve 0;
}
UNIDAD -2
Funciones, clases y objetos:

Introducción de Clases, Definición de Clases, Definición de Miembros, Objetos, Control de Acceso,
Ámbito de Clase, Operador de Resolución de Ámbito, Funciones Inline, Asignación de Memoria para
Objetos, Miembros de Datos Estáticos, Funciones de Miembros Estáticos, Arrays de Objetos, Objetos como
Argumentos de Función, Funciones Amigas.
Presentación de la clase:
La programación orientada a objetos es una colección de objetos y cada objeto consta de las
correspondientes estructuras de datos y procedimientos. El programa es reutilizable y más fácil de mantener.
El aspecto importante en oop es una clase que tiene una sintaxis similar a la de estructura.
clase: Es una colección de datos y funciones miembro que manipulan datos. Los componentes de datos de la
clase se denominan miembros de datos y las funciones que manipulan los datos se denominan funciones
miembro.
También se le puede llamar blue print o prototipo que define las variables y funciones comunes a todos
los objetos de cierto tipo. También se conoce como tipo de datos definido por el usuario o ADT (tipo de datos
abstracto) Una clase se declara mediante la palabra clave class.
Sintaxis:-
clase nombre_clase {
Especificador de acceso :
Declaraciones de variables;
Especificador de acceso :
declaraciones de funciones;
};
Control de acceso:
Los especificadores de acceso o modificadores de acceso son las etiquetas que especifican el tipo de
acceso dado a los miembros de una clase. Se utilizan para ocultar datos. También se denominan modos de
visibilidad. Existen tres tipos de especificadores de acceso
1.privado
2.público
3.protegido
1.Privado:
Si los miembros de datos se declaran como de acceso privado, entonces no se puede acceder a ellos
desde otras funciones fuera de la clase. Sólo se puede acceder a ella mediante las funciones declaradas dentro de
la clase. Se declara mediante la palabra clave "private" .
2.público:
Si los miembros de datos se declaran de acceso público, entonces se puede acceder a ellos desde otras
funciones fuera de la clase. Se declara mediante la palabra clave "public" .
3.protected: El nivel de acceso de la declaración protegida se sitúa entre público y privado. Este especificador
de acceso se utiliza en el momento de la herencia
Nota:-
Si no se especifica ningún especificador de acceso, se trata por defecto como privado
El especificador de acceso por defecto de una estructura es "public", mientras que el de una clase es "private".
Ejemplo:
alumno de clase
{
privado : int roll;
char nombre[30];
público:
void obtener_datos()
{
cout<<"Introducir número de rollo y nombre": cin>>rollo>>nombre;
}
void poner_datos()
{
cout<<"Número de rollo:"<<rollo<<<endl;
cout<<"Nombre :"<<nombre<<endl;
}
};
Objeto:-La instancia de una clase se denomina objeto.
Sintaxis:
nombre_clase nombre_objeto;
Ex:
estudiante s;
Acceso a los miembros: el operador -dot se utiliza para acceder a los miembros de la clase
Nombre-objeto.nombre-función(argumentos reales);
Ex:
s.get_data();
s.put_data();
Nota:
1 Si no se especifica el especificador de acceso en la clase, el especificador de acceso por defecto es
private
2 Todas las funciones miembro deben ser declaradas como públicas, si no, no son accesibles fuera de
la clase. Objeto:
La instancia de una clase se denomina objeto.
Sintaxis:
Nombre_clase nombre_objeto;
Por ejemplo:
estudiante s;
en el ejemplo anterior s es el objeto. Es una entidad en tiempo real que puede utilizarse
Escribir un programa para leer los datos de un alumno
#include<iostream>
alumno de clase
{
privado:
int roll;
char nombre[20];
público:
void getdata()
{cout<<"Introduzca el número de rollo:";
cin>>roll;
cout<<"Introduce el nombre:";
cin>>nombre;
}
void putdata()
{cout<<"Rollo no:"<<rollo<<<endl;
cout<<Nombre:"<<nombre<<endl;
}
};
int main()
{
estudiante s;
s.getdata();
s.putdata();
returm 0;
}
Ámbito Resolución operador:
Ámbito:-La visibilidado disponibilidad de una variable en un programa se denomina ámbito.
Existen dos tipos de ámbito. i)Ámbito local ii)Ámbito global
Ámbito local: la visibilidad de una variable es local a la función en la que se declara.
Ámbito global: visibilidad de una variable para todas las funciones de un programa.
Operador de resolución de alcance en "::" .
Se utiliza para acceder a variables globales si se declaran las mismas variables como locales y
globales
int a=5;
void main()
{
int a=1;
cout<<"Local a="<<a<<endl;
cout<<"Global a="<<::a<<<endl;
}
Ámbito de la clase:
El operador de resolución de ámbito(::) se utiliza para definir una función fuera de una clase.
#include <iostream>
muestra de clase
{
público:
void output(); //declaración de función
};
// definición de la función fuera del
class void muestra::salida() {
cout << "Función definida fuera de la clase.\n";
};
int main() {
muestra obj;
obj.output();
Devuelve 0;
}
Salida del programa:
Función definida fuera de la clase.
Escribe un programa para encontrar el área de un rectángulo

clase rectángulo
{
int L,B;
público:
void get_data();
void area();
};
void rectángulo::obtener_datos()
{
cout<<"Introduce la longitud del rectángulo";
cin>>L;
cout<<"Introduce la anchura del rectángulo";
cin>>B;
}
int rectángulo::área()
{
devuelve L*B;
}
int main()
{
rectángulo r;
r.get_data();
cout<<"El área del rectángulo es"<<r.area();
Devuelve 0;
}
FUNCIONES EN LÍNEA:
Definición:
Una función inline es una función que se expande en línea cuando es invocada. La expansión en línea
hace que un programa se ejecute más rápido porque se elimina la sobrecarga de una llamada y retorno
de función. Se define utilizando la palabra clave " inline".
Necesidad de función en línea:

> - ,, , Uno de los objetivos de utilizar funciones en un programa es ahorrar algo de espacio de memoria, lo que se hace apreciable
cuando es probable que se llame a una función muchas veces.
Cada vez que se llama a una función, se tarda mucho tiempo extra en ejecutar una serie de instrucciones para
tareas como saltar a la función, guardar registros, introducir argumentos en la pila y volver a la función de
llamada.
>
Cuando una función es pequeña, un porcentaje sustancial del tiempo de ejecución puede dedicarse a esos gastos
generales.
Una solución a este problema es utilizar definiciones de macro conocidas como macros. Las macros del
preprocesador son populares en C. El mayor inconveniente de las macros es que no son realmente
funciones y , por lo tanto, no se produce la comprobación de errores habitual durante la compilación.
C++ tiene una solución diferente para este problema. Para eliminar el coste de las llamadas a funciones
pequeñas, C++ propone una nueva característica denominada función en línea.
Formulario general:
inline function-header
{
cuerpo de la función;
Ej:
inline float mul(float x, float y)
{
devolver (x*y);
}
inline doble div(doble p, doble q)
{
devolución (p/q);
}
int main()
{
float a=12,345;
float b=9,82;
cout<<mul(a,b);
cout<<div(a,b);
Devuelve 0;
}
Propiedades de la función inline:
1.La función Inline envía una petición pero no una orden al compilador
2.Compiler mi servir o ignorar la solicitud
3.si la función tiene demasiadas líneas de código o si tiene una lógica complicada, se ejecuta como una
función normal.
Situaciones en las que inline no funciona:
>
Una función que devuelve un valor, si contiene un bucle de conmutación o ambos, entonces se trata como una función
normal.
>
si una función no devuelve ningún valor y contiene una sentencia return, se trata como una función normal
>
Si la función contiene variables estáticas, se ejecuta como una función normal.
>
Si la función en línea se declara como función recursiva, se ejecuta como una función normal.
Asignación de memoria para objetos: La memoria de los objetos se asigna cuando se declaran, pero no
cuando se define la clase. Todos los objetos de una clase determinada utilizan las mismas funciones miembro.
Las funciones miembro se crean y se colocan en memoria una sola vez cuando se definen en la definición de la
clase
MIEMBROS ESTÁTICOS DE LA CLASE
Miembros de datos estáticos

Funciones estáticas
Miembros de datos estáticos:
Un miembro de datos de una clase puede calificarse como estático. Una variable miembro estática tiene
ciertas características especiales:
Se inicializa a cero cuando se crea el primer objeto de su clase. No se permite ninguna otra inicialización.
Sólo se crea una copia de ese miembro para toda la clase y es compartida por todos los objetos de esa clase,
independientemente del número de objetos que se creen.
Sólo es visible dentro de la clase, pero su tiempo de vida es todo el programa.
Los datos estáticos se definen con la palabra clave "static".
Sintaxis:
Nombre de la clase de tipo de datos::static_variable Nombre;
Ej: int item::count;
#include<conio.h>
elemento de clase
{
static int count;
número int;
público:
void getdata(int a) {
number=a; count++;
}
void getcount()
{
cout<<"cuenta es"<<cuenta;
}
};
int item::count;//decleración
int main()
{
punto a,b,c;
a.getcount();
b.getcount();
c.getcount();
a.getdata(100);
b.getdata(200);
c.getdata(300);
cout<<"Después de leer los datos";
a.getcount();
b.getcount();
c.getcount();
Devuelve 0;
}
Salida:
el recuento es 0
el recuento es 0
el recuento es 0
Después de leer los datos
la cuenta es 3
la cuenta es 3
la cuenta es 3
Funciones estáticas
Al igual que las variables miembro estáticas, también podemos tener funciones miembro estáticas. Una
función miembro declarada estática tiene las siguientes propiedades:
Una función estática sólo puede tener acceso a otros miembros estáticos (funciones o variables)
declarados en la misma clase.
Una función miembro estática debe llamarse utilizando el nombre de la clase (en lugar de sus objetos)
de la siguiente forma: nombre-clase :: nombre-función;
prueba de clase
{
código int;
static int count;
público:
void setcode()
{
code=++cuenta;
}
void showcode()
{
cout<<"número de objeto"<<código;
}
static void showcount()
{
cout<<"cuenta"<<cuenta;
}
};
int prueba::cuenta;
int main()
{
prueba t1,t2;
t1.setcode();
t2.setcode();
test::showcount();
prueba t3;
t3.setcode();
test::showcount();
t1.showcode();
t2.showcode();
t3.showcode();
Devuelve 0;
}
Salida:
recuento 2
recuento 3
objeto número 1
objeto número 2
objeto número 3
Matrices de objetos: Las matrices de variables de tipo "clase" se conocen como "Matriz de objetos". Un array
de objetos se almacena dentro de la memoria de la misma forma que un array ordinario.
Sintaxis:
clase nombre_clase
{
privado:
miembros de data_type;
público:
miembros data_type; funciones miembro;
};
Matriz de objetos:
Nombre_clase nombre_objeto[tamaño];
Donde tamaño es el tamaño de la matriz
Ex:
Myclass obj[10];
Escribe un programa para inicializar un array de objetos e imprimirlos
#include<iostream>
clase MyClass
{
int a;
público:
void set(int x)
{
a=x;
}
int obtener()
{
devolver a;
}
};
int main()
{
MyClass obj[5];
for(int i=0;i<5;i++)
obj[i].set(i);
for(int i=0;i<5;i++)
cout<<"obj["<<i<<"].get():"<<obj[i].get()<<endl;
}
Salida:
obj[0].get():0
obj[1].get():1
obj[2].get():2
obj[3].get():3
obj[4].get():4
Objetos como argumentos de funciones: Los objetos pueden utilizarse como argumentos de
funciones Esto puede hacerse de tres maneras
a. Pasar por valor o llamar por valor
b. Pasar por dirección o llamar por dirección
c. Pasar por referencia o llamar por referencia
a.Pass-by-value - Una copia del objeto (objeto real) se envía a la función y se asigna al objeto de la función
llamada (objeto formal). Tanto las copias reales como las formales de los objetos se almacenan en distintas
posiciones de memoria. Por lo tanto, los cambios realizados en el objeto formal no se reflejan en el objeto real.
escriba un programa para intercambiar los valores de dos objetos
escribir un programa para intercambiar los valores de dos objetos
clase muestra2;
clase muestra1
{
int a;
público:
void getdata(int x);
friend void display(muestra1 x,muestra2 y);
friend void swap(muestra1 x,muestra2 y);
};
void muestra1::getdata(int x)
{
a=x;
}
clase muestra2
{
int b;
público:
friend void swap(muestra1 x,muestra2 y);

};
{
b=x;
}
void display(muestra1 x,muestra2 y)
{
cout<<"Los datos del objeto 1 son"<<endl;
cout<<"a="<<x.a<<<endl;
cout<<"b="<<y.b<<<endl;
}
void swap(muestra1 x,muestra2 y)
{
int t;
t=x.a;
x.a=y.b;
y.b=t;
}
int main()
{
muestra1 obj1;
muestra2 obj2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Antes del intercambio de datos entre dos objetos\n
"; display(obj1,obj2);
swap(obj1,obj2);
cout<<"tras Intercambio de datos entre Dos objetos\n ";
display(obj1,obj2);
}
Antes del intercambio de datos entre dos objetos
Los datos del objeto 1 son a=5
Los datos del objeto 2 son b=15
tras el intercambio de datos entre dos objetos
b. Paso por dirección: La dirección del objeto se envía como argumento a la función.
Aquí se utiliza ampersand(&) como operador de dirección y arrow (->) como operador de referenciación. Si se
realiza algún cambio en los argumentos formales entonces hay un cambio en los argumentos reales escribe un
programa para intercambiar los valores de dos objetos
clase muestra2;
clase muestra1
{
int a;
público:
friend void swap(muestra1 *x,muestra2 *y);
};
{
a=x;
}
clase muestra2
{
int b;
público:
friend void swap(muestra1 *x,muestra2 *y);
};
{
b=x;
}
{
}
void swap(muestra1 *x,muestra2 *y)
{
int t;
t=x->a;
x->a=y->b;
y->b=t;
}
int main()
{
muestra1 obj1;
muestra2 obj2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Antes de Intercambiar datos entre Dos objetos\n ";
display(obj1,obj2);
swap(&obj1,&obj2);
display(obj1,obj2);
}
Los datos del objeto 2 son b=5 c.Pass-by-reference:Se envía una referencia de objeto como argumento a la
función.
La referencia a una variable proporciona un nombre alternativo para una variable previamente definida. Si se
realiza algún cambio en la variable de referencia, se produce un cambio en la variable original.
Una variable de referencia puede declararse del siguiente modo
Tipo de datos y variable de referencia =variable;
int x=5;
int &y=x;
Ex:
Escribe un programa para encontrar la suma de n números naturales usando la variable de referencia
int main()
{
int i=0;
int &j=i;
int s=0;
int n;
cout<<"Introduce n:";
cin>>n;
while(j<=n)
{
s=s+i;
i++;
}
cout<<"suma="<<s<<endl;
}
Salida:
Introduzca n:10
suma=55
escribe un programa para intercambiar los valores de dos objetos
clase muestra2;
clase muestra1
{
int a;
público:
friend void swap(muestra1 &x,muestra2 &y);
};
{
a=x;
}
clase muestra2
{
int b;
público:
friend void swap(muestra1 &x,muestra2 &y);
};
{
b=x;
}
{
}
void swap(muestra1 &x,muestra2 &y)
{
int t;
t=x.a;
x.a=y.b;
y.b=t;
}
int main()
{
muestra1 obj1;
muestra2 obj2;
obj1.getdata(5);
obj2.getdata(15);
cout<<"Antes de Intercambiar datos entre Dos objetos\n ";
display(obj1,obj2);
swap(obj1,obj2);
display(obj1,obj2);
}
Salida:
FUNCIONES AMIGAS:Los miembros privados no pueden ser accedidos desde fuera de la clase. i.e....
una función no miembro no puede tener acceso a los datos privados de una clase. En C++ una función no
miembro puede acceder a private haciendo que la función sea amiga de una clase.
Definición:
Una función amiga es una función que se declara dentro de una clase y se define fuera de ella. No
requiere ningún operador de resolución de ámbito para definir . Puede acceder a los miembros privados de una
clase. Se declara utilizando la palabra clave "friend".
Ex:
muestra de clase
{ int x,y; public: muestra(int a,int b);
friend int suma(muestra s);
};
muestra::muestra(int a,int b)
{ x=a;y=b;
}
int suma(muestras s)
{ int suma;
suma=s.x+s.y;
Devuelve 0;
}
void main()
{
Muestra obj(2,3);
int res=suma(obj);
cout<< "suma="<<res<<endl;
}
Una función amiga posee ciertas características especiales:
No está en el ámbito de la clase a la que se ha declarado como amigo.
Como no está en el ámbito de la clase, no puede ser llamado utilizando el objeto de esa clase. Puede invocarse como una
función normal sin ayuda de ningún objeto.
A diferencia de las funciones de miembro, no puede acceder directamente a los nombres de los miembros y tiene que utilizar un
nombre de objeto y un operador de pertenencia de punto con cada nombre de miembro.
Puede declararse en la parte pública o privada de una clase sin que ello afecte a su significado.
Normalmente, tiene los objetos como argumentos.
#include<iostream.h> class sample
{
int a;
int b;
público:
void setvalue()
{
a=25;
b=40;
}
amigo float media(muestra s);
};
float media(muestra s)
{
return float(s.a+s.b)/2.0;
}
int main()
{
muestra X;
X.setvalue();
cout<<"Valor medio="<<media(X);
Devuelve 0;
}
escribe un programa para encontrar el maximo de dos numeros usando una funcion amiga para dos
clases diferentes #include<iostream>
clase muestra2;
clase muestra1
{
int x;
público:
muestra1(int a);
friend void max(muestra1 s1,muestra2 s2)
};
muestra1::muestra1(int a)
{
x=a;
}
clase muestra2
{
int y;
público:
muestra2(int b);
friend void max(muestra1 s1,muestra2 s2)
};
Muestra2::muestra2(int b)
{
y=b;
}
void max(muestra1 s1,muestra2 s2)
{
Si(s1.x>s2.y)
cout<<"Miembro de datos en Objeto de la clase muestra1 es mayor"<<endl;
si no
cout<<"Miembro de datos en Objeto de la clase muestra2 es mayor"<<endl;
}
void main()
{
muestra1 obj1(3);
muestra2 obj2(5);
max(obj1,obj2);
}
Escribe un programa para sumar números complejos usando la función amiga
#include<iostream>
clase compleja
{
float real,img;
público:
complejo();
complex(float x,float y)
friend complejo add_complex(complejo c1,complejo c2);
};
complejo::complejo()
{
real=img=0;
}
complex::complex(float x,float y)
{
real=x;img=y;
}
complejo add_complex(complejo c1,complejo c2)
{
complejo t;
t.real=c1.real+c2.real;
t.img=c1.img+c2.img;
devolver t;
}
void complejo::mostrar ()
{
if(img<0)
{img=-img;
cout<<real<<"-i"<<img<<<endl
} else { cout<<real<<"+i"<<img<<<endl
}
}
int main()
{
complejo obj1(2,3);
complejo obj2(-4,-6);
complejo obj3=add_compex(obj1,obj2);
obj3.display();
Devuelve 0;
}
Clase amiga:Una clase también puede declararse amiga de otra clase. Cuando creamos una clase amiga,
todas las funciones miembro de la clase amiga también se convierten en amigas de la otra clase. Esto requiere la
condición de que la clase que se convierte en amigo debe ser declarada o definida en primer lugar (declaración
hacia adelante).
#include <iostream.h>
clase muestra_1
{
clase amiga muestra_2;//declarar clase amiga
int a,b;
público:
void getdata_1()
{
cout<<"Introduce los valores A y B en la clase muestra_1";
cin>>a>>b;
}
void display_1()
{
cout<<"A="<<a<<endl;
cout<<"B="<<b<<endl;
}
};
clase muestra_2
{
int c,d,suma;
sample_1 obj1;
público:
void getdata_2()
{
obj1.getdata_1();
cout<<"Introduzca los valores C y D en la clase muestra_2"; cin>>c>>d;
}
void suma_2()
{
suma=obj1.a+obj1.b+c+d;
}
void visualizar_2()
{
cout<<"A="<<obj1.a<<<endl;
cout<<"B="<<obj1.b<<<endl;
cout<<"C="<<c<<endl;
cout<<"D="<<d<<endl;
cout<<"SUMA="<<suma<<endl;
}
};
int main()
{
sample_1 s1;
s1.getdata_1();
s1.display_1();
muestra_2 s2;
s2.getdata_2();
s2.suma_2();
s2.display_2();
}
Introduzca los valores A y B en la clase sample_1:1 2

A=1
B=2
Introduzca los valores A y B en la clase sample_1:1 2 3 4
Introduzca los valores C y D en la clase muestra_2:A=1
B=2
C=3
D=4
SUMA=10
UNIDAD -3
Constructores, destructores, herencia:

Introducción a los Constructores, Constructores por Defecto, Constructores Parametrizados, Copiar
Constructores, Múltiples Constructores en una Clase, Destructores.
Herencia :Introducción a la herencia, Definición de Clases Derivadas, Herencia Simple, Herencia Múltiple,
Herencia Multinivel, Herencia Jerárquica, Herencia Híbrida.
D
Introducción a los Constructores: C++ proporciona una función miembro especial
llamada constructor que permite que un objeto se inicialice a sí mismo cuando se crea.
Definición: - Un constructor es una función miembro especial cuya tarea es inicializar los objetos de su
clase. Es especial porque su nombre es el mismo que el de la clase. El constructor se invoca cada vez
que se crea un objeto de su clase asociada. Se llama constructor porque construye los valores de los
miembros de datos de la clase.
Un constructor se declara y define como sigue:
integer obj1; => no sólo crea el objeto obj1 sino que también inicializa sus datos m y n a cero. No es necesario
escribir ninguna sentencia para invocar la función constructora.
CARACTERÍSTICAS DEL CONSTRUCTOR
> Deben declararse en la sección pública.
Se invocan automáticamente cuando se crean los objetos.
> No tienen tipo de retorno, ni siquiera void.
No se pueden heredar, aunque una clase derivada puede llamar al constructor de la
clase base.
> Como otras funciones c++, pueden tener argumentos por defecto.
> Los constructores no pueden ser virtuales.
>
Realizan "llamadas implícitas" a los operadores new y delete cuando es necesario asignar memoria.
Los constructores son de 3 tipos:
1. Constructor por defecto
2. Constructor parametrizado
3. Constructor de copias
1 Constructor por defecto: Un constructor que no acepta parámetros se denomina constructor por defecto.
#include<conio.h> class item
{
int m,n;
público:
item()
{
m=10;
n=20;
}
void put();
};
void item::put() {
cout<<m<<n;
}
void main()
{
item t;
t.put();
getch();
}
2 Constructores parametrizados:-Los constructores que toman parámetros se llaman
constructores parametrizados.
elemento de clase
{
int m,n;
público:
item(int x, int y)
{
m=x;
n=y;
}
};
Cuando un constructor ha sido parametrizado, la sentencia de declaración de objeto como item
t; puede no funcionar. Debemos pasar los valores iniciales como argumentos a la función constructora
cuando se declara un objeto. Esto puede hacerse de 2 maneras: item t=item(10,20); //llamada explícita
item t(10,20); //llamada implícita

Ej:
#include<conio.h>
elemento de clase
{
int m,n;
público:
item(int x,int y)
{
m=x;
n=y;
}
void put();
};
void item::put()
{
cout<<m<<n;
}
void main()
{
item t1(10,20);
elemento t2=elemento(20,30);
t1.put();
t2.put();
getch();
}
3 .Copy Constructor: Un constructor de copia se utiliza para declarar e inicializar un objeto
a partir de otro objeto.
Ej:
elemento t2(t1);
o
elemento t2=t1;
1. El proceso de inicialización a través de un constructor de copia se conoce como inicialización de

copia.
2. t2=t1 no invocará al constructor de copia. t1 y t2 son objetos, asigna los valores de t1 a t2.
3. Un constructor de copia toma una referencia a un objeto de la misma clase que él como
un argumento. #include<iostream.h>
muestra de clase
{
int n;
público:
muestra()
{
n=0;
}
sample(int a)
{
n=a;
}
muestra(muestra &x)
{
n=x.n;
}
void display()
{
cout<<n;
}
};
void main()
{
muestra A(100);
muestra B(A);
muestra C=A;
muestra D;
D=A;
A.display();
B.display();
C.display();
D.display();
}
Salida: 100 100 100 100
Múltiples Constructores en una Clase: Se pueden declarar múltiples constructores en una clase. Puede
haber cualquier número de constructores en una clase.
clase compleja
{
float real,img;
público:
complex()//constructor por defecto
{
real=img=0;
}
complex(float r)//constructor parametrizado de un solo parámetro

{
real=img=r;
}
complex(float r,float i) //constructor parametrizado de dos parámetros

{
real=r;img=i;
}
complex(complex&c)//constructor de copia
{
real=c.real;
img=c.img;
}
suma compleja(complejo c ) {
complejo t;
t.real=real+c.real;
t.img=img+c.img;
devolver t;
}
void mostrar()
{
Si(img>0)
cout<<real<<"+i"<<img<<<endl;
si no
{
img=-img;
cout<<real<<"-i"<<img<<<endl;
}
};
void main()
{
complejo c1(1,2);
complejo c2(2,2);
compex c3;
c3=c1.suma(c3);
c3.show();
DESTRUCTORES:Un destructor, se utiliza para destruir los objetos que han sido creados por un constructor.
Al igual que un constructor, el destructor es una función miembro cuyo nombre es el mismo que el de la
clase pero va precedido de una tilde.
Ej: ~item() { }
1. Un destructor nunca toma ningún argumento ni devuelve ningún valor.
2. Será invocado implícitamente por el compilador al salir del programa para limpiar el almacenamiento
que ya no es accesible.
3. Es una buena práctica declarar destructores en un programa ya que libera espacio de memoria para uso
futuro.
#include<iostream>
clase Marcas
{
público:
int matemáticas;
int science;
//constructor
Marcas() {
cout << "Dentro del Constructor"<<endl;
cout << "Objeto C++ creado"<<endl;
}
//Destructor
~Marks() {
cout << "Dentro del destructor"<<endl;
cout << "Objeto C++ destruido"<<endl;
}
};
int main( )
{
Marcas m1;
Marcas m2;
Devuelve 0;
}
Salida:
Dentro del constructor
Objeto C++ creado
Dentro del constructor
Objeto C++ creado
Destructor interior
Objeto C++ destruido
Destructor interior
Objeto C++ destruido
HERENCIA: . El mecanismo de derivación de una nueva clase a partir de una antigua se denomina
herencia o derivación. La clase antigua se denomina clase base y la nueva, clase derivada o subclase. La
clase derivada hereda algunos o todos los rasgos de la clase base.
Una clase también puede heredar propiedades de más de una clase o de más de un nivel.
Una clase derivada puede definirse especificando su relación con la clase base además de sus propios detalles.
clase nombre-clase-derivada : modo-visibilidad nombre-clase-base {
Los dos puntos indican que el nombre de la clase derivada se deriva del nombre de la clase base. el modo de
visibilidad es opcional y, si está presente, puede ser private o protected o public. Por defecto es privado. El
modo de visibilidad especifica si las características de la clase base se derivan de forma privada o pública.
clase ABC : privado XYZ { //derivación privada

miembros de ABC;
};
clase ABC:public XYZ
{
miembros de ABC;
};
//derivación pública
class ABC:protected XYZ { // miembros de derivación protegidos de ABC;

};
clase ABC:XYZ //privado por defecto
{
miembros de ABC;
};
Cuando una clase base es heredada de forma privada por una clase derivada, los miembros públicos
de la clase base sólo pueden ser accedidos por las funciones miembro de la clase derivada. Los miembros
privados de la clase base son inaccesibles para los objetos de la clase derivada.
Cuando una clase base es heredada de forma protegida por una clase derivada, los miembros públicos
de la clase base sólo pueden ser accedidos por las funciones miembro de la clase derivada.Los miembros
privados de la clase base son inaccesibles para los objetos de la clase derivada. Si los miembros privados de la
clase base van a ser heredados a la clase derivada, entonces declárelos como protegidos.
Cuando la clase base se hereda públicamente, los miembros públicos de la clase base se heredan
públicamente, los miembros públicos de la clase base se convierten en miembros públicos de la clase derivada
y, por tanto, son accesibles a los objetos de la clase derivada. En ambos casos, los miembros privados no se
heredan y, por lo tanto, los miembros privados de una clase base nunca se convertirán en miembros de su clase
derivada.
En la herencia, algunos de los elementos de datos y funciones miembro de la clase base se "heredan" en
la clase derivada. Podemos añadir nuestros propios datos y funciones miembro y ampliar así la funcionalidad de
la clase base. La herencia, cuando se utiliza para modificar y ampliar la capacidad de las clases existentes, se
convierte en una herramienta muy poderosa para el desarrollo incremental de programas.
Visibilidad de los miembros heredados

Visibilidad elate derivada
Baur cUu* vitibility
Derivación
pública Derivación privada Derivación protegida
Privado —♦ No heredado No heredado
No heredado Protegido
Protegido ♦ Privado Protegido
Público — Público Privado Protegido
Tipos de herencia: 1. Herencia simple 2. Herencia multinivel 3. Herencia múltiple 4. Herencia híbrida 5.
Herencia múltiple Herencia jerárquica.
1.HERENCIA ÚNICA: una clase derivada hereda de una sola clase base. Es la forma más sencilla de
Herencia.
A / /Clase base
B //Clase derivada
#include<iostream> using namespace std; class A { public: int a,b; void get() { cout<<"Introduzca dos valores
enteros cualesquiera"<<endl; cin>>a>>b;
} };
clase B:public A {
int c;
público:
void add()
{ c=a+b;
cout<<a<<"+"<<b<<"="<<c;
}
};
int main()
{
B b;
b.get();
b.add();
}
Salida:
Introduzca dos valores enteros cualesquiera
12
1+2=3
2.HERENCIA MÚLTIPLE: En este tipo de herencia la clase derivada hereda de una clase, que a su vez
hereda de alguna otra clase. La Superclase para uno, es subclase para el otro.
clase A
{
público:
int a,b;
void get()
{
cout<<"Introduzca dos valores enteros cualesquiera"<<endl;
cin>>a>>b;
}
};
clase B:public A
{
público:
int c;
void add()
{
c=a+b;
}
};
clase C:public B
{
público:
void mostrar()
{
cout<<a<<"+"<<b<<"="<<c;
}
};
int main()
{
C c;
c.get();
c.add();
c.show();
}
Salida:
Introduzca dos valores enteros cualesquiera
12 14
12+14=26
3 Herencia múltiple:en este tipo de herencia, una única clase derivada puede heredar de dos o más clases
base.
Sintaxis
: clase D : visibilidad A, visibilidad B,.... {
clase A
{
público:
int a;
void getA()
{
cout<<"Introduzca un valor entero"<<endl; cin>>a;
}
};
clase B
{
público:
int b;
void getB()
{
cout<<"Introduzca un valor entero"<<endl; cin>>b;
}
};
clase C:public A,public B

{
público:
int c;
void add()
{
c=a+b;
cout<<a<<"+"<<b<<"="<<c<<endl;
}
};
int main()
{
C obj;
obj.getA();
obj.getB();
obj.add();
}
Introduzca un número entero
valor 12 Introduzca un
Valor entero 13 12+13=25
4 Herencia híbrida: La herencia híbrida es la combinación de dos o más herencias, como la herencia
simple, múltiple, multinivel o jerárquica.
clase aritmética
{
protegida:
int num1, num2;
público:
void getdata()
{
cout<<"Para la adición:";
cout<<"\nIntroduzca el primer número: ";
cin>>num1;
cout<<"\nIntroduzca el segundo número: ";
cin>>num2;
}
};
clase plus:aritmética pública
{
protegida:
int suma;
público:
void add()
{
suma=num1+num2;
}
};
clase menos
{
protegida:
int n1,n2,diff;
público:
void sub()
{
cout<<"\nPara la resta:";
cout<<"\nIntroduzca el primer número: ";
cin>>n1;
cout<<"\nIntroduzca el segundo número: ";
cin>>n2;
diff=n1-n2;
} };
clase resultado:public más, public menos
{
público:
void display()
{
cout<<"\nSuma de "<<num1<<" y "<<num2<<"= "<<suma;

cout<<"\nDiferencia de "<<n1<<" y "<<n2<<"="<<diff;
}
};
int main()
{
resultado z;
z.getdata();
z.add();
z.sub();
z.display();
}
Por adición:
Introduzca el primer número: 1
Introduzca el segundo número: 2
Para restar:
Introduzca el primer número: 3
Introduzca el segundo número: 4
Suma de 1 y 2= 3
Diferencia de 3 y 4= -1
5 Herencia Jerárquica:- Heredar es un método de herencia donde una o más clases derivadas derivan de
una clase base común.
#include<iostream.h> class A //Clase base {

público:
int a,b;
void getnumber()
{
cout<<"\n\nIntroduzca el número :\t"; cin>>a;
}
};
clase B : public A //Clase derivada 1
{
público:
void cuadrado()
{
getnumber(); //Llamar a la propiedad de la clase Base cout<<"Cuadrado del número :\t"<<(a*a);
}
};
clase C :public A //Clase derivada 2
{
público:
void cubo()
{
getnumber(); //Llamar a la propiedad de la clase Base cout<<"\n\tCubo del número :::\t"<<(a*a*a);
}
};
int main()
{
B b1; //b1 es un objeto de la clase derivada 1
b1.square(); //llamar a función miembro de la clase B C c1; //c1 es objeto de la clase derivada 2
c1.cube(); //llamar a función miembro de la clase C }
Cuadrado del número : 4
Cubo del número ::: 27

UNIDAD -4
Punteros, Funciones Virtuales y Polimorfismo:Introducción, Gestión de Memoria, Operador new y

Operador delete, Punteros a Objetos, este Puntero, Punteros a
Clases derivadas,Polimorfismo,Polimorfismo en tiempo de compilación,Polimorfismo en tiempo de
ejecución,Virtual
Funciones,Funciones virtuales puras,Clases base virtuales,Destructores virtuales,Función
Sobrecarga, Sobrecarga de operadores, Reglas para la sobrecarga de operadores - operadores binarios y
unarios.
Introducción a la gestión de memoria:
ASIGNACIÓN Y DESASIGNACIÓN DINÁMICAS DE LA MEMORIA (nueva y

borrada)
C utiliza las funciones malloc() y calloc() para asignar memoria dinámicamente en tiempo de ejecución.
Utiliza la función free() para desasignar la memoria asignada dinámicamente.
C++ soporta estas funciones, define dos operadores unarios new y delete que realizan la tarea de asignar y
desasignar la memoria de una manera mejor y más fácil.
Un objeto puede ser creado usando new, y destruido usando delete.
Un objeto de datos creado dentro de un bloque con new, seguirá existiendo hasta que sea
explícitamente
destruido mediante el uso de eliminar.
nuevo operador:-
El operador new se puede utilizar para crear objetos de cualquier tipo, por lo que asigna
memoria suficiente para contener los datos de los objetos y devuelve la dirección de la memoria
asignada. Sintaxis:
puntero-variable = nuevo tipo-datos;
Ej: int *p = new int;
>
Para crear espacio de memoria para matrices: puntero-variable = nuevo tipo-datos[tamaño];
Ej: int *p = new int[10];
eliminaroperador:
Si la variable o el objeto ya no es necesario o necesario es destruido por el operador "delete", por
lo que una cierta cantidad de memoria se libera para fines futuros. Synatx:
eliminar puntero-variable;
Ej: suprimir p;
>
Si queremos liberar una asignación dinámica
array: borrar [tamaño] puntero-variable;
Programa: escribe un programa para encontrar la suma de una lista de enteros #include<iostream> using
namespace std; int main()
{
int n,*p;
cout<<"Introduce el tamaño del array:";
cin>>n;
p=nuevo int[n];
cout<<"Introducir lista de enteros"<<endl;
for(int i=0;i<n;i++)
cin>>p[i];
//lógica de la suma
int s=0;
for( int i=0;i<n;i++)
s=s+p[i];
cout<<"La suma de los elementos del array es\n";
cout<<s;
suprimir [ ]p;
Devuelve 0;
}
Introduzca el tamaño de la matriz:5
Introducir lista de enteros
1 2345
La suma de los elementos de la matriz es
15
Miembro Operador de desreferencia:-

2. Puntero al operador miembro ->*
Puntero a un declarador de miembro ::*
Este operador se utiliza para declarar un puntero al miembro de la clase #include<iostream.h>
muestra de clase
{público:
int x;
};
int main()
{ muestra s; //objeto
int muestra ::*p;//declaración de puntero
s.*p=10; //correcto
cout<<s.*p;
}
Salida:10
2 .puntero a operador miembro ->*
muestra de clase
{
público:
int x; void
display() {
}
};
int main()
{
muestra s; //objeto
muestra *ptr;
int muestra::*f=&muestra::x;
s.x=10;
ptr=&s;
cout<<ptr->*f;
ptr->display();
}
3 . Puntero al operador miembro .*
muestra de clase
{
público:
int x;
};
int main()
{
muestra s; //objeto
int muestra ::*p;//declaración de punteros
s.*p=10; //correcto
cout<<s.*p;
}
Punteros a objetos:Los punteros a objetos son útiles para crear objetos en tiempo de ejecución. Para acceder a
los miembros operador de flecha ( ) y el operador de referenciación o indirección (*).
Declaración de puntero.
className*ptr
ex:
item *obj;
Aquí obj es un puntero a objeto de tipo item.
elemento de clase
{
código int;
precio de flotación;
público:
void getdata(int a,float b)
{
code=a;
precio=b;
}
void mostrar()
{
cout<<"código:"<<código<<<"\n"<<"Precio:"<<precio<<<endl;
}
};
Declaración de objeto y puntero a clase item: item obj;

item *ptr=&obj;
Se puede acceder al miembro de la siguiente manera.
a) Acceso a miembros mediante el operador punto obj.getdata(101,77.7); obj.show();
b)mediante puntero
ptr->getdata(101,77.7);
ptr->show();
c)Utilizando el operador de referenciación y el operador punto (*ptr).getdata(101,77.7);
(*ptr).show();
Creación de matriz de objetos mediante puntero: item *ptr=new item[10];
La declaración anterior crea espacio de memoria para un array de 10 objetos de tipo item.
#include<iostream.h> class item

{
código int;
precio de flotación;
público:
void getdata(int a,float b) {
código=a; precio=b;
}
void mostrar()
{
cout<<code<<"\t"<<precio<<<endl;
}
};
int main()
{
int n;
int cd;
float pri;
cout<<"Introduce el número de objetos a crear:";
cin>>n;
item *ptr=nuevo item[n];
item *p;
p=ptr;
for(int i=0;i<n;i++) {
cout<<"Introduce los datos del objeto"<<i+1;
cout<<"\nIntroduzca el código:";cin>>cd;
cout<<"Introduzca el precio:";cin>>pri;
p->getdata(cd,pri);
p++;
}
p=ptr;
cout<<"Los datos de varios objetos son "<<endl;
cout<<"Sno\tCode\tPrice\n";
for(i=0;i<n;i++)
{
cout<<i+1<<"\t";
ptr->show();
ptr++;
}
Devuelve 0;
}
Punteros a clases derivadas: Los punteros se pueden declarar a la clase derivada. se puede utilizar para
acceder a los miembros de la clase base y la clase derivada. Un puntero de una clase base también puede
utilizarse para apuntar a un objeto de una clase derivada, pero sólo puede acceder a los miembros heredados de
la clase base.
clase base
{
público:
int a;
void get_a(int x)
{
a=x;
}
void visualizar_a()
{
cout<<"En base"<<"\n"<<"a="<<a<<<endl;
}
};
clase derivada:base pública
{
int b;
público:
void get_ab(int x,int y)
{
a=x;
b=y;
}
void mostrar_ab()
{
cout<<"En Derivados"<<"\n"<<"a="<<a<<"\nb="<<b<<<endl;
}
};
int main()
{
base b;
base *bptr;
bptr=&b;//apunta al objeto de la clase base
bptr->get_a(100);
bptr->display_a();
derivado d;
derivado *dptr;
dptr=&d;//apunta al objeto de la clase derivada
dptr->get_a(400);
dptr->display_a();
dptr->get_ab(300,200);
dptr->display_ab();
bptr=&d;//apunta al objeto de clase derivada bptr->get_a(400);

bptr->display_a();
Devuelve 0;
}
Salida:
En la base
a=100
En la base
a=400
En Derivados
a=300
b=200
En la base
a=400
POLIMORFISMO EN TIEMPO DE EJECUCIÓN MEDIANTE FUNCIONES

VIRTUALES
Vinculación estática y dinámica
Polimorfismo significa "un nombre" - "múltiples formas".
Las funciones miembro sobrecargadas se "seleccionan" para su invocación mediante argumentos coincidentes,
tanto de tipo como de número. Esta información es conocida por el compilador en el momento de la
compilación y éste es capaz de seleccionar la función adecuada para una llamada concreta en el mismo
momento de la compilación. Esto se denomina vinculación temprana o vinculación estática o enlace
estático. También conocido como polimorfismo en tiempo de compilación. La vinculación anticipada
significa que un objeto está vinculado a su llamada de función en tiempo de compilación.
Estaría bien poder seleccionar la función miembro adecuada mientras se ejecuta el programa. Esto se
conoce como polimorfismo en tiempo de ejecución. C++ soporta un mecanismo conocido como función
virtual para conseguir polimorfismo en tiempo de ejecución.
En tiempo de ejecución, cuando se sabe qué objetos de clase se están considerando, se invoca la
versión adecuada de la función. Dado que la función se vincula a una clase concreta mucho después de la
compilación, este proceso se denomina vinculación tardía. También se conoce como vinculación dinámica
porque la selección de la función adecuada se realiza dinámicamente en tiempo de ejecución.
Función Operador Virtual

Sobrecarga Sobrecarga Funciones
FUNCIONES VIRTUALES
El polimorfismo se refiere a la propiedad por la cual objetos pertenecientes a distintas clases son
capaces de responder al mismo mensaje, pero de distinta forma. Un requisito esencial del polimorfismo es, por
tanto, la capacidad de referirse a objetos sin tener en cuenta sus clases.
Cuando utilizamos el mismo nombre de función tanto en la clase base como en la derivada, la función
en la clase base se declara como virtual utilizando la palabra clave virtual que precede a su declaración normal.
Cuando una función se hace virtual, C++ determina qué función utilizar en tiempo de ejecución basándose en
el tipo de objeto apuntado por el puntero base, en lugar del tipo del puntero. Así, haciendo que el puntero base
apunte a diferentes objetos, podemos ejecutar diferentes versiones de la función virtual.
clase Base
{
público:
void display()
{
cout<<"Base de la pantalla";
}
virtual void show()
{
cout<<"Mostrar Base";
}
};
clase Derivados : public Base
{
público:
void display()
{
cout<<"Mostrar derivado";
}
void mostrar()
{
cout<<"mostrar derivados";
}
};
void main()
{
Base b;
Derivado d;
Base *ptr;
cout<<"ptr apunta a Base";
ptr=&b;
ptr->display(); //llama a Base
ptr->show(); //llama a Base
cout<<"ptr apunta a derivado";
ptr=&d;
ptr->display(); //llama a Base
ptr->show(); //clase Derivada
}
Salida:
ptr apunta a Base

Base de exposición
Mostrar base
ptr apunta a Derivado
Base de exposición
Mostrar derivados
Cuando se hace que ptr apunte al objeto d, la sentencia ptr->display(); sólo llama a la función
asociada a la Base, es decir Base::display()
mientras que la declaración
ptr->show();
llama a la versión derivada de show(). Esto se debe a que la función display() no se ha hecho virtual en la clase
Base.
Normas para las funciones virtuales:
Cuando se crean funciones virtuales para implementar la vinculación tardía, se deben observar algunas
reglas básicas que satisfagan los requisitos del compilador.
1. Las funciones virtuales deben ser miembros de alguna clase.

2. No pueden ser miembros estáticos.
3. Se accede a ellos mediante punteros a objetos.
4. Una función virtual puede ser amiga de otra clase.
5. Una función virtual de una clase base debe definirse, aunque no se utilice.
6. Los prototipos de la versión de clase base de una función virtual y de todas las versiones de clase
derivada deben ser idénticos. C++ las considera funciones sobrecargadas, y se ignora el mecanismo de
las funciones virtuales.
7. No podemos tener constructores virtuales, pero sí destructores virtuales.
8. Mientras que un puntero base apunta a cualquier tipo del objeto derivado, lo contrario no es cierto, es
decir, no podemos utilizar un puntero a una clase derivada para acceder a un objeto del tipo de la clase
base.
9. Cuando un puntero base apunta a una clase derivada, incrementarlo o decrementarlo no hará que
apunte al siguiente objeto de la clase derivada. Se incrementa o decrementa sólo en relación a su tipo
base. Por lo tanto, no debemos utilizar este método para mover el puntero al siguiente objeto.
10. Si se define una función virtual en la clase base, no es necesario redefinirla en la clase derivada. En
estos casos, las llamadas invocarán la función base.
SOBRECARGA
SOBRECARGA DE OPERADORES
C++ tiene la capacidad de dotar a los operadores de un significado especial para un tipo de datos. El
mecanismo para dar estos significados especiales a un operador se conoce como sobrecarga de operadores.
Podemos sobrecargar todos los operadores excepto los siguientes:
Operador de acceso a miembros de clase ("." Y "
.*") Operador de resolución de ámbito "::"
Operador de tamaño (sizeof)
Operador condicional
Para definir una tarea adicional a un operador, especifique lo que significa en relación con la clase a la
que se aplica el operador. Esto se hace con la ayuda de una función especial, llamada función de
operador. El proceso de sobrecarga implica los siguientes pasos:
1. Cree una clase que defina el tipo de datos que se va a utilizar en la operación de sobrecarga.
2. Declarar la función operador op() en la parte pública de la clase. Puede ser una función miembro o
una función amiga.
3. Aquí op es el operador a sobrecargar.
4. Definir la función de operador para implementar las operaciones requeridas.
Ex:
complejo complejo::operador+(complejo c)
{
complejo t;
t.real=real+c.real;
t.img=img+c.img;
devolver t;
}
Concepto de sobrecarga de operadores
Una de las características únicas de C++ es la sobrecarga de operadores. Aplicar la sobrecarga a los operadores
significa, mismo operador en responder de manera diferente. Por ejemplo, el operador + puede utilizarse como
operador de concatenación y como operador adicional.
Es decir, 2+3 significa 5 (suma), mientras que

"2"+"3" significa 23 (concatenación).
Realizar muchas acciones con un solo operador es la sobrecarga de operadores. Podemos asignar una
función definida por el usuario a un operador. Podemos cambiar la función de un operador, pero no es
recomendable cambiar las funciones reales del operador. No podemos crear nuevos operadores utilizando esta
carga de operador.
El concepto de sobrecarga de operadores puede aplicarse en las dos áreas principales siguientes (Ventajas)
1. Ampliación del uso de operadores
2. Conversión de datos
Reglas que deben seguirse para la sobrecarga de operadores:-
1 Sólo se pueden sobrecargar los operadores existentes.
2 Los operadores sobrecargados deben tener al menos un operando que sea de operadores definidos
por el usuario.
3 No podemos cambiar el significado básico de un operador.
4 El operador sobrecargado debe seguir las características mínimas del operador original.
5 Cuando se utiliza la sobrecarga del operador binario a través de una función miembro, el operando
de la izquierda debe ser un objeto de la clase correspondiente.
El número de argumentos de la lista de argumentos del operador sobrecargado depende de
1. La función operadora debe ser una función miembro o una función amiga.
2. Si la función del operador es una función amiga, tendrá un argumento para el operador unario
& dos argumentos para el operador binario
3. Si la función de operador es una función miembro, tendrá cero argumentos para el operador
unario y un argumento para el operador binario.
Sobrecarga de operadores unarios

Un operador unario es un operador que trabaja con un solo operando. Por ejemplo, ++ es un operador unario,
que toma un solo operando (c++). Así, cuando se sobrecarga un operador unario, no toma argumento (porque el
objeto mismo se considera como argumento).
Sintaxis del operador unario (dentro de una clase)
operador de retorno operatorymbol( )

{
//cuerpo de la función
}
Ex:
void operador-()
{
real=-real;
img=-img;
}
Sintaxis del operador unario (fuera de una clase)
tipo de retorno classname::operatorymbol( )
{
}
Ejemplo 1:-
void operator++()
{
contra++;
}
Ejemplo 2:-
void complejo::operador-()
{
real=-real;
img=-img;
}
El siguiente programa sencillo explica el concepto de sobrecarga unaria.

#include < iostream.h >
#include < conio.h >
// Operador de programa
Sobrecarga de la clase fact
{
int a;
público:
hecho ()
{
a=0;
} fact (int i) {
a=i;
}
hecho operador!()
{
int f=1,i;
hecho t;
for (i=1;i<=a;i++)
{
f=f*i;
}
t.a=f;
devolver t;
}
void display()
{
cout<<"El factorial"<< a;
}
};
void main()
{
int x;
cout<<"introduce un número";
cin>>x;
hecho s(x),p;
p=!s;
p.display();
}
Salida del programa anterior:

Introduzca un número 5
El factorial de un número dado 120
Explicación:
Hemos tomado "!" como operador para sobrecargar. Aquí el nombre de la clase es un hecho. Constructor sin
parámetros para tomar inicialmente el valor de "x" como 0. Constructor con parámetro para tomar el valor de "x
" . Hemos creado dos objetos uno para hacer el factorial y otro para devolver el factorial. Aquí el número de
parámetros para una función sobrecargada es 0. Factorial es un operador unario porque opera sobre un elemento
de datos. la sobrecarga del operador encuentra el factorial del objeto. La función de visualización para imprimir
el resultado.
Sobrecarga del operador unario -
Ejemplo 1:-
Escribe un programa para sobrecargar el operador unario -
#include<iostream>
clase compleja
{
float real,img;
público:
complejo();
complex(float x, float y);
void display();
void operator-();
};
complejo::complejo()
{
real=0;img=0;
}
complex::complex(float x, float y)
{
real=x;
img=y;
}
void complejo::mostrar()
{
int imag=img;
if(img<0)
{
imag=-img;
cout<<real<<" -i"<<imag<<<endl;
}
si no
cout<<real<<" +i"<<img<<<endl;
}
void complejo::operador-()
{
real=-real;
img=-img;
}
int main()
{
complejo c(1,-2);
c.display();
cout<<"Después de Unary - operación\n";
-c;
c.display();
}
Ejemplo 2:-
espacio de clase
{
int x,y,z;
público:
void getdata(int a,int b,int c);
void display();
void operator-();
};
void space :: getdata(int a,int b,int c)
{
x=a;
y=b;
z=c;
}
void espacio :: mostrar()
{
cout<<"y="<<y<<endl;
cout<<"z="<<z<<endl;
}
void espacio :: operador-()
{
x=-x;
y=-y;
z=-z;
}
int main()
{
espacio s;
s.getdata(10,-20,30);
s.display();
-s;
cout<<"después de la negación\n";
s.display();
}
Salida:
x=10
y=-20
z=30
después de la negación
x=-10
y=20
z=-30
Es posible sobrecargar un operador menos unario utilizando una función amiga de la siguiente manera:
friend void operator-(space &s);
Ejemplo 3:-
Operador menos unario utilizando una función amiga
espacio de clase
{
int x,y,z;
público:
void getdata(int a,int b,int c);
void display();
friend void operator-(space &);
};
void space :: getdata(int a,int b,int c)
{
x=a;
y=b;
z=c;
}
void espacio :: mostrar()

{
cout<<x<<" "<<y<<" "<<z<<<endl;
}
void operator-(space &s)
{
s.x=-s.x;
s.y=-s.y;
s.z=-s.z;
}
int main()
{
espacio S;
S.getdata(10,-20,30);
S.display();
-S;
cout<<"después de la negación\n";
S.display();
}
Salida:
10 -20 30
después de la negación
-10 20-30
Sobrecarga de operadores binarios

Un operador binario es un operador que trabaja con dos operandos. Por ejemplo, + es un operador binario, toma
un solo operando (c+d). Así, al sobrecargar un operador binario, éste toma un argumento (uno es el objeto
mismo y el otro es el argumento pasado).
Sintaxis del operador binario (dentro de una clase) operador de tipo retorno
operatorsymbol(argumento) {
}
Sintaxis para la definición del operador binario (fuera de una clase) return-type classname::operator
operatorsymbol(argument) {
}
Ejemplo operador complejo+(complejo s)

{
complejo t;
t.real=real+s.real;
t.img=img+s.img;
devolver t;
}
El siguiente programa explica la sobrecarga de operadores binarios:
suma de clases
{
int a;
público:
suma()
{
a=0;
}
suma(int i)
{
a=i;
}
suma operador+(suma p1)
{
suma t;
t.a=a+p1.a;
devolver t;
}
void main ()
{
cout<<"Introduzca dos números:"
int a,b;
cin>>a>>b;
suma x(a),y(b),z;
z.display();
z=x+y;
cout<<"después de aplicar el operador \n";
z.display();
getch();
}
Salida del programa anterior:
Introduzca dos números 5 6
Tras aplicar el operador
La suma de dos números 11
Explicación: El nombre de la clase es "suma" . Hemos creado tres objetos dos para hacer la suma y el otro para
devolver la suma. +" es un operador binario que opera sobre miembros de dos objetos y devuelve el resultado
que es miembro de un objeto. La suma se muestra en la función de visualización.
Escribe un programa para sobrecargar operadores aritméticos en números complejos utilizando la

función miembro
clase compleja
{
float real,img;
público:
complex(){ }
complex(float x, float y)
{
real=x;
img=y;
}
complejo operador+(complejo c) void display();
};
complejo complejo::operador+(complejo c)
{
temperatura compleja;
temp.real=real+c.real;
temp.img=img+c.img;
devolver temp;
}
{
int imag=img;
Si(img<0)
{
imag=-imag;
cout<<real<<"-i"<<imag;
} else cout<<real<<"+i"<<img;
}
int main()
{
complejo c1,c2,c3;
c1=complejo(2,5,3,5);
c3=c1+c2;
c3.display();
Devuelve 0;
}
Sobrecarga de operadores binarios con Friends
1. Sustituir la declaración de la función miembro por la declaración de la función amiga en la clase amiga
complejo operador+(complejo, complejo)
2. Redefina la función de operador como sigue:
operador complejo+(complejo a, complejo b)
{
return complejo((a.x+b.x),(a.y+b.y));
}
Escribe un programa para sobrecargar operadores aritméticos en números complejos usando la función
amiga #include<iostream.h>
clase compleja
{
float real,img;
público:
complex(){ }
complex(float x, float y)
{
real=x;
img=y;
}
amigo operador complejo+(complejo);
void display();
};
operador complejo+(complejo c1, complejo c2)
{
temperatura compleja;
temp.real=c1.real+c2.real;
temp.img=c1.img+c2.img;
devolver temp;
}
{
Si(img<0)
{
img=-img;
cout<<real<<"-i"<<img;
}
si no
cout<<real<<"+i"<<img;
}
int main()
{
complejo c1,c2,c3;
c3=c1+c2;
c3.display();
Devuelve 0;
}
UNIDAD -5
Plantillas y gestión de excepciones:

Introducción, Plantillas de Clases, Plantillas de Clases con Múltiples Parámetros, Plantillas de Funciones,
Plantillas de Funciones con Múltiples Parámetros, Plantillas de Funciones Miembro. Manejo de
Excepciones: Fundamentos del Manejo de Excepciones , Tipos de Excepciones, Mecanismo de Manejo
de Excepciones, Mecanismo de Lanzar y Atrapar, Volver a Lanzar una Excepción, Especificación de
Excepciones.
PROGRAMACIÓN GENÉRICA(Plantillas)
La programación genérica es un enfoque en el que los tipos genéricos se utilizan como parámetros en los
algoritmos para que funcionen con una variedad de tipos y estructuras de datos adecuados.
Una ventaja significativa de la programación orientada a objetos es la reutilización del código, que
elimina la codificación redundante. Una importante característica de C++ denominada plantillas refuerza esta
ventaja de la programación orientada a objetos y proporciona una gran flexibilidad al lenguaje. Las plantillas
admiten la programación genérica, lo que permite desarrollar componentes de software reutilizables, como
funciones, clases, etc., que admiten distintos tipos de datos en un único marco.
Plantillas Concepto
Introducción
En lugar de escribir funciones diferentes para los distintos tipos de datos, podemos definir funciones comunes
función. Por ejemplo
int max(int a,int b); // Devuelve el máximo de dos enteros float

max(float a,float b); // Devuelve el máximo de dos floats char max(char a,char b); // Devuelve el máximo de
dos caracteres (esto se llama sobrecarga de funciones)
Pero, en lugar de escribir tres funciones diferentes como antes, C++ proporcionó la facilidad llamada
"Plantillas". Con la ayuda de las plantillas puede definir una única función común, como se indica a
continuación:
T max(T a,T b); // T se llama tipo de datos genérico
Las funciones de plantilla son la forma de hacer funciones/clases abstractas creando el comportamiento de la
función sin saber qué datos serán manejados por una función. En cierto sentido, esto es lo que se conoce como
"programación o funciones genéricas".
La función de plantilla se centra más en el pensamiento algorítmico que en un medio específico de tipo de
datos único. Por ejemplo podrías hacer una función push de pila templada. Esta función push puede manejar la
operación de inserción a una pila en cualquier tipo de datos en lugar de tener que crear una función push de
pila para cada tipo diferente.
Sintaxis:
plantilla < clase tipo >
ret_type nombre_funcion(lista_parametros)
{
--------------//cuerpo de la función
} //www.suhritsolutions.com
Características de las plantillas:-

1. Elimina el código redundante
2. Mejora la reutilización del código.
3. Ofrece una gran flexibilidad lingüística
Las plantillas se clasifican en dos tipos. Son
1 Plantillas .Function
2 Plantillas de clase.
Plantillas de funciones
Las plantillas declaradas para funciones se denominan plantillas de funciones. Una plantilla de función define
cómo puede construirse una función individual.
Sintaxis :
plantilla <clase tipo,.........>
ret _type fun_ nombre(argumentos)
{
-----------------// cuerpo de la función
-----------------
}
PLANTILLAS DE CLASE
Las plantillas declaradas para las clases se denominan plantillas de clase. Una plantilla de clase
especifica cómo se pueden construir las clases individuales de forma similar a la especificación de clase
normal. Estas clases modelan una clase genérica que soporta operaciones similares para diferentes tipos de
datos. Forma general de una plantilla de clase
plantilla <clase T> clase nombre-clase {
…; ….
}
Una clase creada a partir de una plantilla de clase se denomina clase de plantilla. La sintaxis para definir un
objeto de una clase de plantilla es:
classname<type> objectname(arglist);
#include<conio.h>
plantilla <clase T> clase swap
{
T a,b;
público:
intercambio(T x,T y)
{
a=x;
b=y;
}
void swapab()
{
T temp;
temp=a;
a=b;
b=temp;
}
void showdata()
{
cout<<a<<b;
}
};
void main()
{
int m,n;
float m1,n1;
cout<<"Introducir valores enteros";
cin>>m>>n;
cout<<"Introducir valores flotantes";
cin>>m1>>n1;
swap<int> c1(m,n);
swap<float> c2(m1,n1);
c1.swapab();
c1.showdata();
c2.swapab();
c2.showdata();
}
Plantilla de clase con múltiples parámetros
Sintaxis:
template <clase T1, clase T2,....> clase-nombre-clase

{}
#include<iostream.h> template <clase T1,clase T2> class Test

{
T1 a;
T2 b;
público:
Prueba(T1 x,T2 y)
{ a=x; b=y;
}
void mostrar()
{
cout<<a<<b;
}
};
void main()
{
Test<float,int> test1(1.23,123);
Test<int,char> test2(100, "w");
test1.show();
test2.show();
}
PLANTILLAS DE FUNCIONES
Al igual que las plantillas de clases, también podemos definir plantillas de funciones que se utilizarían para
crear una familia de funciones con diferentes tipos de argumentos.
Formulario general:
plantilla <clase T>
return-type nombre-función (argumentos de tipo T)
{}
plantilla<clase T>
void swap(T &x, T &y)
{
T temp = x;
x=y;
y=temp;
}
void fun(int m,int n,float a,float b)
{
cout<<m<<n;
swap(m,n);
cout<<m<<n;
cout<<a<<b;
swap(a,b);
cout<<a<<b;
}
int main()
{
fun(100,200,11.22,33.44);
Devuelve 0;
}
Ejemplo 2:-
plantilla
T máx(T a, T b)
{
si(a>b)
devolver a;
si no
devolver b;
}
void main( )
{
char ch1,ch2,ch3;
cout<<"introduce dos caracteres"<< ch2<< ch3;
cin>>ch2>>ch3;
d=max(ch2,ch3);
cout<<"max(ch2,ch3)"<< ch1;
int a,b,c;
cout<<"introduce dos enteros:";
cin>>a>>b;
c=max(a,b);
cout<<"max(a,b):"<< c<<< endl;
float f1,f2,f3;
cout<<"introduce dos flotantes< f1f2 >:";
cin>>f1,f2;
f3=max(f1,f2);
cout<<"max(f1,f2):"<< f3;
}
salida:
introduzca dos caracteres: A,B
max(ch2,ch3):B
introduzca dos números enteros:20,10
max (a,b) :20
introduce dos flotantes :20.5,30.9
máx (f1,f2) :30,9
Plantilla de función con varios parámetros

Al igual que la clase de plantilla, podemos utilizar más de un tipo de datos genéricos en la sentencia de
plantilla, utilizando una lista separada por comas como se muestra a continuación:
template <clase T1, clase T2,.> return-type función-
name(argumentos de tipos T1,T2.) {
}
#inlcude<string.h>
template<clas T1, class T2> void display(T1 x,T2 y) {
cout<<x<<y;
}
int main()
{
display(1999, "EBG");
pantalla(12.34,1234);
Devuelve 0;
}
Gestión de excepciones
Excepciones: Las excepciones son anomalías en tiempo de ejecución o condiciones inusuales que un programa
puede encontrar mientras se ejecuta. Las anomalías pueden incluir condiciones tales como la división por cero,
el acceso a una matriz fuera de sus límites o quedarse sin memoria o espacio en disco. Cuando un programa
encuentra una condición de excepción, debe ser identificada y tratada.
Las excepciones permiten transferir el control de una parte del programa a otra. El manejo de
excepciones en C++ se basa en tres palabras clave: try, catch y throw.
Tipos de excepciones:Existen dos tipos de excepciones

1.Excepciones sincrónicas
2.Excepciones asíncronas
1.Excepciones síncronas: Errores como "índice fuera de rango" y "exceso de flujo" son excepciones síncronas.
2.Excepciones asíncronas: Los errores que se generan por cualquier evento fuera del control del programa se
denominan excepciones asíncronas
El objetivo del tratamiento de excepciones es proporcionar un medio para detectar y notificar una
circunstancia excepcional.
Mecanismo de gestión de excepciones:

Se dice que se lanza una excepción en el lugar donde se detecta algún error o condición anormal. El
lanzamiento hará que se aborte el flujo normal del programa, en una excepción levantada. Una excepción se
lanza programáticamente, el programador especifica las condiciones de un lanzamiento.
En las excepciones manejadas, la ejecución del programa se reanudará en un bloque de código
designado, llamado bloque catch, que encierra el punto de lanzamiento en términos de ejecución del programa.
El bloque de captura puede estar, y suele estar, situado en una función diferente a la del punto de lanzamiento.
El manejo de excepciones en C++ se basa en tres palabras clave: try, catch y throw.
Try se utiliza para preceder un bloque de sentencias que pueden generar excepciones. Este bloque de sentencias se conoce
como bloque try. Cuando se detecta una excepción, se lanza utilizando la sentencia throw en el bloque try. El bloque
Catch captura la excepción lanzada por la sentencia throw en el bloque try y la maneja apropiadamente.
#include<iostream>
int main()
{
int a,b;
cout<<"Introduce dos valores enteros cualesquiera";
cin>>a>>b;
int x=a-b;
pruebe
{
if(x!=0)
{
cout<<"Resultado(a/x)="<<a/x<<<endl;
}
si no
{ tirar x;
}
}
catch(int ex)
{
cout<<"Exception caught:Divide By Zero \n";
}
}
MECANISMO DE LANZAMIENTO
Cuando se detecta una excepción, puede eliminarse utilizando la sentencia throw en cualquiera de las
siguientes formas
throw(excepción); throw excepción;
tirar;
MECANISMO DE CAPTURA:
El bloque de captura es el siguiente

Catch(tipo de datos arg) {
//declaraciones de manipulación
//excepciones
}
Múltiples sentencias catch:
pruebe
{
//intentar bloque
}
catch(datos tipo1 arg)
{
//captura bloque1
}
catch(datos tipo2 arg)
{
//captura bloque2
} catch(datos tipoN arg)
{
//catch bloqueN
}
• Cuando se lanza una excepción, se busca en el controlador de excepciones una coincidencia adecuada.
• Es posible que los argumentos de varias sentencias catch coincidan con el tipo de una excepción. En
estos casos se ejecuta el primer manejador que coincida con el tipo de excepción
Escribir un programa para atrapar múltiples sentencias catch

void test(int x)
{
pruebe
{
if(x==1) throw x;
si no
if(x==0) lanzar 'x';
si no
if(x==-1) throw 1.0;
cout<<"fin del bloque try"<<endl;
}
catch(char c)
{
cout<<"capturado un carácter"<<endl;
}
catch(int m)
{
cout<<"capturado un entero"<<endl;
}
catch(double d)
{
cout<<"capturado un doble"<<endl;
}
}
int main()
{
prueba(1);
prueba(0);
prueba(-1);
prueba(2);
Devuelve 0;
}
Salida:
capturó un número entero
atrapó a un personaje
atrapó un doble
fin del bloque try
Coger todas las excepciones:
todos los tipos posibles de excepciones y, por lo tanto, es posible que no pueda diseñar gestores de captura
independientes para capturarlas. En tales circunstancias, podemos forzar una sentencia catch para que atrape
todas las excepciones en lugar de sólo un determinado tipo.
catch(...)
{}
Escribir un programa para capturar todas las excepciones

void test(int x)
{
pruebe
{
if(x==0) throw x;
if(x==0) lanzar 'x';
if(x==-1) throw 1.0;
}
catch(...)
{
cout<<"atrapada excepción"<<endl;
}
}
int main()
{
prueba(-1);
prueba(0);
prueba(1);
Devuelve 0;
}
Re-lanzamiento de una excepción:
Es posible volver a pasar la excepción capturada por un bloque catch a otro manejador de excepciones.
Esto se conoce como Retirada.
#include <iostream>
void MiHandler()
{ try {
lanza "hola";
}
catch (const char*)
{
cout <<"Excepción capturada dentro de MyHandler\n";
throw; //retirar char* de la función
}
}
int main()
{ cout<< "Inicio principal "<<endl; try
{
MyHandler();
}
catch(const char*)
{
cout <<"Capturada excepción dentro de Main\n";
}
cout << "Fin principal";
Devuelve 0;
}
Especificación de excepciones:
La especificación de excepciones restringe las funciones para lanzar algunas excepciones especificadas sólo
con el uso de throw(lista de excepciones) en la cabecera de la función.
Formulario general
Tipo nombre_función(lista argumentos) throw(excepciones -lista)
{
Declaraciones
intentar {
declaraciones
}
#include <iostream>
void test(int x) throw(int,float,char)
{
switch(x)
{
caso 1:lanzar x;
romper;
caso 2:throw 'x';
romper;
caso 3:throw doble(x);
romper;
caso 4:throw float(x);
romper;
}
}
int main()
{
pruebe
{
test(4);//test(4) conduce a una terminación anormal
}
catch(int i)
{
cout <<"Capturada excepción de tipo int\n";
}
catch(float f)
{
cout <<"Capturada excepción de tipo float\n";
}
catch(char c)
{
cout <<"Capturada excepción de tipo char\n";
}
catch(double i)
{
cout <<"Atrapado Excepción de tipo doble\n";
}
Devuelve 0;
}

Notas Digitales: B.Tech (I Año - Ii Sem) (2018-19)

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Notas Digitales: B.Tech (I Año - Ii Sem) (2018-19)

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIÓN ORIENTADA A OBJETOS

DEPARTAMENTO DE CSE & IT

MALLA REDDY COLLEGE OF ENGINEERING & TECHNOLOGY

I Año B.Tech II SEM L T/P/D C

Conceptos de Programación Orientada a Objetos: Paradigma orientado a objetos-diferencias entre

Visión general del lenguaje C:

Visión general del lenguaje C++:

Programación orientada a procedimientos Programación orientada a objetos

Ejemplo de procedimiento orientado Ejemplos de programación orientada a objetos

Principios (o características) de la programación orientada a objetos:

Ventajas de la programación orientada a objetos ( POO)

Fácil de mantener y actualizar: La programación orientada a objetos facilita el mantenimiento y la modificación

Modificabilidad: es fácil realizar pequeños cambios en la representación de datos o en los

3. SECCIÓN DE DEFINICIÓN : Se utiliza para declarar algunas constantes y asignarles

int i; //esta declaración se hace fuera y antes de main()

5. SECCIÓN DE SUBPROGRAMAS O FUNCIONES : Contiene todos los subprogramas o funciones

espacio de nombres definido por el usuario:

using namespace sample;

Tipos de datos primarios:

Enteros con signo: (máquina de 16 bits):

15 14 13 12 11 10 9 8 7 -1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2 +1*2

Tipo de datos de carácter: (char)

Tipo de datos MEMORIA NECESARIA O GAMA ESPECIFICADOR DE

Tipos de coma flotante:

Ejemplos de identificadores no válidos: $amount, ³num', grand-total, suma de dígitos, 4num.

Variables:Una posición de memoria con nombre se denomina variable.

> No debemos utilizar palabras clave como identificadores.

Declaración de variables: La declaración de la variable da el nombre para la ubicación de memoria y su

Pueden ir precedidos de un signo + o ± opcional.

Número entero octal: Consta de un conjunto de dígitos, de 0 a 7.

Número entero hexadecimal: Consiste en un conjunto de dígitos del 0 al 9 y los alfabetos A, B, C, D, E y F. Un

Secuencia de escape Carácter

Los operadores C pueden clasificarse en

2. OPERADORES RELACIONALES : A menudo comparamos dos cantidades y dependiendo de su relación

Tablas verdadero-falso de los operadores AND (&&) y X Y X&&Y X/Y

Ventajas de utilizar el operador de asignación abreviado:

Un operador ternario requiere dos operandos para funcionar

& Y bit a bit

^ Exclusivo bit a bit O

Operador bit a bit OR ( |)

Operador bit a bit OR EXCLUSIVO ( A )

Explicación: El número introducido a través del teclado como entrada es 8 y su correspondiente

Operador bitwise de desplazamiento a la izquierda

Ej: int a=2;

El operador coma (,)

Primero asigna el valor 10 a x, luego asigna 20 a y y fina

Sno Operador Símbolo

8.6 cope Operador de resolución:

3. Puntero a operador miembro .*

Sentencias de control:-El flujo de ejecución de las sentencias de un programa se denomina control. La

/*mayor de dos números*/

/*mayor de dos números*/

cout<<"B es mayor que A\n A="<<b;

EL ESTADO DEL INTERRUPTOR o la SELECCIÓN DE VARIAS VÍAS:

/*programa para simular una calculadora simple */ #include<iostream.h>

cout<<"Introducir número1 operador número2 : ";

Sentencias de control de bucle o repeticiones:

c programa para hallar la suma de n números naturales */

cout<<"La suma de los primeros"<<n<"números naturales es:"<<suma<<<endl; return 0;

2 .DO DECLARACIÓN WHILE :

tlo-mientras - ( Salida controlada )

/*c programa para hallar la suma de n números naturales */

/*c programa para hallar la suma de n números naturales */

15 14 13 12 11 10 9 8 7 -12 +12 +12 +12 +12 +12 +12 +12

/mayor de dos números/

/mayor de dos números/

/programa para simular una calculadora simple / #include<iostream.h>

/c programa para hallar la suma de n números naturales /

/c programa para hallar la suma de n números naturales /

/programa para imprimir números primos hasta un número dado/

/c programa para hallar la suma de n números naturales /