INTRODUCCION a C

Vista previa del material en texto

INTRODUCCION a C++
· El Lenguaje de Programación C++ se diseñó para :
· mejorar el lenguaje C
· apoyar la abstracción de datos
· apoyar la programación orientada a objetos
· Un lenguaje apoya un estilo de programación cuando contiene elementos que facilitan la programación con esa técnica.
· C++ es un superconjunto de C. C++ hereda de C lo siguiente: funciones, aritméticas, selección y construcciones cíclicas, operaciones de E/S, manejo de punteros
· El mínimo programa en C++ es :
main () {}
al igual que en C, todo programa en C++ debe tener una función main y el programa comienza ejecutando esa función 
ALGUNAS MEJORAS MENORES DEL C
Comentarios : // permite introducir comentarios hasta el fin de línea
Nombres de datos enumerados : el nombre de una enumeración es un nombre de tipo, por lo tanto simplifica la escritura de un programa :
	enum { a, b, c=0 }
	enum { d, e, f=e+2 }
	enum color { rojo, amarillo, verde=20, azul }
	color col = rojo
	color* cp = &col
	if(*cp == azul) // …
Nombres de clases y estructuras : los nombres de clases y estructuras son nombres de tipos en C++. Las clases no existen en C. En C++ no se necesita colocar el calificador struct o class delante de un nombre de estructura o clase.
Declaraciones en bloques : C++ permite la introducción de declaraciones de variables dentro de bloques y antes de sentencias ejecutables. Esto permite declarar un identificador más cerca de su punto de aplicación.
for (int k=0; k<10; k++)
	cout << “el valor de k es : ” << k << ‘\n’ ;
Operador de alcance : el operador de alcance :: es un nuevo operador y permite resolver conflictos de nombre. Por ejemplo si se tiene una función local con una variable llamada vector y también se tiene una variable global llamada vector, el calificador ::vector permite acceder a los valores de la variable global. Lo contrario no se puede hacer.
 
Especificador const: sirve para : fijar el valor de una entidad dentro de su alcance, fijar el dato apuntado por una variable puntero, el valor de la dirección del puntero o ambos a la vez (puntero y valor).
Conversiones explícitas de tipo : se puede emplear un tipo predefinido o tipo definido por el programador como una función para convertir datos de un tipo a otro. Bajo ciertas circunstancias se puede emplear la conversión explícita de tipo como una alternativa a una conversión por asignación.
Sobrecarga de funciones : En C++ varias funciones pueden utilizar los mismos nombres de función, cada una de las funciones sobrecargadas puede distinguirse gracias al número y tipo de parámetros.
Valores por omisión de los parámetros de una función : Podemos asignar valores por omisión a los parámetros finales de las funciones de C++. De modo tal que se puede llamar a una función con menos parámetros de los definidos.
Funciones con número no especificado de parámetros : Empleando … se pueden definir funciones con un número no definido de parámetros. No se chequean los tipos de los parámetros utilizados para permitir flexibilidad en el uso.
Parámetros por referencia en una función : Utilizando el operador &, podemos declarar un parámetro de función formal como un parámetro por referencia :
void incremento (int& valor)
{
	valor++;
}
int i;
incremento(i);
Cuando se llama a la función incremento se asigna a la dirección de valor la dirección de i. En incremento se incrementa el valor de i y se devuelve a la función que lo llamó. No es necesario pasar la dirección de i como ocurría en C, con lo que simplifica la codificación.
Operadores new y delete : Los operadores new y delete son introducidos en C++ para asignar y desasignar memoria dinámicamente. 
MEJORAS IMPORTANTES RESPECTO a C
Estas mejoras están directamente relacionadas con la Programación Orientada a Objetos (POO)
Constructores de clases y encapsulamiento de datos : Una clase puede contener en su definición las declaraciones de datos, los valores iniciales y el conjunto de operaciones (métodos) para la abstracción de datos. Se crean objetos a partir de una clase dada. Entre objetos se envían mensajes. Cada objeto puede contener un conjunto público y privado de datos.
Estructura de clases : Una struct en C++ es un subconjunto de una definición de clase, con todos sus miembros públicos. La struct puede contener datos y funciones. 
Constructores y destructores : se emplean para inicializar objetos de una clase determinada. Cuando se declara un objeto se activa el constructor. Los destructores desasignan la memoria del objeto involucrado. Esto se puede hacer explícitamente o automáticamente cuando se sale del ámbito de declaración del objeto.
Mensajes : En C++ los mensajes se envían con un mecanismo similar al llamado de una función. Por lo general se invoca a una función miembro del objeto especificado pasando los parámetros definidos para esa función.
 
		mi_objeto.mi_metodo(5);
