REPUBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA EDUCACION

UNIVERSITARIA CIENCIA Y TECNOLOGIA
INSTITUTO UNIVERSITARIO DE TECNOLOGIA
DE ADMINISTRACION INDUSTRIAL
EXTENSION – MARACAY

Lenguaje de programación I

Autor:

Jhonatan González

C.I: 25891373

Maracay, Agosto de 2017

 Funciones
Una función es un conjunto de líneas de código que realizan una tarea específica y puede
retornar un valor. Las funciones pueden tomar parámetros que modifiquen su
funcionamiento. Las funciones son utilizadas para descomponer grandes problemas en
tareas simples y para implementar operaciones que son comúnmente utilizadas durante un
programa y de esta manera reducir la cantidad de código. Cuando una función es invocada
se le pasa el control a la misma, una vez que esta finalizó con su tarea el control es devuelto
al punto desde el cual la función fue llamada.
También Una función es un bloque de código que realiza alguna operación. Una función
puede definir opcionalmente parámetros de entrada que permiten a los llamadores pasar
argumentos a la función. Una función también puede devolver un valor como salida. Las
funciones son útiles para encapsular las operaciones comunes en un solo bloque
reutilizable, idealmente con un nombre que describa claramente lo que hace la función.
Ejemplo de funciones
Función siguiente acepta dos enteros de un llamador y devuelve su
suma; a y b son parámetros de tipo int.
int sum(int a, int b)
{
return a + b;
}

La función puede invocarse, o llamarse, desde cualquier número de partes del programa.
Los valores que se pasan a la función son los argumentos, cuyos tipos deben ser
compatibles con los tipos de parámetro de la definición de función.
int main()
{
int i = sum(10, 32);
int j = sum(i, 66);
cout << "The value of j is" << j << endl; // 108
}

Elementos de una declaración de función

Una declaración de función mínima consiste en el tipo de valor devuelto, el nombre de

función y la lista de parámetros (que puede estar vacía), junto con las palabras clave
opcionales que proporcionan instrucciones adicionales para el compilador. Una definición
de función se compone de una declaración más el cuerpo, que es todo el código incluido
entre llaves. Una declaración de función seguida de un punto y coma puede aparecer en
varios lugares de un programa. Debe aparecer antes de cualquier llamada a esa función en
cada unidad de traducción. La definición de función debe aparecer solo una vez en el
programa, según la regla de una definición (ODR).
Los elementos necesarios de una declaración de función son los siguientes:
1. El tipo de valor devuelto, que especifica el tipo del valor que devuelve la función, o
void si no se devuelve ningún valor. En C++11, auto es un tipo de valor devuelto
válido que indica al compilador que debe inferir el tipo de la instrucción return. En
C++14, también se permite decltype(auto). Para obtener más información, consulte
más adelante Deducción de tipos en tipos de valor devueltos.
2. El nombre de función, que debe comenzar con una letra o un carácter de subrayado
y no puede contener espacios. En general, un carácter de subrayado inicial en los
nombres de función de la biblioteca estándar indica funciones de miembro privado o
funciones no miembro que no están pensadas para que las use el código.
3. La lista de parámetros, que es un conjunto delimitado por llaves y separado por
comas de cero o más parámetros que especifican el tipo y, opcionalmente, un
nombre local mediante el cual se puede acceder a los valores de dentro del cuerpo
de la función.

Paso por valor

Consiste en hacer una copia del argumento, para que la función trabaje con la copia y no
con el argumento original.
Esto significa que si la función modificara el valor, el original no se alteraría ya que
estamos manejando una copia. Esto resulta bastante útil para asegurarnos de que la función
no modifique nuestros argumentos de manera accidental.
Pero surgen dos problemas:
1. Podríamos querer modificar el argumento original y no una copia.
2. Con mucha cantidad de variables (o estructuras como veremos) el paso por valor
(copiando) puede resultar un gasto excesivo de memoria.
Para resolver estos problemas contamos con las referencias y punteros, por el momento nos
ocuparemos de las referencias.
Una referencia a una variable es un "alias" de la variable. Para indicarle a C++ que estamos
hablando de una referencia y no una variable anteponemos al nombre el carácter
amparando (&).
Por ejemplo una referencia llamada refPresupuesto apuntando a un valor double se
escribiría así:
double &refPresupuesto

Si quisieramos que una función trabaje con la variable original y no con una copia
podríamos indicarle a la función que reciba el parametro como una referencia, veamos un
ejemplo:
//Paso por referencia
#include <iostream>
using std::cout;
using std::cin;
using std::endl;
void elevarCuadrado (int &); //prototipo de funcion que recibe una referencia a un int
int main()
{
int x = 0; //Declaracio e inicializacion en 0.
cout << "Ingrese x para elevarlo al cuadrado" << endl;
cin >> x;
cout << "antes de elevarse es " << x <<endl;
elevarCuadrado(x); //Notar que la llamada no es diferente a un paso por valor.
cout << "x despues de elevarse es " << x << endl;//muestra el valor modificado por la
funcion
return 0;
}
void elevarCuadrado (int &y ) //funcion que no devuelve nada (void) y recibe una
referencia a un int en este caso (x)
{
y = y*y; //La funcion no devuelve ningun valor, pero modifica el argumento original (x)
//ya que estamos trabajando con una referencia.
}

Paso de parámetros

En C++ todos los parámetros se pasan por valor, es decir, se hace una copia de los
parámetros cuando llamamos a la función. En la llamada, antes de hacer la copia, se
chequea que los parámetros actuales (los valores o variables especificados en la llamada)
son del mismo tipo que los parámetros formales (los que declaramos en la lista de
parámetros de la declaración de la función). Si los tipos son iguales o existe una conversión
implícita la llamada puede realizarse, si no son iguales deberemos realizar conversiones
explícitas.

