1.

TIPOS DE FUNCIONES UTILIZADOS EN C/C++

IMERATIVAS

Función main( )

La función main( ), es la primera función que aparece dentro del programa C y C++ y dentro de ella se
presentan llamadas a otras funciones, con la finalidad de tener muchos pequeños procesos, antes de que un
gran proceso monolítico.

Una función es reconocida en un programa, puesto que se lleva entre paréntesis una lista de argumentos, los
cuales son la clave entre la comunicación de la funciones. Todo función, posee un cuerpo que esta encerrado
entre llaves (lo que para Pascal es begin - end ); cuando se encuentre al llave }, el control retorna a la función
que hizo la llamada.

La sentencia return permite devolver el valor de main ().

#include <iostream.h>
int main(void)
{
cout<<”Este programa devuelve un 0\n”;
return(0);
}

Funciones de entrada y salida

Las funciones de entrada y salida, tanto de la pantalla y teclado como de ficheros.

Función "getchar()"
Sintaxis:
int getchar(void);

"getchar" es una macro que devuelve el siguiente carácter del canal de entrada "stdin". Este macro está
definido como "getc(stdin)".
Valor de retorno, "getchar" devuelve el carácter leído, después de convertirlo a un "int" sin signo. Si lee un Fin-
de-fichero o hay un error, devuelve EOF.

Ejemplo:
do {
a = getchar();
} while (a != 'q');
.
Función "putchar()"
Sintaxis:
int putchar(int c);

"putchar(c)" es una macro definida como "putc(c, stdout)".

Valor de retorno, "putchar" devuelve el carácter c. Si hay un error, "putchar" devuelve EOF.
Ejemplo:
while(a = getchar()) putchar(a);

Función "gets()"
Sintaxis:
char *gets(char *s);

"gets" lee una cadena de caracteres terminada con un retorno de línea desde la entrada estándar y la almacena
en s. El carácter de retorno de línea es reemplazado con el carácter nulo en s.
Valor de retorno, "gets" devuelve la cadena s, si se encuentra el fin_de_fichero o se produce un error, devuelve
NULL.

Ejemplo:
char cad[80];
do {
gets(cad);
} while (cad[0] != '\000');
Función "puts()"
Sintaxis:
int puts(const char *s);

"puts" envía la cadena s terminada con nulo a la salida estándar "stdout" y le añade el carácter de retorno de
línea.
Valor de retorno, "puts" devuelve un valor mayor o igual a cero. En caso contrario devolverá el valor EOF.
Ejemplo:

char cad[80];
int i;
do {
gets(cad);
for(i = 0; cad[i]; i++)
if(cad[i] == ' ') cad[i] = '_';
puts(cad);
} while (cad[0] != '\000');

Función "printf()"
Sintaxis:
int printf(const char *formato[, argumento, ...]);

Escribe una cadena con formato a la salida estándar "stdout". Esta es probablemente una de las funciones más
complejas de C. Esta función acepta listas de parámetros con un número indefinido de elementos.
Valor de retorno el número de bytes de la cadena de salida. Si hay error se retornará con EOF.

Función “scanf()”
La función scanf(), posee un formato semejante a su inversa printf(), pero esta destinada a la entrada estándar
(teclado); siendo:

scanf(“Cadena de control ”,argumentos)

Funciones de Conversión
Nos permiten convertir cadenas de caracteres a números, números a cadenas de caracteres, números con
decimales a números enteros, etc.
Función "atoi()"
Convierte una cadena de caracteres a un entero.
Sintaxis:
int atoi(const char *s);

Función "max()"
Devuelve el mayor de dos valores.
Sintaxis:
<tipo> max(<tipo> t1, <tipo> t2 ); // sólo en C++
En C está definida como una macro y en C++ como un "formato", el resultado es el mismo, la función acepta
cualquier tipo, siempre y cuando se use el mismo tipo en ambos parámetros.

Función "min()"
Devuelve el menor de dos valores.
Sintaxis:
<tipo> min(<tipo> t1, <tipo> t2 ); // sólo en C++
En C está definida como una macro y en C++ como un "formato", el resultado es el mismo, la función acepta
cualquier tipo, siempre y cuando se use el mismo tipo en ambos parámetros.

Función "abs()"
Devuelve el valor absoluto de un entero.
Sintaxis:
int abs(int x);
"abs" devuelve el valor absoluto del valor entero de entrada, x. Si se llama a "abs" cuando se ha incluido la
librería "stdlib.h", se la trata como una macro que se expandirá. Si se quiere usar la función "abs" en lugar de su
macro, hay que incluir la línea:

Función "random()"
Generador de números aleatorios.
Sintaxis:
int random(int num);
"random" devuelve un número aleatorio entre 0 y (num-1). Se trata de una macro definida en "stdlib.h". Tanto
num como el número generado serán enteros. Valor de retorno, "random" devuelve un número entre 0 y (num-
1).

Función "toupper()"
Convierte un carácter a mayúscula.
Sintaxis:
int toupper(int ch);
"toupper" es una función que convierte el entero ch (dentro del rango EOF a 255) a su valor en mayúscula (A a
Z; si era una minúscula de, a a z). Todos los demás valores permanecerán sin cambios.
Valor de retorno, "toupper" devuelve el valor convertido si ch era una minúscula, en caso contrario devuelve ch.

Función "tolower()"
Convierte un carácter a mayúscula.
Sintaxis:
int tolower(int ch);
"tolower" es una función que convierte el entero ch (dentro del rango EOF a 255) a su valor en minúscula (A a
Z; si era una mayúscula de, a a z). Todos los demás valores permanecerán sin cambios.
Valor de retorno, "tolower" devuelve el valor convertido si ch era una mayúscula, en caso contrario devuelve
ch.

Funciones de manipulación de cadenas

En esta librería se incluyen rutinas de manipulación de cadenas de caracteres y de
memoria. De momento veremos sólo algunas de las que se refieren a cadenas.

Función "strlen()"
Calcula la longitud de una cadena.
Sintaxis:
size_t strlen(const char *s);
"strlen" calcula la longitud de la cadena s. Valor de retorno, "strlen" devuelve el número de caracteres que hay
en s, excluyendo el carácter nulo de terminación de cadena.

Función "strcpy()"
Copia una cadena en otra.
Sintaxis:
char *strcpy(char *dest, const char *orig);
Copia la cadena orig a dest, la copia de caracteres se detendrá cuando sea copiado el carácter nulo. Valor de
retorno, "strcpy" devuelve el puntero dest.

Función "strcmp()"
Compara dos cadenas.
Sintaxis:
int strcmp(char *cad1, const char *cad2);
Compara las dos cadenas, si la cad1 es mayor que cad2 el resultado será mayor de 0, si cad1 es menor que
cad2, el resultado será menor de 0, si son iguales, el resultado será 0. La comparación se realiza carácter a
carácter. Mientras los caracteres comparados sean iguales, se continúa con el siguiente carácter. Cuando se
encuentran caracteres distintos, aquél que tenga un código ASCII menor pertenecerá a la cadena menor. Por
supuesto, si las cadenas son iguales hasta que una de ellas se acaba, la más corta es la menor.

Función "strcat()"
Añade o concatena una cadena a otra.
Sintaxis:
char *strcat(char *dest, const char *orig);
"strcat" añade una copia de orig al final de dest. La longitud de la cadena resultante será strlen(dest) +
strlen(orig). Valor de retorno,"strcat" devuelve un puntero a la cadena concatenada.

Función "strncpy()"
Copia un determinado número de caracteres de una cadena en otra.
Sintaxis:
char *strncpy(char *dest, const char *orig, size_t maxlong);
Copia maxlong caracteres de la cadena orig a dest, si hay más caracteres se ignoran, si hay menos se rellenará
con caracteres nulos. La cadena dest no se terminará con nulo si la longitud de orig es maxlong o más. Valor de
retorno,"strncpy" devuelve el puntero dest.

Función "strncmp()"
Compara dos porciones de cadenas.
Sintaxis:
int strncmp(char *cad1, const char *cad2, size_t maxlong);
Compara las dos cadenas igual que strcmp, pero sólo se comparan los primeros maxlong caracteres.

Función "strncat()"
Añade o concatena una porción de una cadena a otra.
Sintaxis:
char *strncat(char *dest, const char *orig, size_t maxlong);
"strncat" añade como máximo maxlong caracteres de la cadena orig al final de dest, y después añade el
carácter nulo. La longitud de la cadena resultante será strlen(dest) + maxlong. Valor de retorno, "strncat"
devuelve un puntero a la cadena concatenada.