Sobrecarga de operadores : C++ podemos redefinir el conjunto de operadores suministrados por el compilador, de modo tal que puedan ser adaptados a los tipos definidos por el usuario. Esto permitiría definir operadores (+,*,/, etc.) para que operen con un tipo definido por el usuario del mismo modo que los tipos fundamentales. 
Clases derivadas : una clase derivada es una subclase de una clase. Este es lo que permite implementar herencia entre los objetos. Un objeto puede heredar el todo o un parte de la superclase. Las subclases heredan la parte pública de la clase madre (superclase), pero no puede heredar la parte privada.
Polimorfismo : es la capacidad que tienen los objetos de responder de distinto modo a un mismo mensaje. En C++ la especificación de las clases derivadas, la sobrecarga de funciones y operadores permiten implementar esta importante característica de la POO.
Facilidades para las E/S : Las entradas y salidas pueden ser rápidamente definidas para ser adaptadas a los distintos objetos definidos por el usuario. cin, cout y cerr, forman una jerarquía de clases y objetos que pueden ser empleados fácilmente.
Elementos del Lenguaje
Un programa C++ está compuesto por una secuencia de componentes léxicos. Existen cinco componentes léxicos: identificadores, palabras claves, operadores, constantes y otro separadores.
Identificadores : en general los nombres que asigna un programador a los: objetos, funciones, enumerador, tipo, miembro de clase, patrón, un valor ó un rótulo y o subprogramas (funciones) 
Palabras claves : palabras reservadas que el programador no puede utilizar de ninguna otra manera que no sea la asignada por el lenguaje.
asm		continue	float		new		signed	try
auto	 	default	for		operator	sizeof	typedef
break	delete	friend	private	static		union
case		do		goto		protected	struct	unsigned
catch		double	if		public	switch	virtual
char		else		inline	register	template	void
class		enum		int		return	this		volatile
const		extern	long		short		throw	while
Los identificadores con doble subrayado _ _ son empleados por algunos compiladores de C++ y bibliotecas estándar por lo que se recomienda no usarlos.
Operadores : tienen una función específica asignada por el programa y van acompañados de identificadores, literales, otros operadores, etc.. Los siguientes caracteres simples se emplean como operadores o signos de puntuación:
!	%	^	&	*	(	)	-	+	 =	{	}
|	[	]	\	;	‘	:	“	<	>	?	,
.	/
 también se emplea la siguiente combinación de caracteres como operadores:
->	++	--	.*	->* 	<<	>>	<=	>=	==	!=	&&
||	*=	/=	%=	+=	-=	<<=	>>=	&=	^=	|=	::
Literales : son los que por lo general se conocen como “constantes” y pueden ser : enteras, de caracteres, flotante (decimal ó real) cadena de caracteres.
numérica : 123456
de caracteres :
nueva línea: \n	tabulador horizontal: \t	tabulador vertical: \v
retroceso: \b	retorno de carro: \r		avance de página: \f
alerta: \a		diagonal invertida: \\		interrogación: \?
apóstrofe: \’	comillas: \”
flotantes : 0.1233, 1233.e-04
cadena de caracteres : encerrada entre comillas “abcde”
TIPOS FUNDAMENTALES DE DATOS
		char
unsigned 		shortpara representarvalores enteros
int
			long
			floatpara representar valores reales
			double
		long double
OPERACIONES SOBRE TIPOS
	sizeof : tamaño de
	new : asignar memoria del tipo
	delete : liberar memoria del tipo
	int main()
	{
		int *p = new int;
		cout << “tamaño de : ” << sizeof (p) << ‘\n’ ;
		delete(p);
	}
	
En C++ el nombre de tipo se emplea para la conversión
	explícita de un tipo a otro :
float f;
	char *p;
	// …
	long k = long(p); 	// convertir p a un long
	int l = int (f) ;		// convertir f a un int
TIPOS DERIVADOS
Por medio de los operadores de declaración se pueden
derivar otros tipos :
*	Puntero
&	Referencia
[]	Arreglo
()	Función
además podemos definir estructuras (registros) por medio de la palabra struct
	int *a ; 	// puntero a un entero
	float v[10]; //arreglo 10 posiciones para nros. reales
	char *p[20]; // arreglo de 20 punteros a caracteres
	void f(int);
	struct estr{ short longitud; char *p);
OPERADORES ARITMETICOS
		+ sumar 	* multiplicar		% residuo
		- restar		/ dividir
En C++ en las operaciones de asignación o aritméticas las conversiones entre los tipos básicos se realizan automáticamente, esto implica que los tipos se pueden mezclar libremente 
OPERADORES DE COMPARACION
	= = igual que	 < menor que		<= menor o igual que
	!= distinto de	 > mayor que	>= mayor o igual que
			
DECLARACIONES
Antes de que un nombre sea utilizado este debe haberse declarado y además debe haberse definido su tipo :
	char car;
	int cuenta = 1;
	char *nombre=”Juan”;
	struct complejo {float re, im};
	complejo varcom;
	extern complejo sqrt (complejo);
	extern int numero_error;
	const double pi=3.1415926535897932385;
	enum perro{Bulldog, Terrier, Pekines};
	struct usuario;
La mayor parte de estas declaraciones son también definiciones definen la entidad a la que se referirá el nombre
car, cuenta, nombre, varcom un lugar en la memoria con un valor asociado
	struct usuario					 no son definiciones
extern complejo sqrt (complejo); son declaraciones 
extern int numero_error;		 de nombres 
 
 las entidades a las que se refieren se definirán en otro lugar
	