Veamos un ejemplo de paso de parámetros:

#include <iostream.h>
void f (int val, int& ref) {
val++;
ref++;
}
main (){
int i=1;
int j=1;
f(i.j);
cout << "i vale " << i << " y j " << j << endl;
}
El resultado de ejecutar el programa será i vale 1 y j vale 2. Esto se debe a que cuando
pasamos el parámetro val, esperamos un entero y lo que recibe la función es una copia del
valor de i (1), al incrementar val en 1 modificamos la copia y la i queda igual. Sin embargo,
el segundo parámetro es una referencia (la dirección de una variable entera), y al llamar a la
función con j lo que se copia es su dirección, luego las modificaciones de ref se producen
en la posición en la que se encuentra j. Como se ve, podemos considerar que al poner un
parámetro de tipo referencia estamos realmente pasando el parámetro por referencia.

Punteros en C/C++

Un puntero es una variable que contiene la dirección de memoria de otra variable. Los
punteros permiten código más compacto y eficiente; utilizándolos en forma ordenada dan
gran flexibilidad a la programación.

La dirección de memoria de una variable se obtiene con el operador unario &. El operador
unario * permite la des referencia de un variable puntero; es decir, permite el acceso a lo
apuntado por un puntero.

Dado el ejemplo

int x = 1, y = 2;
int *ip; /* ip es un puntero a int */
ip = &x; /* ip apunta a x */
y = *ip; /* a y se le asigna lo apuntado por ip */
*ip = *ip + 3; /* incrementa lo apuntado por ip, x */
ip = NULL; /* ip apunta a direcc. especial (nada) */

La sintaxis de la declaración de un puntero imita a las expresiones en que la variable puede

utilizarse; cada puntero apunta a un tipo específico de datos (con la excepción del puntero
genérico void). La dirección especial NULL (o cero) indica que un puntero apunta a “nada”
y es usada como centinela para establecer el fin de estructuras auto referenciadas. Además,
esta es retornada por la función de asignación de memoria, malloc, en el caso de no haber
suficiente memoria. El operador new, en cambio, aborta el programa cuando no tiene más
memoria que dar.
Los arrays

Los arrays son usados extensamente por los programadores para contener listas de datos en
la memoria, por ejemplo, los datos almacenados en un disco suelen leerse y ponerse dentro
de un array con el objetivo de facilitar la manipulación de dichos datos, ya que los datos en
memoria pueden ser modificados, clasificados, marcados para su eliminación, etc. para
luego ser reescritos al disco. Otro ejemplo podría ser el de un menú de opciones que se
desplegarán dentro de una ventana para que el usuario pueda elegir una de éstas, en tales
casos y cuando las opciones son numerosas, solamente se ponen unas cuantas de ellas
dentro de la ventana pero se le da al usuario la oportunidad de poder subir y bajar a su
antojo para ver el resto de opciones que, aunque no se vean en la ventana, forman parte del
menú o array de opciones.
Array:
Un Array es un conjunto de datos del mismo tipo ordenados de forma lineal uno después de
otro. Los componentes de un Array se han de referenciar por medio del nombre del Array y
un índice de desplazamiento para indicar el componente deseado.

En C, C++ para declarar un array se emplea la sintaxis:

tipo identificador [tamaño] = { lista de inicialización } ;

donde,
 tipo se refiere al tipo de datos que contendrá el array. El tipo puede ser cualquiera
de los tipos estándar (char, int, float, etc.) o un tipo definido por el usuario. Es más,
el tipo del array puede ser de una estructura creada con: struct, union y class.
 identificador se refiere al nombre que le daremos al array.
 tamaño es opcional e indica el número de elementos que contendrá el array. Si un
array se declara sin tamaño, el mismo no podrá contener elemento alguno a menos
que en la declaración se emplee una lista de inicialización.
 lista de inicialización es opcional y se usa para establecer valores para cada uno de
los componentes del array. Si el array es declarado con un tamaño específico, el
número de valores inicializados no podrá ser mayor a dicho tamaño.

Ejemplos:
int intA[5];
long longA[5] = { 1, 2, 3, 4, 5 };
char charA[3] = { 'a', 'b', 'c' };

Definición de una estructura.

Una estructura es un tipo de dato compuesto que permite almacenar un conjunto de datos
de diferente tipo. Los datos que contiene una estructura pueden ser de tipo simple
(caracteres, números enteros o de coma flotante etc.) o a su vez de tipo compuesto
(vectores,estructuras,listas,etc.).

A cada uno de los datos o elementos almacenados dentro de una estructura se les
denomina miembros
de esa estructura y éstos pertenecerán a un tipo de dato determinado.

En esta declaración aclararemos que:

struct: es una palabra reservada de C que indica que los

elementos que vienen agrupados a continuación entre llaves
componen una estructura.
 nombre_estructura: identifica el tipo de dato que se describe y
del cual se podrán declarar variables. Se especifica entre
corchetes para indicar su opcionalidad.

miembro1, miembro2,...: Son los elementos que componen la

estructura de datos, deben ser precedidos por el tipo_dato al
cual pertenecen.

Recordemos que una estructura define un tipo de dato, no una variable, lo que significa que
no existe reserva de memoria cuando el compilador está analizando la estructura.
Posteriormente habrá que declarar variables del tipo definido por la estructura para poder
almacenar y manipular datos.

Ejemplo: estructura de una tarjeta bancaria, utilizando esta primera forma:

struct {
long_int num_tarjeta;
char tipo_cuenta;
char nombre [80];
float saldo;
} cliente1, cliente2;