Función "strtok()"
Busca dentro de una cadena conjuntos de caracteres o símbolos (tokens) separados por
delimitadores.
Sintaxis:
char *strtok(char *s1, const char *s2);
"strtok" considera la cadena s1 como una lista de símbolos separados por delimitadores de la forma de s2. La
primera llamada a "strtok" devuelve un puntero al primer caracter del primer símbolo de s1 e inserta un carácter
nulo a continuación del símbolo retornado. Las siguientes llamadas, especificando null como primer argumento,
siguen dando símbolos hasta que no quede ninguno. El separador, s2, puede ser diferente para cada llamada.
Valor de retorno,"strtok" devuelve un puntero al símbolo extraido, o NULL cuando no quedan símbolos.

FUNCIONES RECURSIVAS

Al igual que C, el lenguaje C++ soporta recursivas. Una función es recursiva si puede llamarse a si misma.
Ejemplo:

El programa recuruno muestra el uso de la recursividad para contar de 1 a 10.

//recuruno.cpp
#include <iostream.h>

void contar (int tope)

main()
{
contar(10);
}
void contar(int tope)
{
if (tope = 0 ) {
cout<<tope<<”\y”;
contar(tope-1); }
}

La sentencia if comprueba el valor del parámetro tope,. Si ese valor es mayor que 0, la sentencia llama a
contar, la misma función que esta ejecutando. En esta llamada, el programa pasa por la función de resultado de
la expresión tope -1.
Las llamadas recursivas terminan cuando se cumplen cuando se cumple la condición de salida (tope >1).

FUNCIONES EN LINEA

A menudo nos encontraremos con funciones miembro cuyas definiciones son muy pequeñas. En estos casos
suele ser interesante declararlas como inline. Cuando hacemos eso, el código generado para la función cuando
el programa se compila, se inserta en el punto donde se invoca a la función, en lugar de hacerlo en otro lugar y
hacer una llamada.
Esto nos proporciona una ventaja, el código de estas funciones se ejecuta más rápidamente, ya que se evita
usar la pila para pasar parámetros y se evitan las instrucciones de salto y retorno. También tiene un
inconveniente: se generará el código de la función tantas veces como ésta se use, con lo que el programa
ejecutable final puede ser mucho más grande en ciertas ocasiones. Es por esos dos motivos por los que sólo se
usan funciones inline cuando las funciones son pequeñas. Hay que elegir con cuidado qué funciones
declararemos inline y cuales no, ya que el resultado puede ser muy diferente dependiendo de nuestras
decisiones.
Hay dos maneras de declarar una función como inline. La primera ya la hemos visto. Las funciones que se
definen dentro de la declaración de la clase son inline implícitamente.
Por ejemplo:
class Ejemplo {
public:
Ejemplo(int a = 0) { A = a;}
private:
int A;
};
En éste ejemplo hemos definido el constructor de la clase Ejemplo dentro de la propia declaración, esto hace
que se considere como inline. Cada vez que declaremos un objeto de la clase Ejemplo se insertará el código
correspondiente a su constructor. Si queremos que la clase Ejemplo no tenga un constructor inline deberemos
declararla y definirla así:
class Ejemplo {
public:
Ejemplo(int a = 0);
private:
int A;
};
Ejemplo::Ejemplo(int a)
{
A = a;
}
En este caso, cada vez que declaremos un objeto de la clase Ejemplo se hará una llamada al constructor y sólo
existirá una copia del código del constructor en nuestro programa. La otra forma de declarar funciones inline es
hacerlo explícitamente, usando la palabra reservada inline. En el ejemplo anterior sería así:
class Ejemplo {
public:
Ejemplo(int a = 0);
private:
int A;
};
inline Ejemplo::Ejemplo(int a)
{
A = a;
}

FUNCIONES MIEMBRO CONSTANTES

Esta es una propiedad que nos será muy útil en la depuración de nuestras clases. Cuando una función miembro
no modifique el valor de ningún dato de la clase, podemos y debemos declararla como constante. Esto no
evitará que la función modifique los datos del objeto, el código de la función lo escribimos nosotros, pero
generará un error durante la compilación si la función intenta modificar alguno de los datos miembro del objeto.

Por ejemplo:
#include <iostream.h>
#include <stdlib.h>
class Ejemplo2 {
public:
Ejemplo2(int a = 0) {A = a; }
void Modifica(int a) { A = a; }
int Lee() const { return A; }
private:
int A;
};
int main()
{
Ejemplo2 X(6);
cout << X.Lee() << endl;
X.Modifica(2);
cout << X.Lee() << endl;
system("PAUSE");
return 0;
}