ALCANCE
Una declaración tiene un alcance determinado un nombre se puede emplear en un determinado lugar del programa
locales : se emplean dentro de una función específica
globales : no pertenecen a una función, su alcance va
desde donde se declaró hasta el fin de archivo
La declaración de una variable local
OCULTA
a la de la variable global
int x;				// x global
	void f()
{
		int x;			// x local oculta a x global
		x = 1; 		// asignación a x local
		{
			int x;		// oculta a la primera x local
			x = 2;	// asignación a la segunda x local
		}
		x = 3;		// asignación a la primera x local
}
int *p = &x;		// toma la dirección de x global
En programas grandes la ocultación de nombres es inevitable
su uso debe evitarse por ser frecuente fuente de errores
Es posible emplear el nombre de una variable global
dentro del ámbito local ( operador alcance :: )
int x;
void f2()
{
		int x = 2;		// oculta a x global
		::x = 3;		// asigna el valor 3 a x global
}
No hay modo de utilizar un nombre local oculto
NOMBRES
· Identificador : secuencia de letras y dígitos
· 1er. caracter debe ser una letra
· subrayado bajo _ se considera una letra
· C++ no impone límite a los nombres pero las implementaciones si lo hacen (Borland C++ los 32 primeros son significativos)
· Se pueden admitir ASCII extendidos limitan la portabilidad
· Mayúsculas y minúsculas son distintas
Identificadores válidos :
 hola este_es_un_nombre_largo DEFINIDO
 fo0 bAr var0 var10 CLASS _class
Identificadores no_válidos :
	 012 un gato $sist class 3 var
	 num-cta dir~emp .nombre if
TIEMPO DE VIDA
(ámbito o visibilidad)
Un objeto se crea cuando se llega a su definición
Se destruye cuando se sale de su alcance (ámbito)
Los objetos globales se crean e inicializan una sola vez, se destruyen cuando el programa termina
	Cuatro posibilidades de visibilidad : 
· bloque
· función
· archivo		(static)
· programa		(extern)
Objetos definidos con la palabra clave static se crean una sola vez y se destruyen al final del programa. Se inicializan la primera vez que el programa pasa por la declaración
# include <iostream.h>
int a
void f()
{
	int b=1; 	// se inicializa cada vez que se llama a f
	static int c=a; // inicializado una sola vez
	cout << “ a = ” << a++ 
<< “ b = ” << b++
<< “ c = ” << c++ << ‘\n’ ;
	}
	int main()
{
	while (a<4) f();
	}
	Salida del programa :
		a = 1 b= 1 c=1
		a = 2 b= 1 c=2
		a = 3 b= 1 c=3
	
El programador puede controlar el tiempo de vida de los objetos que crea con los operadores new y delete
PUNTEROS
T : Tipo fundamental de datos
T* : puntero a un objeto del tipo T
int *pi;		// puntero a un entero
char **aac;	// puntero a un puntero de tipo char
Para arreglos y funciones se tiene :
int (*vp)[10]; 	// puntero a un arreglo de 10 enteros
int (*fp)(char, char *); // puntero a una función que
// recibe argumentos tipo char y char* y devuelve int
Operación indirección : hace referencia al objeto que apunta el puntero 
char c1 = ‘a’;
char *p = &c1; 	// p tiene la dirección de c1
char c2 = *p;		// a c2 se le asigna el valor ‘a’
Es posible realizar operaciones aritméticas con los punteros :
int strlen (char *p)	// calcula la longitud en caracteres
{				// de una cadena que termina en ‘\0’
	int i=0;		// sin contar el cero final
	while (*p++) i++;
	return i;
}
ARREGLOS
tipo T[tam] : especifica el arreglo de nombre T de tipo tipo
 de tamaño tam, indizado de 0 a tam-1
float v[3];	// arreglo de tres float, v[0], v[1] y v[2]
int a[2][5];	// matriz de enteros de 2 filas y 5 colum.
char* vpc[32];// arreglo punteros char 32 posiciones
Ejemplo :
#include <string.h>
char alfa[]=”abcdefghijklmnñopqrstuvwxyz”;
main()
{
	int tam=strlen(alfa);
	for (int i=0; i<tam; i++) {
		char car = alfa[i];
		cout << car <<” = “<< int(car) <<’\n”;
	}
}
Salida :
	a = 97
	b = 98
	c = 99
………………….
No hace falta especificar el tamaño del arreglo alfa. El compilador asigna como tamaño la cadena especificada. Es el único caso en que se puede emplear el operador de asignación para una cadena de caracteres.
	char v[10];
	v = “una cadena”; // error !!!!!!!!
	strcpy(v, “una cadena”);
Para inicializar arreglos de otro tipo se necesita otra notación
	int v1[] = {1, 2, 3, 4}
	int v2[] = {‘a’, ‘b’, ‘c’, ‘d’}
	char v3[]={1,2,3,4}
	char v4[]={‘a’, ‘b’, ‘c’, ‘d’}
v3 y v4 son arreglos caracteres de 4 elementos que no tienen la marca de fin de cadena posibilidad de cometer errores
PUNTEROS Y ARREGLOS
El nombre de un arreglo puntero al primer elemento
#include <string.h>
char alfa[]=”abcdefghijklmnñopqrstuvwxyz”;
main()
{
	char *p=alfa, car; // otra alternativa char *p=&alfa[0]
while(car = *p++)	
cout<<car<<” = “<< int(car) <<’\n”;
}
Cuando un arreglo se pasa como argumento a una función siempre se pasa por referencia (puntero al primer elemento del arreglo)
#include <string.h>
main()
{
	char v[]= “Alejandra”;
	char *p= v;
	strlen(p);	// en ambas llamadas se pasa el mismo valor
	strlen(v);// a strlen
}
Operaciones sobre punteros :
p apunta a un elemento del tipo T
p+1 apunta al siguiente elemento
p-1 apunta al elemento anterior
Resta de punteros permitida cuando se apunta a elementos del mismo arreglo = al nro. de elemento que existen entre los punteros. Se pueden sumar o restar valores enteros a un puntero si se sale de los límites resultado imprevisible
void f()
{
	int v1[10];
	int v2[10];
	int i=&v1[5]-&v1[3]; // resultado =2
	 i=&v1[5]-&v2[3]; // resultado imprevisible
	int *p= v2+2;		// p=&v2[2]
		p=v2-3;		//*p no definido
}
La mayoría de los compiladores C++ no chequean los límites de los arreglos.
ESTRUCTURAS
Arreglo : agregado de elementos del mismo tipo
Estructura Registro : agregadode elementos de tipo
struct domicilio{
	char *nombre;
	char *calle;
	long numero;
	char* ciudad;
	char estado[2];
	int cod_post;
}; // este es uno de los pocos lugares donde el usuario
 // además de la llave debe poner un punto y coma
Ahora se pueden declarar variables del tipo domicilio :
domicilio js; //constructor para estructuras
js.nombre= “Juan Samora”;
js.numero= 61;
También se puede declarar un arreglo de estructuras :
domicilio SantaFe[100];
SantaFe[1].nombre= “Alberto Sosa”;
Otro modo de inicializar una estructura es :
domicilio js = {
	“Juan Samora”;
	“Avenida de los Naranjos”, 61
	“Buenos Aires”,{‘N’, ‘L’},1021
};
Las estructuras se pueden asignar, pasar como argumento de función y devolver como resultado de función :
domicilio actual;
domicilio fijar_actual(domicilio siguiente)
{
	domicilio previo=actual;
	actual = siguiente;
	return previo;
}
Operaciones como igualdad o diferencia no están definidas, por lo tanto no se deben utilizar, si se puede definir una función que lo haga.
Tamaño de la estructura de la suma de los tipos individuales sizeof(domicilio)
El nombre de una estructura está disponible inmediatamente después de haberla declarado :
	struct lista_doble{
		int num;
		lista_doble* siguiente;
		lista_doble* previo;
	};
No es posible declarar un objeto de una estructura que no se ha definido completamente todavía :
	struct muestra{
muestra nueva;	 // error!! muestra no está 
}; 				 	 // totalmente definida todavía
Es posible reservar un nombre para que sea empleado más adelante :
	struct lista;
	struct nodo {
		nodo* next;
		nodo* previo;
		lista* nuevo;
	};
	struct lista {
		nodo *tope;
	};
Ahorro de espacio
Existen dos modos de exprimir (en el sentido de tratar de aprovechar al máximo) espacio en la memoria disponible :
· Campos : colocar un objeto pequeño en un byte
· Uniones : utilizar el mismo espacio para contener objetos diferentes en momentos distintos
Estos recursos no son portables, por lo tanto, se debe pensar bien antes de usarlos.
Campos
Cuando se quiere emplear una variable binaria (0-1, verdadero-falso) se emplea generalmente un char que ocupa un byte, pero se pueden reunir una o más unidades pequeñas como campos de una struct. Un campo de esta struct se especifica por medio del nombre seguido de la cantidad de bits que ocupa.
struct regest {
	unsigned habilitar :1;
	unsigned pagina : 3;
	unsigned : 1; // no se usa sirve para mejorar la 
 // disposición de bits
	unsigned modo : 2;
	unsigned : 4;
	unsigned acceso : 1;
	unsigned longitud : 1;
};
Los campos se emplean como cualquier otra variable entera, pero no es posible obtener su dirección. Emplear campos no siempre ahorra espacio, porque por lo general se incrementa el tamaño del código requerido para manejar variables. Se hace referencia a un campo de la siguiente forma:
struct regest reg1;
reg1.acceso = 0;
if (reg1.longitud == 0)....
Uniones
Supongamos una tabla de entrada que contiene nombre y valor, y el valor es una cadena de caracteres o un entero :
struct entrada {
	char* nombre;
	char tipo;
	char* valor_cadena;
	int	valor_entero;
}
void imprimir_entrada(entrada *p)
{
	switch(p->tipo) {
	case ‘c’:
		printf(“%s”, p->valor_cadena) ;
		break;
	case ‘e’:
		printf(“%d”, p->valor_entero) ;
		break;
	default :
		printf(“tipo corrompido\n”);
		break;
	}
}
Como no se puede emplear valor_cadena y valor_entero 
al mismo tiempo, se desperdiciará espacio, especificando que ambos son miembros de una unión se ahorra espacio :
struct entrada {
	char* nombre;
	char tipo;
	union {
		char* valor_cadena; // utilizado si tipo =’c’
		int valor_entero;	// utilizado si tipo = ‘e’
	};
};
El código que se escribió anteriormente sigue inalterado, al asignar un valor a una entrada, valor_entero y valor_cadena tienen la misma dirección los miembros de una unión ocupan el espacio requerido por el miembro más grande.
FUNCIONES Y ARCHIVOS
Por lo general, un programa está compuesto por varias unidades compiladas en forma independiente y que se encuentran en diferentes archivos. Esto facilita la legibilidad, modificación y/ o corrección del código.
Calificadores extern y static
A no ser que se especifique lo contrario un nombre que no es local respecto de una función o clase debe referirse al mismo tipo, valor, función u objeto en todas las partes de un programa compiladas individualmente un programa sólo puede existir un tipo, valor, función u objeto no local con ese nombre
// arch1.c
int a=1;
int f() {/* hacer algo */}
// arch2.c
extern int a;
int f();
void g() { a = f(); }
· La variable a y la función f() empleadas por g() en arch2.c son las que se definieron en arch1.c. 
· La palabra clave extern indica que la declaración de a en arch2.c es solo eso una declaración y no una definición.
· Si se hubiera inicializado a se habría ignorado la palabra extern porque una declaración con una inicialización es una definición.
Un objeto se debe definir una y solo una vez en un programa, se puede declarar muchas veces pero los tipos deben concordar con exactitud
// arch1.c
int a=1;
int b=1;
extern int c;
// arch2.c
 int a; 		// error !! a se define dos veces