Para experimentar, comprueba lo que pasa si cambias la definición de la función "Lee()" por estas otras:

int Lee() const { A++; return A; }

int Lee() const { Modifica(A+1); return A; }
int Lee() const { Modifica(3); return A; }

2. TIPOS DE ARGUMENTOS QUE SE PUEDEN DEFINIR EN LAS FUNCIONES

Argumentos por defecto de parámetros de una función

En ANSI C se espera encontrar una correspondencia biunívoca entre la lista de argumentos actuales (llamada)
y la lista de argumentos formales (declaración y definición) de una función. Por ejemplo, supóngase la siguiente
declaración de una función para calcular el módulo de un vector x con n elementos: double modulo(double x[],
int n);
En C esta función tiene que ser necesariamente llamada con dos argumentos actuales que se corresponden
con los dos argumentos formales de la declaración.

En C++ la situación es diferente pues se pueden definir valores por defecto para todos o algunos de los
argumentos formales. Después, en la llamada, en el caso de que algún argumento esté ausente de la lista de
argumentos actuales, se toma el valor asignado por defecto a ese argumento. Por ejemplo, la función modulo()
podía haberse declarado del siguiente modo:
double modulo(double x[], int n=3);

La función modulo() puede ser llamada en C++ de las formas siguientes:

v = modulo(x, n);
v = modulo(x);

En el segundo caso se utiliza el valor por defecto n=3 incluido en la declaración. En C++ se exige que todos los
argumentos con valores por defecto estén al final de la lista de argumentos. En la llamada a la función pueden
omitirse alguno o algunos de los últimos argumentos de la lista. Si se omite un argumento deben de omitirse
todos aquellos que se encuentren detrás suyo.

El modificador const
Se puede preceder a un tipo de argumento con el modificador const para indicar que este argumento no puede
ser modificado. Al objeto al cual se aplica no sepuede asignar un valor o modificador de ningun modo.

#include <iostream.h>
void func_1(const int i); // modificador const
main (void)
{
int i=1;
func_1(i); // pasa i como un argumento ral
}

void func_1(const int 1)

{
cout<<”i es”<< i << “\n”;
}

Al compilar y ejecutar este programa se obtiene la siguiente salida:

i es 1

Modifiquemos ahora el programa cambiando el valor de i.

#include <iostream.h>
void func_1(const int i); // argumento de tipo const
main (void)
{
int i=1;
func_1(i); // pasa i como un argumento real
}

void func_1(const int 1)

{
i++;
cout<<”i es”<< i << “\n”;
}

La compilación de este programa produce un error: Este error se produce al intentar cambiar el valor del
argumento que se especifica como tipo const.

El modificador volatile

El modificador volatile se puede utilizar para indicar que los argumentos formales pueden ser modificados en la
ejecución del programa, bien por el propio programador, por hardware o por el propio sistema. Típicamente las
variables volátiles se necesitan solo para valores que pueden ser modificados por una rutina de interrupción que
opera independientemente del programa. La declaración de una variable volátil es:
volatile int k;

aunque es raro su us, se pueden tambien declarar parametros volatiles. Por Ejemplo:

#include<iostream.h>
void func_1(volatile int i);
main (void)
{
int i=1;
finc_1(i);
}
void func_1(volatile int i)
{
i++;
cout<<"i es"<<i<<"\n";
}

La salida del programa es: i es 2

El prototipo de una funcion similar a

void Funvolatile(volatile int par);

Garantiza que el parametro par nunca se optimiza o situa en un registro. Esto es importante cuando un seceso
externo, tal como una interrupcion, modifica par, que se debe elamacenar por consiguiente en memoria, no en
un registros desconocido para la rutina de interrupciones.

Argumentos de tipo referencia

A continuación se va a recordar brevemente cómo se pasaban argumentos por referencia en ANSI
C. Para ello se va a utilizar la función permutar():
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
int i = 1, j = 2;
void permutar(int *a, int *b);
printf("\ni = %d, j = %d", i, j);
permutar(&i, &j);
printf("\ni = %d, j = %d", i, j);
}
void permutar(int *a, int *b)
{
int temp;
temp = *a;
*a = *b;
*b = temp;
}
La clave para pasar argumentos o parámetros por referencia en C está en el uso de punteros. Al pasar la
dirección de la variable9, ésta es accesible desde dentro de la función y su valor puede ser modificado. De
modo análogo, si dentro de una función hay que modificar un puntero habrá que pasar su dirección como
argumento, esto es, habrá que pasar un puntero a puntero. C++ ofrece una nueva forma de pasar argumentos
por referencia a una función, que no obliga a utilizar -dentro de la función- el operador indirección (*) para
acceder al valor de la variable que se quiere modificar. Esto se hace por medio de un nuevo tipo de dato -que
no existe en C- llamado tipo referencia (reference).