extern double b; // error!! b se declara dos veces con tipos
 // diferentes
extern int c;	// error!! c se declara dos veces pero no se
// define 
Estos errores no los detecta el compilador (mira un archivo por vez), el ensamblador es el que lo hace
Con la declaración static es posible hacer que un
nombre sea local a un archivo
// arch1.c
static int a=6;
static int f() {/* …*/};
// arch2.c
static int a=7 ; 	
static int f() { /* …*} 
Cada archivo tiene su variable a y su función f()
ARCHIVOS DE ENCABEZADO
Los tipos de todas las declaraciones del mismo objeto o función deben ser consistentes. Un método para facilitar esto es la inclusión de archivos de encabezado que contienen código fuente y/o definiciones de datos.
Directiva include sirve para poner fragmentos de un programa en un solo archivo.
#include “archivo.cpp” se reemplaza esta línea por el 
 contenido de archivo.cpp 
 (archivo fuente con código C++)
#include <iostream.h> // búsqueda en el directorio estándar
#include “iostream.h” // búsqueda en el directorio actual
 CÓMO ORGANIZAR UN ARCHIVO DE ENCABEZADO
Definiciones de tipos		struct punto{int c,y;};
Patrones					template<class T> class V{…}
Declaraciones de funciones	extern int strlen (const char*);
Definiciones de funciones 
en línea					inline char obt(){return *p++;}
Declaraciones de datos		extern int a;
Definiciones de constantes	const float pi=3.141593;
Enumeraciones			enum bool {falso, verdadero};
Declaraciones de nombres	class Matriz;
Directivas de inclusión		#include <signal.h>
Comentarios				//comprobar si abrió el archivo
	
Un archivo de encabezado no debería incluir :
Definición de funciones ordinarias char obt(){return *p++;}
Definición de datos				 int a;
Por convención los archivos de encabezado llevan la extensión .h y los que tienen definiciones de funciones o datos llevan la extensión .c, .cpp, .cc, .cxx
FUNCIONES
Declaración 	- nombre de la función
- valor devuelto (si lo hay)
· tipo del/los argumento/s de llamada
extern double sqrt(double);
extern char* strcpy(char* a, const char* de);
extern void exit(int);
El compilador ignora los nombres de los argumentos que se ponen en la declaración
Paso de argumentos :
por valor : cuando se pasa el argumento se realiza
 una copia del mismo
	por referencia : la función emplea el argumento que
				 se está pasando
void f(int val, int &ref)
{	val++;
	ref++;
}
void g()
{	int i;
	int j;
	f(i,j); }
 Llamadas por referencia : 
· pueden dificultar la lectura del programa
· son útiles cuando se quieren pasar argumentos largos
· si se quiere evitar que la función modifique el valor se los puede pasar como argumento const
void f(const grande &arg)
{
	// no se puede alterar el valor de arg
	// sin emplear una conversión explícita de tipo
}
Arreglos como argumentos
Siempre se pasan por referencia no por valor.
El tamañono está disponible para la función de llamada. Si en la función de llamada necesitamos trabajar con las dimensiones del arreglo, se debe conocer la dimensión del mismo.
void imprimir_matriz34(int m[3][4])
{
	for (int i=0; i<3; i++) 
		for (int j=0; j<4; j++) 
			cout << ‘ ‘ << m[i] [j] << ‘\n’;
} // no hay problemas porque las dimensiones se conocen en 
 // tiempo de compilación
void imprimir_matriz34(int m[][4], int dim1)
{
	for (int i=0; i<dim1; i++) 
		for (int j=0; j<4; j++) 
			cout << ‘ ‘ << m[i] [j] << ‘\n’;
} // no hay problemas porque la 2da. dimensión se conoce en 
 // tiempo de compilación se puede calcular la ubicación
 // de un elemento
void imprimir_matriz34(int m[][], int dim1, int dim2) //error
{
	for (int i=0; i<dim1; i++) 
		for (int j=0; j<dim2; j++) 
			cout << ‘ ‘ << m[i] [j] << ‘\n’; 
} //PROBLEMAS porque las dimensiones NO SE CONOCEN 
 // en tiempo de compilación
Una posible solución para esto es :
void imprimir_matriz34(int** m, int dim1, int dim2)
{
	for (int i=0; i<dim1; i++) 
		for (int j=0; j<dim2; j++) 
			cout << ‘ ‘ << ((int*)m)[i*dim2+j] << ‘\n’;
} 
Nombres de función sobrecargados
Sobrecarga : mismo nombre de función para realizar tareas diferentes, generalmente manipulan objetos de distinto tipo
Ejemplo : solo hay un nombre para la suma, +, pero puede manipular objetos del tipo entero, punto flotante y punteros
void imprimir(int);			// para imprimir un entero
void imprimir(const char*)	// para imprimir una cadena de // caracteres
void imprimir(double);
void imprimir(long);
void f()
{
 imprimir(1L);	//imprimir(long)
 imprimir(1.0);	//imprimir(double)
 imprimir(1);	//imprimir(int)
}
El compilador determina la función que debe llamar de 
acuerdo con los argumentos de llamada a la misma. Para ello
determina las siguientes reglas de concordancia :
REGLAS DE CONCORDANCIA DE ARGUMENTOS
Desarrollos de Programación en C++
1) Concordancia exacta : verifica que los argumentos concuerden exactamente sin emplear conversiones o haciéndolo con sólo las inevitables (nombre de arreglo a puntero, nombre de funciónpuntero a función, T a const T)
2) Concordancia empleando promociones integrales : char a int, short a int y sus contrapartes unsigned, float a double.
3) Concordancia empleando conversiones estándar : int a double, derivado* a base*, unsigned int a int.
4) Concordancia empleando conversiones definidas por el usuario
5) Concordancia empleando … en declaración de la función
void imprimir(int);			
void imprimir(const char*)	
void imprimir(double);
void imprimir(long);
void imprimir(char);
void h(char c, int i, short s, float f)
{
	imprimir(c); // concordancia exacta
	imprimir(i); // concordancia exacta
	imprimir(s); // promoción integral imprimir(int)
	imprimir(f); // promoción integral imprimir(double)
	imprimir(‘a’); // concordancia exacta
	imprimir(49); // concordancia exacta
	imprimir(“a”); // concordancia exacta imprimir(const
 // char*) }
Argumentos por omisión
Se emplean cuando se necesitan más argumentos en el caso general que en el caso más simple que es el más frecuente
· Solo es posible incluir argumentos al final de la lista de argumentos
· Los argumentos que pueden omitirse deben tener su valor inicializado
· El argumento se fija en la llamada a la función
void imprimir(int valor, int base=10)
void f()
{
	imprimir(31);
	imprimir(31,10);
	imprimir(31,16);
	imprimir(31,2);
}
int f(int, int=0, char* =0);
int g(int = 0; int = 0; char*) // error!! se debe fijar un valor
// por omisión
Número no-especificado de argumentos
Se emplea cuando no es posible especificar el número y tipo de todos los argumentos de una llamada, se termina la declaración de una función de este tipo con …
int printf(const char* …) // printf debe tener al menos un
 //argumento que es una cadena de caracteres
printf(“Hola todo el mndo \n”);
printf(“Mi nombre es %s %s \n”, nombre, apellido);
printf(“%d + %d = %d \n”,2,3,5);
La sentencia :
printf (“Mi nombre es %s %s \n”, 2);
se compilará bien, pero tendrá una salida rara, en tiempo de compilación no es posible verificar los argumentos que tendrá.
Un programa bien diseñado no debería necesitar funciones de este tipo. Las funciones sobrecargadas y los argumentos por omisión hace que se tengan alternativas que haga que no sea necesario emplear este recurso
Punteros a funciones
Dos cosas se pueden hacer con una función : 
· llamarla 
· obtener su dirección
El puntero de una función puede servir para llamarla, pero se debe poner el operador indirección * encerrado entre paréntesis porque el operador llamada a función () tiene mayor precedencia que el indirección
void error (char*p) {…}
void (*pointf) (char); // puntero a función
void f()
{
	pointf = &error; // pointf apunta error
	(*pointf) (“error”) // llama a la función error 
}
si escribiéramos *pointf(“error”) *(pointf(“error”))
nos daría un error de tipo
Cuando se declara un puntero a una función se debe tener en cuenta los tipos de los argumentos. Debe haber una concordancia exacta.
void (*pf) (char*);
void f1(char*);
int f2(char*);
int f3(char*);
void f()
{
	pf = &f1;		// correcto
	pf = &f2;		// error!! tipo devuelto incorrecto
	pf = &f3		// error de tipo de argumento
	(*pf) (“asfd”); // correcto
	(*pf) (1);		// error de tipo de argumento
	int i=(*pf) (“qwer”); // error!! void asignado a int
}
SOBRECARGA DE OPERADORES
Tipos básicos definidas operaciones manejo fácil,
 cómodo, breve, convencional
Las clases nos permiten especificar objetos no primitivos además de un conjunto de operaciones que se pueden llevar a cabo con esos objetos
class complejo {
	double re, im;
public:
	complejo(double r, double i) { re=r; im=i; }
	friend complejo operator+(complejo, complejo);
	friend complejo operator*(complejo, complejo);
};
La definición de operator+ y operator* da al + y * un significado especial. Dados dos complejos a y b, a+b significa por definición operator+(a,b)
void f()
{
	complejo a = complejo(1,3.1)
	complejo b = complejo(1.2, 2)
	complejo c = a;
	a=b+c;
	b = b+c*a; c = a*b + complejo(1,2);
}
Valen las mismas reglas de precedencia que con cualquier otro operador.
Se pueden definir funciones para los siguientes operadores :
+	-	*	%	 ^	 & 	|	~	 !
=	<	>	+=	 -=	 *=	 /=	%=	 ^=
/=	<<	>>	>>=	 <<= ==	 !=	<=	 >=	 &&
||	++	--	->*	 ,	 ->	 []	 ()	new delete
No es posible :
· alterar el orden de precedencia
· no se puede modificar la sintaxis (ej.: no se puede utilizar un operador unario como binario o viceversa)
· no es posible definir nuevos operadores solo se pueden redefinir los que están
 
Una función operador es la que se define utilizando la palabra clave operator seguida del operador (ej.: operator<<). Se pueden invocar como cualquier otra función. Cuando se emplea el operador únicamente estamos empleando una abreviatura del operador.
void f(complejo a, complejo b)
{
	complejo c = a + b; 	// abreviado
	complejo d = operator+ (a,b) // llamada explícita
}
Operadores Binarios y Unarios
Para cualquier operador genérico @ tenemos :
si es binario puede ser implementado como una función miembro que recibe un argumento ó una función global que recibe dos argumentos
	aa@bb 		aa.operator@(bb)
			 	operator@(aa,bb)
si se definen ambas, la concordancia de argumentos le determinará que función le corresponde
si el operador es unario y prefijo @aa 		aa.operator@()
				 					operator@(aa)
si es posfijo : aa@		aa.operator@()	
operator@(aa)
class X{
	// miembros con apuntador this implícito
	X* operator&(); //&(dirección de) unario prefijo
	X operator&(X); //&(and) binario
	X operator++(int); // incremento posfijo
	X operator&(X,X); //error!! ternario
	X operator/();		 // error!! unario
 };
// funciones globales (con frecuencia amigas);
X* operator-(X); 	//- prefijo unario
X operator-(X,X); 	//- binario
X operator --(X&,int); 	// decremento posfijo
X operator-(); 		//error!! falta operando
X operator-(X,X,X);	// error!! ternarioAsignación e inicialización
struct cadena{
	char* p;
	int tamaño; // del vector que apunta p
	cadena(int tam) {p=new char[tamaño=tam];}
	~cadena(){delete p;}
};
Cadena puntero a vector de caracteres y tamaño vector
void f()
{
	cadena c1(10);
	cadena c2(20);
c1=c2; // problemas porque al salir de f se llama al 
//destructor de c1 y de c2, además 
}		// c1 tiene tamaño que c2
Redefiniendo el operador =
struct cadena {
	char* p;
	int tamaño;
	cadena(int tam) {p = new char[tamaño=tam];}
	~cadena() {delete p;}
	cadena & operator = (const cadena &);
};
cadena& cadena::operator=(const cadena& a)
{
	if (this != &a) { // tener en cuenta a=a
		delete p;
		p = new char[tamaño = a.tamaño];
		strcpy(p,a.p);
}
	return *this;
}
Con esto se mejora la situación anterior pero no se evita lo siguiente :
void f()
{
	cadena c1(10);
	cadena c2=c1; // inicialización no es asignación
}
El constructor construye una cadena pero destruye dos. El operador asignación no se aplica a un objeto no inicializado.
struct cadena {
	char* p;
	int tamaño;
	cadena(int tam) {p = new char[tamaño=tam];}
	~cadena() {delete p;}
	cadena & operator = (const cadena &);
	cadena(const cadena&); //constructor de copia
};
 cadena::cadena(const cadena& a)
{
	p = new char[tamaño = a.tamaño];
	strcpy(p,a.p);
}
Para un tipo X, el constructor de copia X(const X&) se ocupa de la inicialización con un objeto del mismo tipo X.
Un constructor debe poseer la máxima cantidad de funciones posibles :
class X{
//…
	X(algo);	// constructor de nuevos objetos
	X(const X&);	// constructor de copia
	operator=(const X&)	//asignación : limpieza y copia
	~X();		//destructor : limpieza
};
Subíndices
Una función operator[] sirve para asignar subíndices a objetos de clase, el segundo argumento (el subíndice de una función operator[], puede ser de cualquier tipo.
class asoc{
	struct pareja{
		char *nombre
		int val;
	};
	pareja* vec;
	int max;
	int libre;
	asoc(const asoc&);		// evitar la copia
	asoc& operator=(const asoc&); // evitar la copia
	public:
		asoc(int);
		int &operator[](const char*);
		void imprimir_todo();
};
asoc es un vector de objetos pareja de tamaño max. El constructor de copia y el operador de asignación se mantienen privados para evitar la copia de arreglos asoc.
asoc::asoc(int s)
{
	max = (s<16)?s:16;
	libre=0;
	vec=new pareja[max];
}
#include <string.h>
int& asoc::operator[](const char*p)
/* administrador de objetos del tipo “pareja” :
· buscar p
· devolver una referencia a la parte entera de pareja
· crear una nueva “pareja” si no se encuentra p
*/
{
	register pareja* pp;
	for (pp=&vec[libre-1]; vec<=pp; pp--)
		if strcmp(p,pp->nombre==0) return pp->val;
	if(libre==max) { // desborde amplair arreglo
		pareja* nvec= new pareja[max*2]
		for (int i=0; i<max; i++) nvec[i] = vec [i];
		delete vec;
		vec=nvec;
		max=2*max;
	}
	pp=&vec[libre++];
	pp->nombre=new char[strlen(p)+1]
	strcpy(pp->nombre,p);
	pp->val=0;	//valor inicial=0
	return pp->val;
}
Conversiones de tipo
Ejemplo de números complejos :
class complejo {
	double re,im
public:
	complejo(double r, double i) {re=r; im=i;}
	friend complejo operator+(complejo, complejo);
	friend complejo operator+(complejo, double);
	friend complejo operator+(double, complejo);
	friend complejo operator-(complejo, complejo);
	friend complejo operator-(complejo, double);
	friend complejo operator-(double, complejo);
	complejo operator-(); //unario
	friend complejo operator*(complejo, complejo);
	friend complejo operator*(complejo, double);
	friend complejo operator*(double, complejo);
}
void f()
{
	complejo a(1,1), b(2,2), c(3,3), d(4,4),e(5,5)
	a= -b-c;
	b=c*2.0*c;
	c=d+e*a;
}
Problema : tedioso escribir una función para combinación complejo – double
Solución : constructor que dado un double cree un complejo
class complejo {
	//…
	complejo(double r) {re r, im=0)
};
esto especifica como crear un complejo a partir de un double
Operadores incremento y decremento
Son los únicos en C++ que se pueden especificar tanto como operadores prefijos como postfijos 
class VerifyPointer{
	T* p;
	T* arreglo;
	int tamaño;
public:
// encadenar con arreglo ‘a’ de tamaño ‘t’ valor inicial ‘p’
	VerifyPointer(T* p, T* a, int T);
// encadenar con un solo objeto valor inicial ‘p’
	VerifyPointer(T* p);
	T* operator++(); 		// prefijo
	T* operator++(int);	//posfijo	
	T* operator--(); 		// prefijo
	T* operator--(int); 	//posfijo
	T& operator*();		//prefijo
}	
El argumento int sirve para indicar que la función debe llamar a la función posfija de ++. El argumento no se usa solo sirve para distinguir la implementación prefija de la posfija.
void f3(T a)
{
	T v[200];
	VerifyPointer p(&v[0],v,200)
	p.operator-(1);
	p.operator*()=a; //error ‘p’ fuera del intervalo
	p.operator++();
	p.operator*()=a; // correcto
}
Un excesivo empleo de la sobrecarga de operadores puede dar como resultado programas incomprensibles
Su uso debería limitarse para imitar el empleo convencional de los operadores, cuando esto no es posible, el empleo de llamadas a función es el mecanismo más adecuado
Desarrollos de Programación en C++
 
 
INTRODUCCION a C++
 
 
 
 
q
 
El Lenguaje de Programación C++ se diseñó para :
 
Ø
 
mejorar el lenguaje C
 
Ø
 
apoyar la abstracción de datos
 
Ø
 
apoyar la programación orientada a objetos
 
 
q
 
Un lenguaje apoya un estilo de programación cuando 
contiene elementos que facilitan la 
programación con esa 
técnica.
 
 
q
 
C++ es un superconjunto de C. C++ hereda de C lo 
siguiente: funciones, aritméticas, selección y 
construcciones cíclicas, operaciones de E/S, manejo de 
punteros
 
 
q
 
El mínimo programa en C++ es :
 
main () {}
 
 
al igual que en C, to
do programa en C++ debe tener una 
función main y el programa comienza ejecutando esa 
función 
 
 
 
 
 
 
 
 
Desarrollos de Programación en C++ 
 
INTRODUCCION a C++ 
 
 
 
 El Lenguaje de Programación C++ se diseñó para : 
 mejorar el lenguaje C 
 apoyar la abstracción de datos 
 apoyar la programación orientada a objetos 
 
 Un lenguaje apoya un estilo de programación cuando 
contiene elementos que facilitan la programación con esa 
técnica. 
 
 C++ es un superconjunto de C. C++ hereda de C lo 
siguiente: funciones, aritméticas, selección y 
construcciones cíclicas, operaciones de E/S, manejo de 
punteros 
 
 El mínimo programa en C++ es : 
main () {} 
 
al igual que en C, todo programa en C++ debe tener una 
función main y el programa comienza ejecutando esa 
función