Las variables referencia se declaran por medio del carácter (&)10. Por lo demás, son variables normales que
contienen un valor numérico o alfanumérico. Antes de pasar a explicarlas con más detenimiento, se presenta de
nuevo el ejemplo de la función permutar() utilizando variables referencia en lugar de punteros.
// Este programa requiere compilador de C++
#include <stdio.h>
#include <stdlib.h>
void main(void)
{
int i = 1, j = 2;
void permutar(int &a, int &b); // los argumentos son referencias
printf("\ni = %d, j = %d", i, j);
permutar(i, j); // los argumentos no llevan (*) ni (&)
printf("\ni = %d, j = %d", i, j);
}
void permutar(int &a, int &b) // los argumentos son referencias
{
int temp;
temp = a; // no hace falta utilizar
a = b; // el operador indirección (*)
b = temp;
}

Los dos programas dan idéntico resultado, sin embargo, el segundo tiene la ventaja de que no hay que utilizar
el operador indirección dentro de la función permutar(). C++ permite pasar
argumentos por referencia sin más que anteponer el carácter (&) a los argumentos correspondientes, tanto en
el prototipo como en el encabezamiento de la definición. En la llamada a la función los argumentos se ponen
directamente, sin anteponerles ningún carácter u operador. En C++ existe realmente un tipo llamado referencia
que va más allá del paso de argumentos a funciones tal y como se acaba de explicar. Las variables de tipo
referencia se declaran con el operador (&) y deben ser inicializadas a otra variable o a un valor numérico. Por
ejemplo:
int i=2;
int& iref = i; // declaración de referencia válida
int& jref; // declaración de referencia no válida
La variable i es una variable normal tipo int. La variable iref es una variable referencia que se
asocia con i, en el sentido de que ambas variables comparten la misma posición de memoria: si se modifica i
se modifica iref, y viceversa. En este sentido, iref es un alias de i. La diferencia con un puntero que apuntase a
la dirección de i está en que, una vez que una variable referencia ha sido declarada como alias de i no puede
ser declarada como alias de otra variable. Siempre se referirá a la misma posición de memoria. Es como un
puntero a una posición de memoria fija. En la función permutar() los argumentos formales, que son
referencias, se inicializan y se convierten en alias de los argumentos actuales, que son variables ordinarias.
El principal uso de las variables referencia es como valor de retorno o argumentos de funciones. Los vectores y
matrices (arrays) no pueden ser declarados como variables referencia, porque ya tienen una forma propia y
natural de ser pasados como argumentos a una función. El que una función tenga como valor de retorno una
variable tipo referencia permite utilizarla de una manera un poco singular. Considérese el siguiente ejemplo:
int& maxref(int& a, int& b)
{
if (a >= b)
return a;
else
return b;
}
La función maxref() tiene referencias como valor de retorno y como argumentos. Esto permite utilizarla, por
ejemplo, del siguiente modo: maxref(i, j) = 0;
Ésta es una forma un poco extraña de utilizar una función: la llamada está a la izquierda del operador de
asignación, en vez de aparecer a la derecha en una expresión aritmética o de otro tipo. El resultado de esta
llamada también es un poco extraño: el valor de retorno es una referencia, esto es un alias del argumento de
valor máximo. Cuando la llamada a la función se sustituye por su valor de retorno, el resultado de la sentencia
anterior es que la variable pasada como argumento que tiene mayor valor se hace igual a cero. Este mismo
efecto puede conseguirse mediante punteros, pero con referencias resulta mucho más sencillo.
En C++ las referencias son muy utilizadas para pasar argumentos a funciones (y como
valores de retorno), no sólo para poderlos modificar dentro de la función, sino también por motivos de eficiencia,
pues es mucho más rápido pasar un puntero o un alias de una variable que una copia del valor de esa variable.
Si además la variable es una estructura, las ventajas de eficiencia son todavía mucho más palpables.

BIBLIOGRAFIA
- C++ A SU ALCANCE Luis Joyanes Aguilar
- TURBO C++ 3.0 E. Raffo Lecca
- CURSO DE C++ Salvador Poso Colorado