Leccion Punteros Cadenas

MIGUEL Á. TOLEDO MARTÍNEZ

APUNTADORES Y CADENA – LECCIÓN 20 20-1

CONTENIDO DE LA LECCIÓN 20

APUNTADORES Y CADENAS 1. Introducción 3 2. Declaración e iniciación de variables de apuntador 37 3. Operadores de los apuntadores 4

3.1. Ejemplo 20.1 6 4. Llamado de funciones por referencia 6

4.1. Ejemplo 20.2 7 5. Empleo del calificador const con apuntadores 10

5.1. Ejemplo 2 20.3, 20.4, 20.5, 20.6, 20.7 11 6. Ordenamiento de burbuja mediante llamada por referencia 15

6.1. Ejemplos 20.8, 20.9, 20.10 15 7. Expresiones de apuntadores y aritmética de apuntadores 18 8. Relación entre apuntadores y arreglos 21

8.1. Ejemplos 20.11, 20.12 22 9. Arreglos de apuntadores 24 10. Caso de estudio: Simulación de barajado y repartición de naipes 25

10.1. Ejemplo 20.13 28 11. Apuntadores y funciones 29

11.1. Ejemplos 20.14, 20.15 29 12. Introducción al procesamiento de caracteres y cadenas 33

12.1. Fundamentos de los caracteres y las cadenas 33 12.2. Funciones de manipulación de cadenas de la biblioteca de manejo de cadenas 34

12.2.1. Ejemplo 20.16, 20.17, 20.18, 20.19, 20.20 36 12.3. Ejercicios resueltos 40 12.4. Funciones de cadena que utilizan cadenas ubicadas fuera de los 64 kb (far string) 47 12.5. Número de ocurrencias de un carácter dentro de una cadena 47 12.6. Contar el número de ocurrencia de una subcadena dentro de una cadena 53 12.7. Obtener un índice a una subcadena 54 12.8. Obtener la ocurrencia mas a la derecha de una subcadena 54 12.9. Remover una subcadena contenida dentro de una cadena 54 12.10. Reemplazo de una subcadena por otra 55 12.11. Determinar si un carácter es alfanumérico 56 12.12. Determinar si un carácter es una letra del alfabeto 56 12.13. Determinar si un carácter contiene un valor ASCII 56 12.14. Determinar si un carácter es un carácter de control 56 12.15. Determinar si un carácter es un digito 56 12.16. Determinar si un carácter es un carácter gráfico 57 12.17. Determinar si un carácter es mayúscula o minúscula 57 12.18. Determinar si un carácter es imprimible 57 12.19. Determinar si un carácter es un símbolo de puntuación 57 12.20. Determinar si un carácter es el carácter espacio 58 12.21. Determinar si un carácter es un valor hexadecimal 58 12.22. Carácter ASCII válido 59

13. Pensando en objetos: Iteraciones entre los objetos 64 14. Errores comunes de programación 65 15. Buenas prácticas de programación 66 16. Propuestas de desempeño 67



17. Sugerencias de portabilidad 67 18. Observaciones de Ingeniería de Software 67 19. Indicaciones de prueba y depuración 67 20. Lo que necesita saber 68 21. Preguntas y problemas 70

21.1. Preguntas 70 21.2. Problemas 73

21.2.1. Sección especial: construya su propia computadora 75 21.2.2. Más problemas de apuntadores 79 21.2.3. Problemas de manipulación de cadenas 84 21.2.4. Sección especial: manipulación avanzada de cadenas 85 21.2.5. Interesante proyecto de manipulación de cadenas 88



LECCIÓN 20

APUNTADORES Y CADENAS INTRODUCCIÓN En esta lección se estudiará una de las características más poderosas del lenguaje de programación C++: el apuntador. Los apuntadores son una de las capacidades de C++ más difíciles de dominar. En otra lección vimos que las referencias pueden servir para hacer llamadas por referencia. Los apuntadores permiten a los programas simular la llamada por referencia y crear y manipular estructuras dinámicas de datos, es decir, estructuras de datos que pueden crecer y encogerse, como las listas vinculadas, colas, pilas y árboles. Esta lección explica los conceptos básicos acerca de los apuntadores. También refuerza la relación íntima entre los arreglos, los apuntadores y las cadenas e incluye un amplio conjunto de ejemplos de procesamiento de cadenas. En otro semestre se estudiarán el empleo de los apuntadores con estructuras. La programación orientada a objetos se efectúa con apuntadores y referencias. En ese semestre se presentan técnicas de administración dinámica de memoria y ejemplos de creación y uso de estructuras dinámicas de datos. El enfoque de los arreglos y cadenas como apuntadores se deriva de C. En la especialidad de computación se estudiarán los arreglos y las cadenas como objetos en toda forma.

Los objetivos de esta lección son: •••• Aprender a utilizar los apuntadores. •••• Emplear los apuntadores para pasar argumentos a las funciones mediante llamada por referencia. •••• Entender la estrecha relación entre los apuntadores, los arreglos y las cadenas. •••• Comprender la utilidad de los apuntadores a funciones. •••• Declarar y utilizar arreglos de cadenas. •••• Asignar caracteres a una cadena de caracteres. •••• Comprender la importancia del carácter NULL. •••• Inicializar cadena de caracteres. •••• Pasar cadena de caracteres a una función. •••• Utilizar las funciones de las librerías en tiempo de ejecución para manejar cadenas de caracteres.

DECLARACIÓN E INICIACIÓN DE VARIABLES DE APUNTADOR Las variables de apuntador contienen direcciones de memoria como sus valores. Normalmente las variables contienen valores específicos. Por otra parte, los apuntadores contienen direcciones de variables que contienen valores específicos. En este sentido, los nombres de variables hacen referencia directa a un valor y los apuntadores hacen referencia indirecta a un valor (figura 20.1) La referencia a un valor a través de un apuntador se llama indirección.



contador contador hace referencia directa a una variable cuyo valor es 7

contadorPtr contador

contadorPtr hace referencia indirecta a una variable cuyo valor es 7.

Figura 20.1. Referencias directa e indirecta a una variable

Los apuntadores, como cualquier otra variable, se deben declarar antes de utilizarlos. La declaración:

int *contadorPtr, contador;

declara la variable contadorPtr como de tipo int * (es decir, como un apuntador a un valor entero) y se lee contadorPtr es un apuntador a int o contadorPtr apunta a un objeto de clase entero. Además, la variable contador se declara como entero, no como apuntador a un entero. En esta declaración, el * solamente se aplica a contadorPtr. Cada variable que se declara como apuntador debe ir precedida por un asterisco (*) Por ejemplo, la declaración:

float *xPtr, *yPtr;

indica que tanto xPtr como yPtr son apuntadores a valores float. El uso de * en una declaración de esta manera indica que la variable que se está declarando es un apuntador. Los apuntadores pueden declararse para que apunten a objetos de cualquier clase de datos. Los apuntadores se deben inicializar, ya sea al declararlos o mediante una instrucción de asignación. Un apuntador puede inicializarse a 0, a NULL o a una dirección. Un apuntador con el valor 0 o NULL no apunta a nada. NULL es una constante simbólica definida en el archivo de encabezado <iostream.h> (y en varios archivos de encabezado de la biblioteca estándar) La iniciación a NULL de un apuntador es equivalente a inicializarlo a 0, pero en C++ se prefiere 0. Cuando se asigna 0, se convierte en un apuntador del tipo adecuado. El valor 0 es el único valor entero que puede asignarse directamente a una variable de apuntador sin convertir primero mediante cast el entero a un tipo de apuntador. En la siguiente sección se estudia la asignación de la dirección de una variable a un apuntador. OPERADORES DE LOS APUNTADORES El &, u operador de dirección, es un aperador unario que devuelve la dirección de su operando. Por ejemplo, suponiendo las declaraciones:

int y = 5; int *yPtr;

la instrucción yPtr = &y;

7

•

7



asigna la dirección de la variable y a la variable de apuntador yPtr. Se dice entonces que la variable yPtr apunta a y. La figura 20.2 muestra una representación esquemática de la memoria tras la ejecución de la asignación previa. En la figura mostramos la relación de apuntador dibujando una flecha del apuntador hacia el objeto al que apunta. y yPtr

Figura 20.2. Representación gráfica de un apuntador que apunta a una variable entera en la memoria

La figura 20.3 muestra la representación del apuntador en la memoria, suponiendo que la variable entera y está almacenada en la localidad 600000 y que la variable de apuntador yPtr está almacenada en la localidad 500000. El operando del operador de dirección debe ser un lvalue (left value) (es decir, algo a lo que puede asignarse un valor, como un nombre de variable); el operador de dirección no puede aplicarse a constantes, a expresiones que no den como resultado referencias, ni a variables declaradas con la clase de almacenamiento register.

yPtr y El operador *, conocido comúnmente como operador de indirección u operador de

desreferenciación, devuelve un sinónimo, alias o apodo del objeto hacia el que apunta su operando (es decir, su apuntador) Por ejemplo (haciendo referencia a la figura 20.2), la instrucción:

cout << *yPtr << endl;

imprime el valor de la variable y, es decir 5, de la misma manera que lo haría la instrucción:

cout << y << endl; El empleo de * de esta manera se conoce como desreferenciación de un apuntador. Observe que también puede utilizarse un apuntador desreferenciado del lado izquierdo de una instrucción de asignación, como:

*yPtr = 9;

que asignará 9 a y en la figura 20.3. El apuntador desreferenciado también podría usarse para recibir un valor de entrada como en el caso de:

cin >> *yPtr;

El apuntador desreferenciado es un lvalue, o valor izquierdo.

5

•

600000 500000 5 600000



Ejemplo 20.1

El programa siguiente: APUNTADOR1.CPP, muestra los operadores de los apuntadores. En este ejemplo, las localidades de memoria se envían a la salida como enteros hexadecimales. Observe que la dirección de a y el valor de aPtr son idénticos en la salida, lo que confirma que la dirección de a efectivamente está asignada a la variable de apuntador aPtr. Los operadores & y * son inversos entre ellos –cuando se aplican ambos consecutivamente a aPtr en cualquier orden, se imprime el mismo resultado.

LLAMADO DE FUNCIONES POR REFERENCIA En C++ hay tres maneras de pasarle argumentos a una función: mediante llamada por valor, mediante llamada por referencia con argumentos de referencia y mediante llamada por referencia con argumentos de apuntador. En lección anterior comparamos e hicimos la distinción entre llamada por valor y llamada por referencia con argumentos de referencia. En esta lección nos concentraremos en la llamada por referencia con argumentos de apuntador. Como antes hemos visto, return puede utilizarse para devolverle al invocador un valor desde una función llamada (o regresar el control desde una función llamada sin devolver un valor) También vimos que se le pueden pasar argumentos a una función mediante argumentos de referencia, permitiendo que la función modifique los valores originales de los argumentos (por lo tanto, se puede devolver más de un valor desde una función), o pasar objetos de datos grandes a una función y evitar la sobrecarga de pasar los objetos mediante llamada por valor (que, claro está, involucra llevar a cabo una copia del objeto) Los apuntadores, como las referencias, también pueden servir para modificar una o más variables del invocador o para pasar apuntadores a objetos de datos grandes, evitando la sobrecarga de pasar los objetos mediante llamada por valor.

/* El siguiente programa: APUNTADOR1.CPP, muestra el empleo de los operadores & y * */ #include <iostream.h> //Para cout y cin void main(void) { int a; //a es un entero int *aPtr; //aPtr es un apuntador a un entero a = 7; aPtr = &a; //aPtr se establece a la dirección de a cout << "La dirección de a es: " << &a << "\nEl valor de aPtr es: " << aPtr; cout << "\n\nEl valor de a es: " << a << "\nEl valor de *Ptr es: " << *aPtr; cout << "\n\nMostrando que * y & son inversos " << "entre sí. \n&*aPtr = " << &*aPtr << "\n*&aPtr = " << *&aPtr << endl; }//Fin de main()



En C++, los programadores se pueden valer de los apuntadores y del operador de indirección para simular llamadas por referencia (de la misma manera que se logran las llamadas por referencia en C) Al llamar una función con argumentos que deben ser modificados, se pasa la dirección de los argumentos. Por lo general, esto se logra aplicándole el operador de dirección (&) al nombre de la variable que se habrá de modificar. Como hemos visto, los arreglos no se pasan mediante el operador &, pues el nombre de éstos es la localidad inicial del mismo en memoria (el nombre del arreglo es equivalente a &nombreArreglo[0], es decir, un nombre de arreglo ya es un apuntador. Cuando se pasa la dirección de una variable a una función, se puede emplear el operador de indirección (*) en la función, creando un sinónimo, alias o apodo del nombre de la variable –con éste, a su vez, es posible modificar el valor de la localidad de memoria del invocador (si la variable no está declarada como const) Ejemplo 20.2

Los dos programas siguientes: CUBO1.CPP y CUBO2.CPP, son dos versiones de una función que eleva al cubo un entero: cuboValor() y cuboReferencia() CUBO1.CPP, pasa la variable numero a la función cuboValor() mediante una llamada por valor. La función cuboReferencia() eleva al cubo su argumento y le devuelve el valor a main() mediante una instrucción return. El nuevo valor se asigna a numero en main() Existe la oportunidad de examinar el resultado de la llamada de función antes de modificar el valor de una variable. Por ejemplo, en este programa se podría haber almacenado el resultado de cuboValor() en otra variable, examinando su valor y asignando el resultado a numero tras comprobar que el resultado es razonable.

El programa CUBO2.CPP pasa la variable numero mediante una llamada por referencia (se pasa la dirección de numero) a la función cuboReferencia() Esta toma nPtr (que es un apuntador a int) como argumento. La función desreferencia el apuntador y eleva al cubo el valor al que apunta nPtr. Esto cambia el valor de numero en main()

/* El siguiente programa: CUBO1.CPP, eleva al cubo una variable mediante una llamada por valor. */ #include <iostream.h> //Para cout y cin int cuboValor(int); //Prototipo void main(void) { int numero = 5; cout << "El valor original del número es: " << numero; numero = cuboValor(numero); cout << "\nEl nuevo valor del número es: " << numero << endl; }//Fin de main() int cuboValor(int n) { return n * n * n; //Eleva al cubo la variable local n }//Fin de cuboValor()



Una función que recibe como argumento una dirección debe definir un parámetro de apuntador para recibir dicha dirección. Por ejemplo, el encabezado de la función cuboReferencia() es:

void cuboReferencia(int *nPtr);

El encabezado de la función especifica que cuboReferencia() contiene int * entre paréntesis. Como sucede con los demás tipos de variables, no es necesario incluir los nombres de los apuntadores en los prototipos de función. El compilador ignorará los nombres incluidos con fines de documentación. En el encabezado de la función y en el prototipo de una función que espera como argumento un arreglo de un solo índice, puede emplearse la notación de apuntadores en la lista de parámetros de cuboReferencia() El compilador no hace ninguna distinción entre una función que recibe un apuntador y otra que recibe un arreglo de un solo índice. Por supuesto, esto significa que la función debe saber cuándo está recibiendo un arreglo y cuándo se trata simplemente de una variable sencilla sobre la que debe efectuar una llamada por referencia. Cuando el compilador encuentra un parámetro de función para un arreglo de un solo índice, de la forma int b[], lo convierte a la notación de apuntadores int * const b (que se pronuncia como b es un apuntador constante a un entero); const se explica en la sección siguiente (empleo del calificador const con apuntadores) Ambas formas de declaración de un parámetro de función como arreglo de un solo índice son intercambiables. Las figuras 20.3 y 20.4 son análisis gráficos de los programas CUBO1.CPP y CUBO2.CPP. Antes de que main() llame a cuboValor():

/* El siguiente programa: CUBO2.CPP, eleva al cubo una variable mediante una llamada por referencia, con un argumento de apuntador. */ #include <iostream.h> //Para cout y cin void cuboReferencia(int *); //Prototipo void main(void) { int numero = 5; cout << "El valor original del número es: " << numero; cuboReferencia(&numero); cout << "\nEl nuevo valor del número es: " << numero << endl; }//Fin de main() void cuboReferencia(int *nPtr) { *nPtr = *nPtr * *nPtr * *nPtr; //Eleva al cubo el número en main() }//Fin de cuboReferencia()

int main() numero { int numero = 5; numero = cuboValor(numero); }//Fin de main()

int cuboValor(int n) n { return n * n * n; }//Fin de cuboValor()

5 indefinido



Después de que cuboValor() recibe la llamada: Después de que cuboValor() eleve al cubo el parámetro n: Después de que cuboValor() regresa a main(): Después de que main() completa la asignación de numero:

Figura 20.3. Análisis de una llamada por valor típica.

Antes de la llamada por referencia a cuboReferencia():

Después de la llamada por referencia a cuboReferencia() y antes de elevar *nPtr al cubo:



5 5


int cuboValor(int n) n { 125 return n * n * n; }//Fin de cuboValor()

5 indefinido

int main() numero { int numero = 5; 125 numero = cuboValor(numero); }//Fin de main()


5 indefinido



125 indefinido

int main() numero { int numero = 5; cuboReferencia(&numero); }//Fin de main()

void cuboReferencia(int *nPtr) { nPtr *nPtr = * nPtr * *nPtr * *nPtr; }//Fin de cuboValor()

5 indefinido



5 •



Después de elevar *nPtr al cubo:

Figura 20.4. Análisis de una llamada por referencia típica con argumento de apuntador.

EMPLEO DEL CALIFICADOR const CON APUNTADORES

El calificador const le permite al programador informarle al compilador que no se debe modificar el valor de una variable en particular.

Existen seis posibilidades para utilizar (o no utilizar) const con parámetros de función –

dos con paso de parámetros mediante llamada por valor y cuatro con paso de parámetros mediante llamada por referencia. ¿Cómo escoger entre las seis posibilidades? Sea la guía el principio de menor privilegio. Siempre habrá que dar a una función el suficiente acceso a la información de sus parámetros para que pueda llevar a cabo la tarea encomendada, pero no más.

En lección anterior, explicamos que, cuando se invoca una función mediante llamada por

valor, se obtiene una copia del argumento (o argumentos) en la llamada de función, la cual es la que pasa a la función. Si en la función se modifica la copia, el valor original en el invocador se conserva inalterado. En muchos casos, un valor pasado a una función es modificado para que la función pueda llevar a cabo su tarea. Sin embargo, en algunos casos, el valor no debe ser alterado en la función llamada, aún si la función llamada sólo manipula una copia del valor original.

Considere una función que toma como argumentos un arreglo de un solo índice y su

tamaño, y que imprime dicho arreglo. Tal función deberá recorrer el arreglo utilizando un ciclo y enviar a la salida, uno por uno, los elementos del mismo. El tamaño del arreglo se utiliza en el cuerpo de la función para determinar el índice más grande del arreglo y poder terminar el ciclo cuando se ha terminado la impresión. El tamaño del arreglo no cambia en el cuerpo de la función.

Si un valor no cambia (o no debe cambiar) en el cuerpo de una función a la cual se pasa,

el parámetro debe ser declarado como const con el fin de asegurar que no sea modificado por accidente. Si se intenta modificar una valor const, el compilador lo detecta y emite un aviso o un error, dependiendo del compilador.

Hay cuatro maneras de pasar una apuntador a una función: con un apuntador no

constante hacia datos no constantes, mediante un apuntador no constante hacia datos constantes, por medio de un apuntador constante hacia datos no constantes y utilizando un apuntador constante hacia datos constantes. Cada combinación ofrece un nivel distinto de privilegio de acceso.

El mayor acceso se otorga mediante un apuntador no constante hacia datos no constantes

–la información puede modificarse a través del apuntador desreferenciado y dicho apuntador se puede modificar para que apunte hacia otros datos. La declaración de apuntadores no constantes



125 •



hacia datos no constante no incluye a const. Tal apuntador puede servir para recibir una cadena en una función que se vale de aritmética de apuntadores para procesar (y tal vez modificar) uno por uno los caracteres de la cadena. La función convertirMayuscula() en el programa MAYÚSCULA.CPP declara el parámetro sPtr (char *sPtr) como apuntador no constante hacia datos no constantes. La función procesa la cadena cadena, carácter por carácter, mediante aritmética de apuntadores. Los caracteres entre la a y la z son convertidos a sus letras mayúsculas a través de la función toupper(), los demás se conservan iguales. La función toupper() toma como argumento un carácter. Si dicho carácter es una letra minúscula, se devuelve la letra mayúscula correspondiente; de otro modo, se devuelve el carácter original. La función toupper() es parte de la biblioteca de manejo de caracteres ctype.h.

Ejemplo 20.3

El siguiente programa: MAYÚSCULA.CPP, ilustra el uso de un apuntador no constante a datos no constantes.

Un apuntador no constante hacia datos constantes es un apuntador que se puede modificar para que apunte hacia cualquier elemento de información del tipo apropiado, pero los datos a los que apunta no pueden modificarse por medio de ese apuntador. Tal apuntador podría servir para recibir como argumento un arreglo en una función que procesará cada elemento de dicho arreglo sin modificar los datos.

/* El siguiente programa: MAYUSCULA.CPP, convierte letras minúsculas a mayúsculas, por medio de un apuntador no constante hacia datos no constantes. */ #include <iostream.h> //Para cout y cin #include <ctype.h> //Para toupper() void convertirMayuscula(char *); void main(void) { char cadena[] = "caracteres y $32.98"; cout << "La cadena de caracteres antes de la conversión es : " << cadena; convertirMayuscula(cadena); cout << "\nLa cadena de caracteres después de la conversión es: " << cadena << endl; }//Fin de main() void convertirMayuscula(char *sPtr) { while(*sPtr != '\0') { if(*sPtr >= 'a' && *sPtr <= 'z') *sPtr = toupper(*sPtr); //Convierte a mayúsculas ++sPtr; //Mueve sPtr al siguiente carácter }//Fin del while }//Fin de convertirMayuscula()



Ejemplo 20.4

La función imprimirCaracteres() del programa IMPRIMIR.CPP, declara que los parámetros sPtr son del tipo const char *. La declaración se lee de derecha a izquierda como sPtr es un apuntador hacia una constante de caracteres. El cuerpo de la función utiliza una estructura for con la que envía a la salida, uno por uno, los caracteres de la cadena, hasta que encuentra el carácter nulo. Tras la impresión de un carácter, se incremente sPtr para apuntar al siguiente carácter de la cadena.

Ejemplo 20.5

El siguiente programa: MODIFICAR.CPP, muestra los mensajes de error que se generan al intentar compilar una función que recibe un apuntador hacia datos constantes y luego intenta emplear dicho apuntador para modificar los datos.

/* El siguiente programa: IMPRIMIR.CPP, imprime una cadena, caracter tras caracter, mediante un apuntador no constante hacia datos constantes. */ #include <iostream.h> //Para cout y cin void imprimirCaracteres(const char *); void main(void) { char cadena[] = "imprime caracteres de una cadena"; cout << "La cadena es:\n"; imprimirCaracteres(cadena); cout << endl; }//Fin de main() /* En imprimirCaracteres(), sPtr es el apuntador hacia una constante de caracteres. Los caracteres no pueden modificarse por medio de sPtr(es decir, sPtr es un apuntador de solo lectura). */ void imprimirCaracteres(const char *sPtr) { for(; *sPtr != '\0'; sPtr++) // No hay inicialización cout << *sPtr; }//Fin de imprimirCaracteres()

/* El siguiente programa: MODIFICAR.CPP, intenta modificar la información por medio de un apuntador no constante hacia datos constantes. */ #include <iostream.h> //Para cout y cin void f(const int *); void main(void) { int y; f(&y); //f intenta una modificación ilegal }//Fin de main()



Los mensajes que el compilador envía son los siguientes:

Cannot modify a const object Parameter ‘xPtr’ is never used

Como sabemos, los arreglos son tipos de datos agrupados que almacenan elementos de datos relacionados del mismo tipo bajo un mismo nombre. En otra lección se estudiará otra forma de tipo de datos agrupados, llamado estructura (a veces conocido como registro en otros lenguajes) Una estructura es capaz de almacenar elementos de datos relacionados de distintos tipos bajo un mismo nombre (por ejemplo, para almacenar información sobre todos los empleados de una compañía) Al invocar una función con un arreglo como argumento, éste se pasa de manera automática a la función simulando una llamada por referencia. Sin embargo, las estructuras siempre se pasan mediante llamada por valor –se pasa una copia de toda la estructura. Esto requiere la sobrecarga en tiempo de ejecución que es causada por copiar todos los elementos de datos de la estructura y almacenarlos en la pila de llamadas de función de la computadora (que es el lugar donde se almacenan las variables locales empleadas en la función mientras ésta se ejecuta) Cuando hay que pasar una estructura a una función, puede utilizarse un apuntador hacia datos constantes (o una referencia hacia datos constantes), logrando el desempeño de una llamada por referencia y la protección de una llamada por valor. Cuando el apuntador se pasa hacia una estructura, sólo hay que copiar la dirección en la que se almacena tal estructura. En una máquina con direcciones de 4 bytes, se hace una copia de 4 bytes de memoria, en lugar de los, tal vez, cientos o miles de bytes de la estructura.

Un apuntador constante hacia datos no constantes es un apuntador que siempre apunta a

la misma localidad de memoria; los datos de dicha localidad se pueden modificar a través del apuntador. Esto es lo predeterminada para un nombre de arreglo, el cual es un apuntador constante hacia el inicio del arreglo. Es posible acceder y cambiar toda la información del arreglo por medio de su nombre y sus índices. Un apuntador constante hacia datos no constantes puede servir para recibir como argumento un arreglo en una función que accede a elementos del mismo, empleado sólo notación de índices. Los apuntadores que se declaran como const deben ser inicializados cuando se declaran (si el apuntador es un parámetro de función, se inicializa con un apuntador que se pasa a la función)

Ejemplo 20.6

El programa MODIFICAR2.CPP, intenta modificar un apuntador constante. El apuntador ptr se declara como de tipo int * const. Esta declaración se lee de derecha a izquierda como ptr es un apuntador constante hacia un entero. El apuntador se inicializa con la dirección de la variable entera x. El programa intenta asignarle a ptr la dirección de y, lo cual genera un mensaje de error. Observe que al asignarle el valor 7 a *ptr no se produce un error –el valor al que apunta ptr sigue siendo modificable.

// En f, xPtr es un apuntador hacia una constante entera void f(const int *xPtr) { *xPtr = 100; // No se puede modificar un objeto const }//Fin de f()



Los mensajes que envía el compilador son los siguientes:

Cannot modify a const object ‘y’ is declared but never used

El menor privilegio de acceso se otorga mediante un apuntador constante hacia datos constantes. Tal apuntador siempre apunta a la misma localidad de memoria y los datos de dicha localidad no pueden ser modificados. Esta es la manera en que debe pasarse un arreglo a una función que sólo consulta dicho arreglo por medio de notación de índices y que no lo modifica.

Ejemplo 20.7

El programa MODIFICAR3.CPP, declara la variable de apuntador ptr como de tipo const int *const. Esta declaración se lee de derecha a izquierda como ptr es un apuntador constante hacia un entero constante. El programa muestra los mensajes de error generados al intentar modificar los datos hacia los que apunta ptr y al intentar alterar la dirección almacenada en la variable de apuntador. Observe que al intentar enviar a la salida el valor al que apunta ptr no se genera un error, pues en la instrucción de salida no se está modificando nada.

/* El siguiente programa: MODIFICAR2.CPP, intenta modificar un apuntador constante hacia datos no constantes. */ #include <iostream.h> //Para cout y cin void main(void) { int x, y; /* ptr es un apuntador constante hacia un entero. Se puede modificar un entero a través de ptr, pero ptr siempre apunta a la misma localidad de memoria. */ int *const ptr = &x; *ptr = 7; ptr = &y; }//Fin de main()

/* El siguiente programa: MODIFICAR3.CPP, intenta modificar un apuntador constante hacia datos constantes. */ #include <iostream.h> //Para cout y cin void main(void) { int x = 5, y; /

/* ptr es un apuntador constante hacia un entero constante. ptr siempre apunta a la misma localidad y el entero de dicha localidad no puede ser modificado. */ const int *const ptr = &x; cout << *ptr << endl;

*ptr = 7; ptr = &y; }//Fin de main()



ORDENAMIENTO DE burbuja MEDIANTE LLAMADA POR REFERENCIA Ejemplo 20.8

El programa BURBUJA1.CPP, de la lección 18 se modificará para que utilice dos funciones clasificBurbuja() e intercambiar() (véase el programa BURBUJA.CPP) La función clasificBurbuja() se encarga de ordenar el arreglo. Llama a la función intercambiar() para que intercambie los elementos del arreglo arreglo[j] y arreglo[j + 1] Recuerde que C++ aplica el ocultamiento de información entre funciones, por lo que intercambiar() no tiene acceso a los elementos individuales del arreglo clasificBurbuja() Debido a que clasificBurbuja() quiere que intercambiar() tenga acceso a los elementos del arreglo que se intercambiarán, pasa cada uno de ellos a intercambiar() mediante una llamada por referencia; la dirección de cada elemento del arreglo se pasa explícitamente. Aunque los arreglos completos se pasan automáticamente mediante llamada por referencia, los elementos individuales del arreglo son escalares y por lo general se pasan mediante una llamada por valor. Así que clasificBurbuja() utiliza el operador de dirección (&) en cada elemento del arreglo en la llamada de intercambiar(), como sigue:

Intercambiar(&arreglo[j], &arreglo[j + 1]);

Poniendo en práctica la llamada por referencia. La función intercambiar() recibe &arreglo[j] en la variable de apuntador elemento1Ptr. Gracias al ocultamiento de información, intercambiar() no puede saber el nombre arreglo[j], pero puede utilizar *elemento1Ptr como sinónimo de arreglo[j] Por lo tanto, cuando intercambiar() hace referencia a *elemento1Ptr, de hecho está referenciando a arreglo[j] en clasificBurbuja() De igual manera, cuando intercambiar() hace referencia a *elemento2Ptr, en realidad está referenciando a arreglo[j + 1] en clasificBurbuja() Aun cuando no se permite que intercambiar() diga:

temporal = arreglo[j]; arreglo[j] = arreglo[j + 1]; arreglo[j + 1] = temporal;

se logra exactamente el mismo efecto mediante:

en la función intercambiar del programa BURBUJA.CPP

/* El siguiente programa: BURBUJA.CPP, pone los valores en un arreglo, los ordena en orden ascendente e imprime el arreglo resultante. */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() void clasificBurbuja(int *, const int); void main(void) { const int TAMANO_ARREGLO = 10; int arreglo[TAMANO_ARREGLO] = {2, 6, 4, 8, 10, 12, 89, 68, 45, 37}; int i; cout << "Datos en el orden original\n"; for(i = 0; i < TAMANO_ARREGLO; i++) cout << setw(4) << arreglo[i]; clasificBurbuja(arreglo, TAMANO_ARREGLO); //Ordena el arreglo

cout << "\nDatos en orden ascendente\n";



Deben observarse varias características de la función clasificBurbuja() El encabezado de la función declara arreglo como int *arre, en lugar de como int arre[], indicando que clasificBurbuja() recibe como argumento un arreglo de un solo índice (nuevamente, estas notaciones son intercambiables) El parámetro tamano se declara como const, aplicando el principio de menor privilegio. Aunque el parámetro tamano recibe una copia de un valor de main() y la modificación de la copia no puede cambiar el valor en main() clasificBurbuja() no necesita alterar tamano para que cumpla su tarea. El tamaño del arreglo permanece fijo durante la ejecución de clasificBurbuja() Por lo tanto, tamano se declara como const para asegurarse de que no se pueda modificar. Si el tamaño del arreglo se modificara durante el proceso de ordenamiento, el algoritmo de ordenamiento no se ejecutaría correctamente.

El prototipo de la función intercambiar() está incluido en el cuerpo de la función clasificBurbuja() porque es la única función que llama a intercambiar() La colocación del prototipo en clasificBurbuja() restringe las llamadas correctas a intercambiar() a aquellas que se llevan a cabo desde clasificBurbuja() Otras funciones que intentan llamar a intercambiar() no tienen acceso a un prototipo de función apropiado. Por lo general, éste es un error de sintaxis, pues C++ requiere prototipos de función. Observe que la función clasificBurbuja() recibe como parámetro el tamaño del arreglo. Dicha función debe saber el tamaño del arreglo para poder ordenarlo. Cuando se pasa un arreglo a una función, ésta recibe la dirección de memoria del primer elemento del arreglo. El tamaño del arreglo se debe pasar por separado. Al definir la función clasificBurbuja() para que reciba como parámetro el tamaño del arreglo, se logra que cualquier programa que ordene arreglos de enteros de un solo índice de tamaño arbitrario utilice dicha función. El tamaño del arreglo podría haberse programado directamente en la función. Esto limita el uso de la función a un arreglo de un tamaño específico y reduce su capacidad de reutilización. Sólo los programas que procesen arreglos de enteros de un solo índice y que sean del tamaño especificado podrán utilizar la función.

Ejemplo 20.9

C++ ofrece el operador unario sizeof, el cual determina el tamaño en bytes de un arreglo (o de cualquier otro tipo de datos) durante la compilación del programa. Cuando al nombre de un arreglo se le aplica el operador sizeof, como en el programa SIZEOF.CPP, éste devuelve la cantidad total de bytes que hay en el

for(i = 0; i < TAMANO_ARREGLO; i++) cout << setw(4) << arreglo[i]; cout << endl; }//Fin de main() void clasificBurbuja(int *arre, const int tamano) { void intercambiar(int *, int *); for(int pasada = 0; pasada < tamano - 1; pasada++) for(int j = 0; j < tamano -1; j++) if(arre[j] > arre[j+1]) intercambiar(&arre[j], &arre[j+1]); }//Fin de clasificBurbuja() void intercambiar(int *elemento1Ptr, int *elemento2Ptr) { int temporal = *elemento1Ptr; *elemento1Ptr = *elemento2Ptr; *elemento2Ptr = temporal; }//Fin de intercambiar()



arreglo como un valor de tipo size_t, que generalmente es un unsigned int. La computadora empleada aquí almacena las variables de tipo float en 4 bytes de memoria, y arreglo se ha declarado como de 20 elementos, por lo que arreglo ocupa 80 bytes de memoria. Al aplicarle el operador sizeof a un parámetro de apuntador de una función que recibe un arreglo como argumento, dicho operador devuelve el tamaño en bytes (4) del apuntador, no el tamaño del arreglo.

El número de elementos de un arreglo también puede determinarse por medio de los resultados de dos operaciones de sizeof. Por ejemplo, considere la siguiente declaración de arreglo:

double arregloReal[22];

Si las variables del tipo de datos double se almacenan en 8 bytes de memoria, el arreglo arregloReal contiene un total de 176 bytes. Para determinar el número de elementos del arreglo, puede utilizarse la siguiente expresión:

sizeof (arregloReal) / sizeof(double);

La expresión determina el número de bytes en el arreglo arregloReal y divide este valor entre el número de bytes que se utiliza en memoria para almacenar un valor double.

Ejemplo 20.10

El programa SIZEOF2.CPP se vale del operador sizeof para calcular el número de bytes utilizados para almacenar cada uno de los tipos de datos estándar de la computadora particular que se está empleado.

/* El siguiente programa: SIZEOF.CPP, utiliza el operador sizeof() aplicado a un nombre de arreglo, devuelve la cantidad de bytes del arreglo. */ #include <iostream.h> //Para cout y cin size_t obtenerTamano(float *); void main(void) { float arreglo[20]; cout << "El número de bytes en el arreglo es " << sizeof(arreglo) << "\nEl número de bytes devuelto por obtenerTamano() es " << obtenerTamano(arreglo) << endl; }//Fin de main() size_t obtenerTamano(float *ptr) { return sizeof(ptr); }//fin de obtenerTamano()

/* El siguiente programa: SIZEOF2.CPP, muestra el uso del operador sizeof */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw()



El operador sizeof se puede aplicar a cualquier nombre de variable, nombre de tipo o valor constante. Cuando se aplica a un nombre de variable (que no sea un nombre de arreglo) o valor constante, se devuelve el número de bytes que se emplean para almacenar el tipo de variable o constante específicos. Observe que los paréntesis que se utilizan con sizeof son obligatorios si se indica como operando un nombre de tipo; no se requieren si se indica como operando un nombre de variable. Es importante recordar que sizeof es un operador, no una función.

EXPRESIONES DE APUNTADORES Y ARITMÉTICA DE APUNTADORES Los apuntadores son operandos válidos en las expresiones aritméticas, las expresiones de asignación y las expresiones de comparación. Sin embargo, no todos los operadores que se utilizan normalmente en estas expresiones son válidos con variables de apuntador. Esta sección describe los operadores que pueden tener apuntadores como sus operandos, además de la manera en que se utilizan. Es posible llevar a cabo un conjunto limitado de operaciones aritméticas sobre los apuntadores. Un apuntador puede incrementarse (++) o decrementarse (--), además es posible sumarle un entero a un apuntador (+ o +=), restar un entero de un apuntador (- o -=) y restar un apuntador de otro. Suponga que se ha declarado un arreglo int v[5] y que su primer elemento está en la localidad 3000 de la memoria. Además, suponga que se ha inicializado el apuntador vPtr para que apunte a v[0], es decir, el valor de vPtr es 3000. La figura 20.5 es un diagrama de dicha

void main(void) { char c; short s; int i; long l; float f; double d; long double ld; int arreglo[20], *ptr = arreglo; cout << "sizeof c = " << sizeof c << "\tsizeof(char) = " << sizeof(char) << "\nsizeof s = " << sizeof s << "\tsizeof(short) = " << sizeof(short) << "\nsizeof i = " << sizeof i << "\tsizeof(int) = " << sizeof(int) << "\nsizeof l = " << sizeof l << "\tsizeof(long) = " << sizeof(long) << "\nsizeof f = " << sizeof f << "\tsizeof(float) = " << sizeof(float) << "\nsizeof d = " << sizeof d << "\tsizeof(double) = " << sizeof(double) << "\nsizeof ld = " << sizeof ld << "\tsizeof(long double) = " << sizeof(long double) << "\nsizeof arreglo = " << sizeof arreglo << "\nsizeof ptr = " << sizeof ptr << endl; }//Fin de main()



situación en una máquina con enteros de 4 bytes. Observe que vPtr puede inicializarse para que apunte al arreglo v mediante cualquiera de las siguientes instrucciones:

vPtr = v; vPtr = &v[0];

Localidad

Variable de apuntador vPtr

Figura 20.5. El arreglo v y la variable de apuntador vPtr que apunta a v.

En la aritmética convencional, la suma de 3000 + 2 da el valor 3002. Normalmente éste no es el caso con la aritmética de apuntadores. Cuando a un apuntador se le suma o resta un entero, dicho apuntador no se incrementa o decrementa en la misma cantidad que el entero, sino en el entero por el tamaño del objeto hacia el que apunta el apuntador. El número de bytes depende del tipo de datos del objeto. Por ejemplo, la instrucción

vPtr += 2;

producirá 3008 (3000 + 2 * 4), suponiendo que los enteros se almacenan en 4 bytes de memoria. En el arreglo v, vPtr ahora apuntará a v[2] (vea la figura 20.6) Localidad Variable de apuntador vPtr

Figura 20.6. El apuntador vPtr después de la aritmética de apuntadores.

Si se almacena un entero en 2 bytes de memoria, entonces el cálculo anterior dará la localidad de memoria 3004 (3000 + 2 * 2) Si el arreglo fuera de un tipo de datos distinto, la instrucción previa incrementaría el apuntador por el doble del número de bytes necesarios para almacenar un objeto de dicho tipo de datos. Al efectuar aritmética de apuntadores sobre un

3000 3004 3016 3008 3012

v[0] v[1] v[4] v[2] v[3]

•

3000 3004 3016 3008 3012

v[0] v[1] v[4] v[2] v[3]

•



arreglo de caracteres, los resultados serán consistentes con la aritmética común, pues cada carácter tiene un byte de longitud. Si vPtr se hubiera incrementado a 3016, que apunta a v[4], la instrucción

vPtr -= 4;

establecería vPtr nuevamente a 3000 –el comienzo del arreglo. Si se está incrementando o decrementando en uno un apuntador, es posible utilizar los operadores de incremento (++) y decremento (--) Las instrucciones

++vPtr; vPtr++;

incrementan el apuntador para que apunte a la siguiente localidad del arreglo. Las instrucciones

--vPtr; vPtr--;

decrementan el apuntador para que apunte al elemento previo del arreglo. Las variables de apuntador pueden restarse entre ellas. Por ejemplo, si vPtr contiene la localidad 3000 y v2Ptr la dirección 3008, la instrucción

x = v2Ptr –vPtr;

le asignará a x el número de elementos del arreglo de vPtr a v2Ptr, que es 2 en este caso. La aritmética de apuntadores carece de significado a menos que se lleve a cabo sobre un arreglo. No podemos suponer que dos variables del mismo tipo están almacenadas de manera contigua en la memoria, a menos que sean elementos adyacentes de un arreglo. Es posible asignar un apuntador a otro, si ambos son del mismo tipo. De otro modo, es necesario emplear un operador de conversión mediante cast para convertir el valor del apuntador del lado derecho de la asignación al tipo de apuntador a la izquierda de la asignación. La excepción a esta regla es el apuntador a void (es decir, void *), que es un apuntador genérico capaz de representar cualquier tipo de apuntador. Todos los tipos de apuntadores pueden ser asignados a void sin necesidad de una conversión mediante cast. Sin embargo, un apuntador a void no puede asignarse directamente a un apuntador de otro tipo; primero hay que convertir el apuntador void al tipo de apuntador adecuado. No es posible desreferenciar un apuntador void *. Por ejemplo, el compilador sabe que un apuntador a int hace referencia a cuatro bytes de memoria en una máquina con enteros de 4 bytes, pero los apuntadores a void simplemente contienen localidades de memoria para un tipo de datos desconocido; por lo tanto, el compilador no sabe el número preciso de bytes a los que hace referencia el apuntador. El compilador debe saber el tipo de datos para determinar el número de bytes a desreferenciar para un apuntador en particular. En el caso de un apuntador a void, esta cantidad de bytes no puede determinarse a partir del tipo.



Los apuntadores se pueden comparar por medio de operadores de igualdad y relacionales, pero tales comparaciones no tienen significado a menos que los apuntadores apunten a miembros del mismo arreglo. Las comparaciones de apuntadores comparan las direcciones almacenadas en los apuntadores. Una comparación de dos apuntadores que apuntan al mismo arreglo podría mostrar, por ejemplo, que un apuntador apunta a un elemento de índice mayor que el otro apuntador. Un uso común de la comparación de apuntadores es la determinación de si un apuntador es 0. RELACIÓN ENTRE APUNTADORES Y ARREGLOS Los arreglos y los apuntadores están relacionados íntimamente en C++ y se pueden utilizar de manera casi intercambiable. Es posible pensar en los nombres de arreglos como si fueran apuntadores constantes. Los apuntadores pueden servir para realizar cualquier operación en la que intervengan índices de arreglos. Suponga que se han declarado tanto el arreglo de entero b[5] como la variable entera de apuntador bPtr. Debido a que el nombre del arreglo (sin índice) es un apuntador al primer elemento del mismo, podemos establecer bPtr a la dirección del primer elemento del arreglo b por medio de la instrucción

bPtr = b;

Esto es equivalente a tomar la dirección del primer elemento del arreglo, como sigue

bPtr = &b[0];

El elemento b[3] del arreglo se puede referencia de manera alterna con la expresión de apuntador

*(bPtr + 3)

El 3 de la expresión previa es el desplazamiento al apuntador. Cuando el apuntador apunta al inicio de un arreglo, el desplazamiento indica el elemento del arreglo al que se hará referencia y el valor de dicho desplazamiento es idéntico al índice del arreglo. La notación previa se conoce como notación de apuntador y desplazamiento. Los paréntesis son necesarios porque la precedencia de * es mayor que la de +. Sin éstos, la expresión anterior sumaría 3 al valor de la expresión *bPtr (es decir, se sumaría 3 a b[0]), suponiendo que bPtr apuntara al inicio del arreglo. Así como el elemento del arreglo se puede referenciar con una expresión de apuntador, la dirección

&b[3] se puede escribir con la expresión de apuntador

bPtr + 3

El arreglo mismo puede ser tratado como apuntador y utilizado con aritmética de apuntadores. Por ejemplo, la expresión

*(b + 3)



también se refiere al elemento del arreglo b[3]. En general, todas las expresiones de arreglos con índices se pueden escribir con un apuntador y un desplazamiento. En este caso, se utilizó notación de apuntador y desplazamiento con el nombre del arreglo como apuntador. Observe que la instrucción previa no modifica de ninguna manera el nombre del arreglo; b aún apunta al primer elemento de la misma. Los puntadores se pueden indexar de la misma manera que los arreglos. Por ejemplo, la expresión

bPtr[1] hace referencia al elemento b[1] del arreglo; esta expresión se conoce como notación de apuntador e índice. Recuerde que, en esencia, los nombres de arreglos son apuntadores constantes; siempre apuntan al inicio del arreglo. Por lo tanto, la expresión

b += 3

es inválida debido a que intenta modificar el valor del nombre del arreglo por medio de aritmética de apuntadores. Ejemplo 20.11

El programa APUNTADORES.CPP, utiliza los cuatro métodos que hemos explicado para hacer referencia a los elementos de un arreglo (indización de arreglos, apuntador y desplazamiento con el nombre del arreglo como apuntador, indización de apuntadores y apuntador y desplazamiento con un apuntador) para imprimir los cuatro elementos del arreglo de enteros b.

/* El siguiente programa: APUNTADORES.CPP, utiliza las notaciones de índices y por apuntadores con arreglos. */ #include <iostream.h> //Para cout y cin void main(void) { int b[] = {10, 20, 30, 40}; int *bPtr = b; //Establece bPtr para que apunte al arreglo b cout << "Arreglo b impreso con:\n" << "Notación de índices\n"; for(int i = 0; i < 4; i++) cout << "b[" << i << "] = " << b[i] << '\n'; cout << "\nNotación apuntador/desplazamiento en donde\n" << "el apuntador es el nombre del arreglo\n"; for(int desplazamiento = 0; desplazamiento < 4; desplazamiento++) cout << "*(b + " << desplazamiento << ") = " << *(b + desplazamiento) << '\n';



Ejemplo 20.12

Para ilustrar aún más que los arreglos y los apuntadores son intercambiables, vea las dos funciones de copia de cadenas (copia1() y copia2()) del programa APUNTADORES2.CPP. Ambas funciones copian una cadena a un arreglo de caracteres. Tras una comparación de los prototipos de función de copia1() y copia2(), ambas funciones parecen idénticas (gracias a que los arreglos y los apuntadores son intercambiables) Estas funciones llevan a cabo la misma tarea, pero se implementan de manera diferente.

cout << "\nNotacion de índices de apuntador\n"; for(int i = 0; i < 4; i++) cout << "bPtr[" << i << "] = " << bPtr[i] << '\n'; cout << "\nNotación apuntador/desplazamiento\n"; for(int desplazamiento = 0; desplazamiento < 4; desplazamiento++) cout << "*(bPtr + " << desplazamiento << ") = " << *(bPtr + desplazamiento) << '\n'; }//Fin de main()

/* El siguiente programa: APUNTADORES2.CPP, copia una cadena por medio de notación de arreglos y notación de apuntadores. */ #include <iostream.h> //Para cout y cin void copia1(char *, const char *); void copia2(char *, const char *); void main(void) { char cadena1[10], *cadena2 = "Hola", cadena3[10], cadena4[] = "Adiós"; copia1(cadena1, cadena2); cout << "cadena1 = " << cadena1 << endl; copia2(cadena3, cadena4); cout << "cadena3 = " << cadena3 << endl; }//Fin de main() //Copia s2 a s1 mediante notación de arreglos void copia1(char *s1, const char *s2) { for(int i = 0; (s1[i] = s2[i]) != '\0'; i++) ; //El cuerpo no hace nada }//Fin de copia1() //Copia s2 a s1 mediante notación de apuntadores void copia2(char *s1, const char *s2) { for(; (*s1 = *s2) != '\0'; s1++, s2++) ; //El cuerpo no hace nada }//Fin de copia2()



La función copia1() utiliza notación de índices de arreglo para copiar la cadena s2 al arreglo de caracteres s1. Además, declara una variable entera i, que funciona como contador, la cual será el índice del arreglo. El encabezado de la estructura for realiza la operación completa de copia –su cuerpo es la instrucción vacía. El encabezado especifica que i se inicializa a cero y se incrementa en uno con cada iteración del ciclo. La condición for, (s1[i] = s2[i]) != ‘\0’, realiza la operación de copia, carácter por carácter, de s2 a s1. Al llegar al carácter nulo en s2, éste es asignado a s1 y termina el ciclo, pues el carácter nulo es igual a ‘\0’. Recuerde que el valor de una instrucción de asignación el valor asignado al argumento de la izquierda.

La función copia2() se vale de apuntadores y aritmética de apuntadores para copiar la cadena de s2 al arreglo de caracteres s1. Otra vez, el encabezado de la estructura for efectúa toda la operación de copia. Dicho encabezado no incluye ninguna iniciación de variables. Como en la función copia1(), la condición (*s1 = *s2) != ‘\0’ realiza la operación de copia. El apuntador s2 es desreferenciado y el carácter resultante es asignado al apuntador desreferenciado s1. Tras la asignación que sucede en la condición, se incrementan los apuntadores para que apunten al siguiente elemento del arreglo s1 y al siguiente carácter de la cadena s2, respectivamente. Al encontrar el carácter nulo en s2, se le asigna al apuntador desreferenciado s1 y termina el ciclo.

Observe que el primer argumento, tanto de copia1() como de copia2(), debe ser un arreglo lo bastante grande para contener la cadena del segundo argumento. De otra manera, puede suceder un error cuando se intente escribir en una localidad de memoria fuera de los límites del arreglo. Además observe que el segundo parámetro de cada función se declara como const char * (cadena constante) En ambas funciones se copia el segundo argumento al primero –los caracteres se copian del segundo argumento, uno a la vez, pero nunca se modifican. Por lo tanto, se declara el segundo parámetro de modo que apunte a un valor constante, aplicando así el principio de menor privilegio. Ninguna de las dos funciones necesita modificar el segundo argumento, por lo tanto no tienen la capacidad de hacerlo.

ARREGLOS DE APUNTADORES Los arreglos pueden contener apuntadores. Un uso común de tal estructura de datos es para formar arreglos de cadenas. Cada entrada del arreglo es una cadena, pero en C++ una cadena es, en esencia, un apuntador a su primer carácter. Por lo tanto, cada entrada de un arreglo de cadenas es, de hecho, un apuntador al primer carácter de una cadena. Considere la declaración del arreglo de cadena palos, que podría ser útil para representar una baraja de naipes.

char *palos[4] = {“Corazones”, “Diamantes”, “Tréboles”, “Espadas”};

La parte palos[4] de la declaración indica un arreglo de 4 elementos. La parte char * indica que cada elemento del arreglo palos es del tipo apuntador a char. Los cuatro valores a poner en el arreglo son los palos de la baraja, “Corazones”, “Diamantes”, “Tréboles” y “Espadas”. Cada uno de ellos se almacena en memoria como una cadena de caracteres que termina con el carácter nulo y cuya longitud es de un carácter más que el número de caracteres que hay entre comillas. Las cadenas son de 10, 10, 9 y 8 caracteres de longitud, respectivamente. Aunque parece que estas cadenas se ponen en el arreglo palos, de hecho sólo se almacenan apuntadores (vea la figura 20.7)-cada apuntador apunta al primer carácter de su cadena correspondiente. Por lo tanto, aun cuando el arreglo palos es de tamaño fijo, da acceso a cadenas de caracteres de cualquier longitud. Esta flexibilidad es un ejemplo de las poderosas posibilidades de estructuración de datos que tiene C++.

Las cadenas de los distintos palos de la baraja podrían ponerse en un arreglo de doble índice en el que cada fila representa un palo y cada columna una de las letras del nombre del palo. Tal estructura de datos debe tener un número fijo de columnas por fila, que tiene que ser tan grande como la cadena más larga. Por lo tanto, se desperdiciaría una cantidad importante de memoria si se almacenara un gran número de cadenas cuando la mayoría de ellas fuera más corta



que la cadena más larga. Para ayudar a representar una baraja, en la siguiente sección se emplean arreglos de cadenas.

Figura 20.7. Representación gráfica del arreglo palos.

CASO DE ESTUDIO: Simulación de barajado y repartición de naipes

En esta sección utilizamos la generación aleatoria de números para desarrollar un programa de simulación de barajado y repartición de naipes. Este programa puede utilizarse después para implementar programas de distintos juegos de baraja. Para relevar algunos sutiles problemas de desempeño, hemos utilizado intencionalmente algoritmos de barajado y repartición subóptimos. En los ejercicios desarrollaremos algoritmos más eficientes. Mediante el enfoque de refinación descendente paso a paso, se desarrolla un programa que baraja 52 naipes y luego los reparte. Dicho enfoque es especialmente útil cuando se abordan problemas mayores y más complejos de los que hemos visto en las primeras lecciones. Para representar la baraja, utilizamos un arreglo paquete de doble índice, de 4 por 13 (vea la figura 20.8) Las filas corresponden a los palos: la fila 0 a los corazones, la fila 1 a los diamantes, la 2 a los tréboles y la 3 a las espadas. Las columnas corresponden a los valores de los naipes: las columnas 0 a 9 corresponden del as al 10, respectivamente, y las columnas de la 10 a la 12 corresponden a la sota, la reina y el rey. Cargaremos el arreglo de cadenas palos con las cadenas de caracteres que representan los cuatro palos y el arreglo de cadena cara con las cadenas de caracteres que corresponden a los trece valores de los naipes.

Figura 20.8. Arreglo (paquete) de doble índice que representa una baraja.

•

•

palos[0]

palos[0]

palos[0]

palos[0]

•

•

‘C’ ‘o’ ‘r’ ‘a’ ‘z’ ‘o’ ‘n’ ‘e’ ‘s’ ‘\0’

‘D’ ‘i’ ‘a’ ‘m’ ‘a’ ‘n’ ‘t’ ‘e’ ‘s’ ‘\0’

‘T’ ‘r’ ‘e’ ‘b’ ‘o’ ‘l’ ‘e’ ‘s’ ‘\0’

‘E’ ‘s’ ‘p’ ‘a’ ‘d’ ‘a’ ‘s’ ‘\0’

Corazones 0

Diamantes 1

Tréboles 2

Espadas 3

0 1 2 3 4 5 6 7 8 10 11 12

9



En la figura 20.8 cada columna (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12) representan: As, Dos, Tres, Cuatro, Cinco, Seis, Siete, Ocho, Nueve, Diez, Sota, Reina y Rey respectivamente.

Así paquete[2][12] (parte sombreada de la figura 20.8) representa al rey de tréboles. Tréboles Rey Esta baraja simulada puede barajarse como sigue. Primero, el arreglo paquete se pone

en ceros. Luego se seleccionan al azar una fila (renglón, 0 a 3) y una columna (columna, 0 a 12) El número 1 se inserta en el elemento del arreglo paquete[renglón][columna], indicando que este naipe va a ser el primero de la baraja en ser repartido. Este proceso continua con la inserción aleatoria de los números 2, 3, ..., 52 en el arreglo paquete, con lo que se indica el segundo, tercero, ... y quincuagésimo segundo naipe a repartir. A medida que se va llenando el arreglo paquete con números de naipe, es posible que una carta se seleccione dos veces, es decir, que paquete[renglón][columna] sea distinto de cero cuando sea seleccionado. Esta selección simplemente se ignora y se seleccionan al azar otro renglón y otra columna hasta dar con un naipe no seleccionado. Tarde o temprano los números del 1 al 52 ocuparán los 52 espacios del arreglo paquete. En este momento se termina el barajado de los naipes.

Este algoritmo de barajado podría ejecutarse durante un tiempo indefinidamente grande

si se seleccionan repetidamente al azar naipes que ya han sido barajados. Este fenómeno se conoce como aplazamiento indefinido. En los ejercicios se estudiará un mejor algoritmo de barajado que elimina la posibilidad de dicho fenómeno.

Para repartir el primer naipe se busca en el arreglo la posición

paquete[renglón][columna] que sea igual a 1. Esto se logra mediante una estructura for anidada que varía renglón de 0 a 3 y columna de 0 a 12. ¿A qué naipe corresponde dicho espacio del arreglo? El arreglo palos ha sido precargado con los cuatro palos, por lo que, para obtener el palo, se imprime la cadena de caracteres palos[renglón] De igual manera, para obtener el valor del naipe, se imprime la cadena de caracteres cara[columna] También se imprime la cadena “ de “. La impresión de esta información en el orden correcto permite imprimir cada naipe en la forma Rey de Tréboles, As de Diamantes, etcétera.

Procedamos mediante la refinación descendente paso a paso. La parte superior

simplemente es:

Baraja y reparte 52 naipes.

La primera refinación da:

Inicializa el arreglo de palos (palos) Inicializa el arreglo de valores (cara) Inicializa el arreglo de la baraja (paquete) Baraja los naipes. Reparte los 52 naipes. Baraja los naipes se puede expandir como sigue:

Por cada uno de los 52 naipes Coloca el número del naipe en un espacio desocupado de la baraja seleccionada al azar.



Reparte los 52 naipes se puede expandir como sigue: Por cada uno de los 52 naipes Encuentra un número de naipe en el arreglo de la baraja e imprime su valor y palo.

La incorporación de estas expansiones da la segunda refinación completa:

Inicializa el arreglo de palos. Inicializa el arreglo de valores. Inicializa el arreglo de la baraja. Por cada uno de los 52 naipes Coloca el número del naipe en un espacio desocupado de la baraja seleccionando al azar. Por cada uno de los 52 naipes Encuentra un número de naipe en el arreglo de la baraja e imprime su valor y palo.

Coloca el número del naipe en un espacio desocupado de la baraja seleccionado al azar se puede expandir como sigue:

Selecciona al azar el espacio de la baraja. Mientras ya haya sido seleccionado el espacio de la baraja Selecciona al azar dicho espacio. Coloca el número del naipe en el espacio seleccionado de la baraja. Encuentra el número de naipe en el arreglo de la baraja e imprime su valor y palo se

puede expandir como sigue: Por cada espacio del arreglo de la baraja Si el espacio contiene un número de naipe Imprime el valor y el palo del naipe. La incorporación de estas expansiones da la tercera refinación: Inicializa el arreglo de palos. Inicializa el arreglo de valores. Inicializa el arreglo de la baraja. Por cada uno de los 52 naipes Selecciona al azar dicho espacio. Coloca el número de naipe en el espacio seleccionado de la baraja. Por cada uno de los 52 naipes Por cada espacio del arreglo de la baraja Si el espacio contiene un número de naipe Imprime el valor y el palo del naipe.

Con esto se termina el proceso de refinación. Observe que este programa es más eficiente si las partes de barajado y repartición del algoritmo se combinan, de modo que cada naipe se reparta a medida que se pone en la baraja. Decidimos programar estas operaciones por separado debido a que los naipes normalmente se reparten después de haber sido barajados (no a medida que se barajan)



Ejemplo 20.13

En el programa BARAJAS.CPP, se muestra el barajado y repartición de naipes. Observe el formato de salida que se utiliza en la función repartir(): cout << setw(5) << setiosflags(ios::right) << wCara[columna] << “ de “ << setw(8) << setiosflags(ios::left) << wPalos[renglon] << (baraja % 2 == 0 ? ‘\n’ : ‘\t’); La instrucción de salida anterior provoca que el valor del naipe se envíe a la salida justificado a la derecha en un campo de 5 caracteres, y que el palo se envíe a la salida justificado a la izquierda en un campo de 8 caracteres. La salida se imprime en formado de dos columnas. Si el naipe que se envía a la salida está en la primera columna, se envía una tabulación a la salida tras él para saltar a la segunda columna: de otra manera, se envía un salto de línea. /* El siguiente programa: BARAJAS.CPP, baraja y reparte naipes. */

#include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() #include <stdlib.h> //Para srand() y rand() #include <time.h> //Para Time() void barajar(int[][13]); void repartir(const int [][13], const char *[], const char *[]); void main(void) { const char *palos[4] = {"Corazones", "Diamantes", "Tréboles", "Espadas"}; const char *cara[13] = {"As", "Dos", "Tres", "Cuatro", "Cinco", "Seis", "Siete", "Ocho", "Nueve", "Diez", "Sota", "Reina", "Rey"}; int paquete[4][13] = {0}; srand(time(0)); barajar(paquete); repartir(paquete, cara, palos); }//Fin de main() void barajar(int wPaquete[][13]) { int renglon, columna; for(int baraja = 1; baraja <= 52; baraja++) { do { renglon = rand() % 4; columna = rand() % 13; } while(wPaquete[renglon][columna] != 0); wPaquete[renglon][columna] = baraja; }//Fin del for }//Fin de barajar()



Hay una debilidad en el algoritmo de repartición. Una vez encontrado el número que se busca, incluso si se encuentra al primer intento, las estructuras for internas continúan buscando dicho número en los elementos restantes de paquete. En los ejercicios se corrige esta deficiencia.

APUNTADORES Y FUNCIONES

Un apuntador a una función contiene la dirección que tiene la función en la memoria. Según hemos visto el nombre de un arreglo es, en realidad, la dirección inicial en memoria del primer elemento del mismo. Del mismo modo, un nombre de función en realidad es la dirección inicial en memoria del código que lleva a cabo la tarea de la función. Los apuntadores a funciones pueden ser pasados a las funciones, devueltos de ellas, almacenados en arreglos y asignados a otros apuntadores a funciones. Ejemplo 20.14

Para ilustrar el uso de los apuntadores a funciones, hemos modificado el programa de ordenamiento de burbuja de esta lección al cual llamamos BURBUJA.CPP, dando lugar al siguiente programa, BURBUJA2.CPP. Este nuevo programa consiste en main() y en las funciones burbuja(), intercambiar(), ascendente() y descendente() La función burbuja() recibe como argumento un apuntador a una función –sea ascendente() o descendente()- además de un arreglo de enteros y su tamaño. El programa le pide al usuario que seleccione si el arreglo debe ordenarse de manera ascendente o descendente. Si el usuario indica 1, a burbuja() se le pasa un apuntador a la función ascendente(), lo que causa que el arreglo se ordena de menor a mayor. Si el usuario indica 2, a burbuja() se le pasa un apuntador a la función descendente(), lo que causa que el arreglo se ordene de mayor a menor.

void repartir(const int wPaquete[][13], const char *wCara[], const char *wPalos[]) { for(int baraja = 1; baraja <= 52; baraja++) for(int renglon = 0; renglon <= 3; renglon++) for(int columna = 0; columna <= 12; columna++) if(wPaquete[renglon][columna] == baraja) cout << setw(5) << setiosflags(ios::right) << wCara[columna] << " de " << setw(8) << setiosflags(ios::left) << wPalos[renglon] << (baraja % 2 == 0 ? '\n' : '\t'); }//Fin de repartir()

/* El siguiente programa: BURBUJA2.CPP, de ordenamiento de usos múltiples que utiliza apuntadores a funciones. */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() void burbuja(int[], const int, int (*)(int, int)); int ascendente(int, int); int descendente(int, int); void main(void) { const int TAMANO_ARREGLO = 10; int orden, contador, arreglo[TAMANO_ARREGLO] = {2, 6, 4, 8, 10, 12, 89, 68, 45, 37};



cout << "Teclee 1 para ordenar en forma ascendente,\n" << "Teclee 2 para ordenar en forma descendente: "; cin >> orden; cout << "\nDatos en el orden original\n"; for(contador = 0; contador < TAMANO_ARREGLO; contador++) cout << setw(4) << arreglo[contador]; if(orden == 1) { burbuja(arreglo, TAMANO_ARREGLO, ascendente); cout << "\nDatos en orden ascendente\n"; }//Fin del if else { burbuja(arreglo, TAMANO_ARREGLO, descendente); cout << "\nDatos en orden descendente\n"; }//Fin del else for(contador = 0; contador < TAMANO_ARREGLO; contador++) cout << setw(4) << arreglo[contador]; cout << endl; }//Fin de main() void burbuja(int trabajar[], const int tamano, int (*comparar)(int, int)) { void intercambiar(int *, int *); for(int pasada = 1; pasada < tamano; pasada++) for(int contador = 0; contador < tamano -1; contador++) if((*comparar)(trabajar[contador], trabajar[contador + 1])) intercambiar(&trabajar[contador], &trabajar[contador + 1]); }//Fin de burbuja void intercambiar(int *elemento1Ptr, int *elemento2Ptr) { int temporal; temporal = *elemento1Ptr; *elemento1Ptr = *elemento2Ptr; *elemento2Ptr = temporal; }//Fin de intercambiar() int ascendente(int a, int b) { return b < a; //Intercambia si b es menor que a }//Fin de ascendente() int descendente(int a, int b) { return b > a; //Intercambia si b es mayor que a }//Fin de descendente()



El siguiente parámetro aparece en el encabezado de la función burbuja():

int ( *comparar )( ínt, int)

Esto le dice a burbuja() que espere un parámetro que es un apuntador a una función que recibe dos parámetros enteros y devuelve un resultado entero. Se necesitan paréntesis alrededor de *comparar debido a que * tiene menor precedencia que el paréntesis que encierra los parámetros de la función. Si no se hubieran incluido los paréntesis, la declaración habría sido

int *comparar( int, int )

que declara una función que recibe dos enteros como parámetros y le devuelve un apuntador a un entero.

El parámetro correspondiente del prototipo de función de burbuja() es

Int (*) ( int, int)

Observe que sólo se han incluido los tipos, pero, con fines de documentación, el programador puede incluir nombres que ignorará el compilador.

La función que se le pasa a burbuja() es llamada en una instrucción if como sigue

if((*comparar )( trabajar[ contador], trabajar[contador + 1]))

Así como se desreferencia un apuntador a una variable para acceder al valor de ésta, se desreferencian los apuntadores a funciones para ejecutar dichas funciones.

La llamada a la función podría haberse hecho sin desreferenciar el apuntador, como en

if ( *comparar( trabajar[ contador ], trabajar[ contador + 1]))

que utiliza el apuntador directamente como nombre de función. Preferirnos el primer método, donde la llamada a una función es a través de un apuntador, pues explícitamente ilustra que compare es un apuntador a una función que se desreferencia para llamar a la función. El segundo método para llamar a la función a través de un apuntador da la apariencia de que comparar() de hecho es una función. Esto puede confundir a algún usuario del programa que quisiera ver la definición de la función comparar() y descubriera que no se definió en ninguna parte del archivo. Uno de los usos de los apuntadores a funciones es en los sistemas operados por menús. Al usuario se le solicita desde un menú que dé una opción (por ejemplo, de 1 a 5) Cada opción es atendida por una función distinta. En un arreglo de apuntadores a funciones se almacenan los apuntadores a todas las funciones. Se toma la selección del usuario como índice del arreglo y se emplea el apuntador del mismo para llamar a la función.

Ejemplo 20.15

El programa siguiente: APUNTADORES3.CPP presenta un ejemplo general de la mecánica de declaración y empleo de un arreglo de apuntadores a funciones. Se definen tres funciones (funcion1(), funcion2() y funcion3()) que toman un argumento entero y no devuelven nada. Los apuntadores a estas tres funciones se almacenan en el arreglo f, que se declara como sigue:

void( *f[ 3] ) ( int) = { funcion1, funcion2, funcion3};

La declaración se lee comenzando por el par de paréntesis de la izquierda, f es un arreglo de 3 apuntadores a funciones que toman un int como argumento y devuelven void". El arreglo se inicializa con los nombres de las funciones (que, nuevamente, son apuntadores) Cuando el usuario introduce un valor entre 0 y 2, se toma como índice del arreglo de apuntadores a funciones. La llamada de la función se hace como sigue:



( *f[opcion]) (opcion);

En la llamada, f[opcion] selecciona el apuntador que se encuentra en la localidad opcion del arreglo. El apuntador se desreferencia para que llame a la función, y opcion se pasa como argumento de la función. Cada función imprime el valor de su argumento y su nombre, indicando que se llamó de manera correcta. En los ejercicios se desarrollará un sistema operador por menús.

/* El siguiente programa: APUNTADORES3.CPP, muestra un arreglo de apuntadores a funciones. */ #include <iostream.h> //Para cout y cin void funcion1(int); void funcion2(int); void funcion3(int); void main(void) { void(*f[3])(int) = {funcion1, funcion2, funcion3}; int opcion; cout << "Introduzca un número entre 0 y 2, 3 para terminar: "; cin >> opcion; while(opcion >= 0 && opcion < 3) { (*f[opcion])(opcion); cout << "Introduzca un número entre 0 y 2, 3 para terminar: "; cin >> opcion; }//Fin de while cout << "Ejecución del programa finalizada." << endl; }//Fin de main() void funcion1(int a) { cout << "Introdujo " << a << " por ello se llamó a funcion1()\n\n"; }//Fin de funcion1() void funcion2(int b) { cout << "Introdujo " << b << " por ello se llamó a funcion2()\n\n"; }//Fin de funcion2() void funcion3(int c) { cout << "Introdujo " << c << " por ello se llamó a funcion3()\n\n"; }//Fin de funcion3()



INTRODUCCIÓN AL PROCESAMIENTO DE CARACTERES Y CADENAS

En esta sección se presentarán algunas de las funciones de la biblioteca estándar que simplifican el procesamiento de cadenas. Las técnicas que se estudian aquí son adecuadas para el desarrollo de editores de texto, procesadores de texto, software de formación de páginas, sistemas tipográficos computarizados y otros tipos de software de procesamiento de texto. Aquí empleamos cadenas basadas en apuntadores.

FUNDAMENTOS DE LOS CARACTERES Y LAS CADENAS

En C++, los caracteres son los bloques de construcción fundamentales de los programas fuente. Todos los programas se componen de una secuencia de caracteres que, agrupados de manera significativa, son interpretados por la computadora como una serie de instrucciones que sirven para llevar a cabo una tarea. Un programa puede contener constantes de caracteres. Una constante de carácter es un valor entero representado corno un carácter entre apóstrofos. El valor de dicha constante es el valor entero del carácter en el conjunto de caracteres de la máquina. Por ejemplo, ‘ z’ representa el valor entero de z (122 en el conjunto de caracteres ASCII) y ‘ \n’ representa el valor entero del salto de línea (10 en el conjunto de caracteres ASCII)

Una cadena es una serie de caracteres que se trata como unidad. Una cadena puede

incluir letras, dígitos y diversos caracteres especiales, como +, -, *, /, $ y otros. En C++ las literales de cadena o constantes de cadena se escriben entre comillas, como sigue:

“Miguel Ángel Toledo Martínez” (un nombre) “Ave. I.P.N. 36” (una dirección) “México, D. F.” (una ciudad y un estado) “(201) 555-12121” (un número telefónico)

Una cadena en C++ es un arreglo de caracteres que termina con el carácter nulo (‘ \0’)

Una cadena se accede por medio de un apuntador al primer carácter de dicha cadena. El valor de una cadena es la dirección (constante) de su primer carácter. Por lo tanto, en C++ es apropiado decir que una cadena es un apuntador constante; de hecho, se trata de un apuntador al primer carácter de la cadena. En este sentido, las cadenas son como los arreglos, pues un nombre de arreglo también es un apuntador (constante) a su primer elemento.

En una declaración, se puede asignar una cadena a un arreglo de caracteres o a una

variable de tipo char *. Las declaraciones

char color[] = “azul”; char *colorPtr = “azul”;

inicializan una variable con la cadena “azul”. La primera declaración crea un arreglo de 5 elementos llamado color que contiene los caracteres ‘a’, ‘z’, ‘u’, ‘l’ y ‘\’. La segunda crea una variable de apuntador colorPtr que apunta a la cadena, “azul”, que está en alguna parte de la memoria.

La declaración char color [] = {“azul”}; también podría escribirse como

char color[] = {‘a’, ‘z’, ‘u’, ‘l’, ‘\0' );



Al declarar un arreglo de caracteres para contener una cadena, se debe asegurar que es lo bastante grande para almacenar dicha cadena y su carácter nulo de terminación. La declaración anterior determina automáticamente el tamaño del arreglo basándose en el número de inicializadores indicados en la lista de iniciación.

Es posible asignar una cadena a un arreglo por medio de extracción de flujo utilizando

cin. Por ejemplo, la siguiente instrucción sirve para asignarle una cadena al arreglo de caracteres palabra[20]

cin >> palabra;

La cadena introducida por el usuario se almacena en palabra. La instrucción previa lee

los caracteres hasta que encuentra un espacio, tabulación, salto de línea o indicador de fin de archivo. Observe que la cadena no debe ser de más de 19 caracteres, a fin de dejar espacio para el carácter nulo de terminación. El manipulador de flujo setw() que se estudió en otra lección puede servir para asegurar que la cadena introducida a palabra no exceda el tamaño del arreglo. Por ejemplo, la instrucción

cin >> setw( 20 ) >> palabra;

especifica que cin debe leer un máximo de 19 caracteres y ponerlos en el arreglo palabra, reservando la 20ª localidad del arreglo para el carácter nulo de terminación de la cadena. El manipulador de flujo setw() sólo se aplica al siguiente valor que se introduzca.

En algunos casos es deseable introducir una línea de texto completa a un arreglo. Con este fin, C++ ofrece la función cin.getline. Ésta toma tres argumentos -un arreglo de caracteres en el que se almacenará la línea de texto, una longitud y un carácter delimitador.

Por ejemplo, el segmento de programa

char sentencia[80]; cin.getline( sentencia, 80, ‘\n’);

declara el arreglo sentencia de 80 caracteres, luego lee del teclado una línea de texto y la carga en el arreglo. La función termina la lectura de los caracteres cuando encuentra el carácter ‘\n’, cuando se introduce un indicador de fin de archivo o cuando el número de caracteres leídos hasta el momento es de uno menos que la longitud indicada en el segundo argumento (el último carácter del arreglo se reserva para el carácter nulo de terminación) Si aparece el carácter delimitador, se lee y se descarta. El tercer argumento de cin.getline tiene ‘\n’ como valor predeterminado, por lo que la llamada de función anterior podría haberse escrito así:

cin.getline( sentencia, 80 ); FUNCIONES DE MANIPULACIÓN DE CADENAS DE LA BIBLIOTECA DE MANEJO DE CADENAS

La biblioteca de manejo de cadenas ofrece muchas funciones útiles para la manipulación de cadenas de datos, la comparación de cadenas, la búsqueda de caracteres y cadenas dentro de cadenas, la división de cadenas en tokens (separación de cadenas en piezas lógicas) y la determinación de la longitud de una cadena. Esta sección presenta algunas



funciones comunes de manipulación de cadenas de la biblioteca de manejo de cadenas (que pertenece a la biblioteca estándar) Las funciones se resumen en la figura 20.9.

Observe que varias funciones de la figura 20.9 contienen parámetros con el tipo de

datos size_t. Este tipo se define en el archivo de encabezado <stddef.h> (que es un archivo de encabezado de la biblioteca estándar incluido en muchos otros archivos de encabezado de la biblioteca estándar, incluyendo <string.h>) como un tipo entero sin signo, como unsigned int y unsigned long. Prototipo de función Descripción de la función char *strcpy( char *s1, const char *s2 )

Copia la cadena s2 al arreglo de caracteres s1. Se devuelve el valor de s1.

char *strncpy( char *s1, const char *s2, size_t n ) Copia cuando mucho n caracteres de la cadena s2 al arreglo de caracteres s1. Se devuelve el valor de s1.

char *strcat( char *sl, const char *s2 ) Agrega la cadena s2 al final de la cadena s1. El primer carácter de s2 sobrescribe el carácter nulo de terminación de s1. Se devuelve el valor de s1.

char *strncat( char *sl, const char *s2, size_t n ) Agrega cuando mucho n caracteres de la cadena s2 a la cadena s1. El primer carácter de s2 sobrescribe el carácter nulo de terminación de s1. Se devuelve el valor de s1.

int strcmp( const char *sl, const char *s2 ) Compara la cadena s1 con la cadena s2. La función devuelve un valor de 0, menor que 0 o mayor que 0 si s1 es igual, menor o mayor que s2, respectivamente.

Prototipo de función Descripción de la función int strncmp( const char *sl, const char *s2, size_t n )

Compara hasta n caracteres de la cadena s1 con la cadena s2. La función devuelve un valor de 0, menor que 0 o mayor que 0 si s1 es igual, menor o mayor que s2, respectivamente.

char *strtok( char *sl, const char *s2 ) Una secuencia de llamadas a strtok divide la cadena s1 en "tokens" (piezas lógicas como palabras de una línea de texto) separados por los caracteres contenidos en la cadena s2. La primera llamada contiene s1 como el primer argumento y las siguientes llamadas que dividen la misma cadena en tokens contienen NULL como el primer argumento. Cada llamada devuelve un apuntador al token actual. Si no hay más tokens al llamar a la función, se devuelve NULL.

size_t strlen( const char *s ) Determina la longitud de la cadena s. Devuelve el número de caracteres que precede al carácter nulo de terminación.

Figura 20.9. Las funciones de manipulación de cadenas de la biblioteca manejo de cadenas.

La función a strcpy() copia el segundo argumento (una cadena) al primer argumento (un arreglo de caracteres que debe ser lo bastante grande para almacenar la cadena y su carácter nulo de terminación, el cual también se copia) La función strncpy() es equivalente a strcpy(), excepto que strncpy() especifica el número de caracteres a copiar de la cadena al arreglo. Observe que la



función strncpy() no necesariamente copia el carácter nulo de terminación del segundo argumento; sólo escribe un carácter nulo de terminación si el número de caracteres a copiar es, cuando menos, uno más que la longitud de la cadena. Por ejemplo, si el segundo argumento es “test”, sólo se escribe un carácter nulo de terminación si el tercer argumento de strncpy() es cuando menos 5 (los 4 caracteres de “test” más el carácter nulo determinación) Si el tercer argumento es mayor que 5, se agregan caracteres nulos al arreglo hasta que se ha escrito el número total de caracteres que indica el tercer argumento.

Ejemplo 20.16

El siguiente programa: COPIAR1.CPP, utiliza strcpy() para copiar la cadena completa del arreglo x al arreglo y, y emplea strncpy() para copiar los primeros 14 caracteres del arreglo x al arreglo z. Un carácter nulo (‘\0’) se agrega al arreglo z, ya que la llamada a strncpy() no escribe un carácter nulo de terminación (el tercer argumento es menor que la longitud de la cadena del segundo argumento)

La función a strcat() añade el segundo argumento (una cadena) al primero (un arreglo

de caracteres que contiene una cadena) El primer carácter del segundo argumento reemplaza el carácter nulo (‘\ 0’) que termina la cadena del primer argumento. El programador debe asegurarse de que el arreglo en el que se encuentra la primera cadena sea lo bastante grande para guardar la combinación de la primera y segunda cadenas, así como el carácter nulo de terminación (copiado de la segunda cadena) La función a strncat() agrega una cantidad específica de caracteres de la segunda cadena a la primera. Se agrega un carácter nulo de terminación al resultado.

Ejemplo 20.17

El programa siguiente: COPIAR2.CPP, muestra las funciones strcat() y strncat()

/* El siguiente programa: COPIAR1.CPP, muestra el uso de strcpy() y strncpy(). */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strcpy() y strncpy() void main (void) { char x[] = "Feliz Cumpleaños a Ti"; char y[25], z[15]; cout << "La cadena de caracteres en el arreglo x es: " << x << "\nLa cadena de caracteres en el arreglo y es: " << strcpy(y, x) << '\n'; strncpy(z, x, 16); //No copia el caracter nulo z[16] = '\0'; cout << "La cadena de caracteres en el arreglo z es: " << z << endl; }//Fin de main()

/* El siguiente programa: COPIAR2.CPP, muestra el uso de las funciones strcat() y strncat(). */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strcat() y strncat()



Ejemplo 20.18

El siguiente programa, COMPARAR.CPP, compara tres cadenas por medio de strcmp() y strncmp() La función strcmp() compara el primer argumento con el segundo, carácter por carácter. La función devuelve 0 si las cadenas son iguales, un valor negativo si la primera cadena es menor que la segunda y un valor positivo si la primera cadena es mayor que la segunda. La función strncmp() es equivalente a strcmp(), excepto porque strncmp() compara hasta un número específico de caracteres. La función strncmp() no compara los caracteres que hay después de un carácter nulo. El programa imprime los valores enteros que las llamadas de la función devuelven.

Para entender lo que significa que una cadena sea mayor que o menor que otra cadena, considere el proceso de alfabetización de una serie de apellidos. El lector, sin duda, pondría González antes que Pérez, pues en el abecedario la primera letra de González está antes que la primera letra de Pérez. Pero el abecedario es algo más que una lista de 30 letras; es una lista ordenada de caracteres. Cada letra aparece en una posición específica de la lista. La Z es algo más que una letra del abecedario; Z es, específicamente el carácter 30 del alfabeto.

void main(void) { char s1[20] = "Feliz "; char s2[] = "Año Nuevo "; char s3[40] = ""; cout << "s1 = " << s1 << "\ns2 = " << s2; cout << "\nstrcat(s1, s2) = " << strcat(s1, s2); cout << "\nstrncat(s3, s1, 6) = " << strncat(s3, s1, 6); cout << "\nstrcat(s3, s1) = " << strcat(s3, s1) << endl; }//Fin de main()

/* El siguiente programa: COMPARAR.CPP, muestra el uso de las funciones strcmp() y strncmp(). */ #include <iostream.h> //Para cout y cin #include <iomanip.h> //Para setw() #include <string.h> //Para strcmp() y strncmp() void main(void) { char *s1 = "Feliz Año Nuevo"; char *s2 = "Feliz Año Nuevo"; char *s3 = "Feliz Vacación"; cout << "s1 = " << s1 << "\ns2 = " << s2 << "\ns3 = " << s3 << "\n\nstrcmp(s1, s2) = " << setw(2) << strcmp(s1, s2) << "\nstrcmp(s1, s3) = " << setw(2) << strcmp(s1, s3) << "\nstrcmp(s3, s1) = " << setw(2) << strcmp(s3, s1); cout << "\n\nstrncmp(s1, s3, 6) = " << setw(2) << strncmp(s1, s3, 6) << "\nstrncmp(s1, s3, 7) = " << setw(2) << strncmp(s1, s3, 7) << "\nstrncmp(s3, s1, 7) = " << setw(2) << strncmp(s3, s1, 7) << endl; }//Fin de main()



¿Cómo sabe la computadora que una letra viene antes que otra? Todos los caracteres se representan dentro de la computadora como códigos numéricos; cuando la computadora compara dos cadenas, de hecho está comparando los códigos numéricos de los caracteres que hay en dichas cadenas. Con el fin de estandarizar las representaciones de los caracteres, la mayoría de los fabricantes de computadoras han diseñado sus máquinas para que operen con alguno de dos esquemas de codificación: el ASCII (Código Estándar Americano para el Intercambio de Información) o el EBCDIC (Código de Intercambio Decimal Codificado en Binario Extendido) Hay otros esquemas de codificación, pero estos dos son los más difundidos.

ASCII y EBCDIC se llaman códigos de caracteres o conjuntos de caracteres. Las manipulaciones de cadenas y caracteres de hecho comprenden la manipulación de los códigos numéricos correspondientes, y no de los caracteres mismos. Esto explica por qué los caracteres y los enteros pequeños son intercambiables en C++. Debido a que tiene sentido decir que un código numérico es mayor que, menor que o igual a otro código numérico, es posible relacionar varios caracteres o cadenas entre ellos haciendo referencia a los códigos de caracteres.

La función strtok() sirve para dividir una cadena en una serie de tokens. Un token es una

secuencia de caracteres separada por caracteres delimitadores (por lo general espacios o marcas de puntuación) Por ejemplo, en una línea de texto, cada palabra puede considerarse como un token y los espacios que las separan pueden verse como delimitadores.

Se necesitan varias llamadas a strtok() para dividir en tokens una cadena (suponiendo

que la cadena contenga más de un token) La primera llamada a strtok() contiene dos argumentos: una cadena a dividir en tokens y una cadena que contiene los caracteres que separan los tokens (es decir, delimitadores) En el siguiente programa, TOKENS.CPP, la instrucción

tokenPtr = strtok( cadena, “ “l);

asigna tokenPtr como apuntador al primer token de cadena. El segundo argumento de strtok(), “ ”, indica que los tokens en cadena están separados por espacios. La función strtok() busca el primer carácter de cadena que no sea un carácter delimitador (espacio) Éste es el inicio del primer token. Luego encuentra el siguiente carácter delimitador de la cadena y lo reemplaza con un carácter nulo ( ‘\ 0’ ) Esto termina el token actual. La función a strtok() guarda un apuntador al carácter que sigue al token y devuelve un apuntador al token actual.

Las siguientes llamadas a strtok() que continúan dividiendo en tokens a cadena contienen NULL como primer argumento. El argumento NULL indica que la llamada a strtok() deberá continuar dividiendo en tokens a partir de la localidad de cadena guardada por la última llamada a strtok() Si no quedan tokens cuando se llame a strtok(), éste devuelve NULL.

Ejemplo 20.19

El programa TOKENS.CPP, utiliza strtok() para dividir en tokens la cadena “Esta es una oración con 7 tokens”. Cada token se imprime por separado. Observe que strtok() modifica la cadena de entrada, por lo tanto, debe hacer una copia de la cadena si desea volver a utilizarla en el programa tras las llamadas a strtok()

/* El siguiente programa: TOKENS.CPP, muestra el uso de la función strtok(). */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strtok()



La función strlen() toma como argumento una cadena y devuelve el número de caracteres que ésta contiene –en la longitud no se incluye el carácter nulo de terminación. Ejemplo 20.20

El programa siguiente, LONGITUD.CPP, muestra el uso de la función strlen() A continuación se resuelven una serie de ejercicios con la intención de que el lector estudie por si mismo lo que los programas hacen y como lo hacen. Independiente de lo anterior en el mismo programa se da una breve definición del problema.

void main(void) { char cadena[] = "Esta es una oración con 7 tokens"; char *tokenPtr; cout << "La cadena a dividirse en tokens es:\n" << cadena << "\n\nLos tokens son:\n"; tokenPtr = strtok(cadena, " "); while(tokenPtr != NULL) { cout << tokenPtr << '\n'; tokenPtr = strtok(NULL, " "); }//Fin de while }//Fin de main()

/* El siguiente programa: LONGITUD.CPP, muestra el empleo de la función strlen(). */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strlen() void main(void) { char *cadena1 = "abcdefghijklmnopqrstuvwxyz"; char *cadena2 = "cinco"; char *cadena3 = "México"; cout << "La longitud de \"" << cadena1 << "\" es " << strlen(cadena1) << "\nLa longitud de \"" << cadena2 << "\" es " << strlen(cadena2) << "\nLa longitud de \"" << cadena3 << "\" es " << strlen(cadena3) << endl; }//Fin de main()



EJERCICIOS RESUELTOS

/* El siguiente programa: ALFABETO.CPP, define una cadena de 256 caracteres y luego se le agrega las letras mayúsculas del alfabeto. */ #include <iostream.h> //Para cout y cin void main (void) { char cadena[256]; int i; for (i = 0; i < 26; i++) cadena[i] = 'A' + i; cadena[i] = NULL; cout << "El contenido de la cadena es: " << cadena; }//Fin de main()

/* El siguiente programa: ALFABETO2.CPP, asigna las letras mayúsculas de la A a la Z a una cadena de caracteres. Posteriormente se agrega el caracter NULL al elemento cadena[10]. */ #include <iostream.h> //Para cout y cin void main (void) { char cadena[256]; int i; for (i = 0; i < 26; i++) cadena[i] = 'A' + i; cadena[10] = NULL; cout << "La cadena contiene: " << cadena; }//Fin de main()



/* El siguiente programa: COMILLAS.CPP, usa la secuencia de escape \" para colocar comillas dentro de la declaración de una constante. */ #include <iostream.h> //Para cout y cin void main(void) { char cadena[] = "\"!Alto!\", dijo él."; cout << cadena; }//Fin de main()

/* El siguiente programa: GETLINE.CPP, utiliza el objeto getline() para leer una serie de caracteres desde el teclado. Posteriormente visualiza esta cadena de caracteres, caracter por caracter. Finalmente muestra la longitud de la cadena. */ #include <iostream.h> //Para cout y cin void main (void) { char cadena[256]; // Cadena introducida por el usuario int i; // Índice a utilizar en la cadena cout << "Digite una cadena de caracteres y oprima enter: "; cin.getline(cadena, sizeof(cadena), '\n'); // Visualizar cada elemento de la cadena hasta que encuentre el caracter NULL for (i = 0; cadena[i] != NULL; i++) cout << cadena[i]; cout << endl << "El número de caracteres de la cadena es de: " << i; }//Fin de main()

/* El siguiente programa: LONGITUD2.CPP, ilustra el uso de la función strlen(). Esta función regresa la cantidad de caracteres que hay en el parámetro cadena. El tipo resultante size_t tiene un typedef de tipo unsigned int. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strlen()



void main(void) { char tituloLibro[] = "\"El Coronel no tiene quien le escriba\""; cout << tituloLibro << " contiene " << strlen(tituloLibro) << " caracteres"; }//Fin de main() /* ************************************************************************ Una posible implementación de la función strlen(), es la siguiente: size_t strlen(const char *cadena) { int i = 0; while (cadena[i]) i++; return (i) }//Fin de strlen() **************************************************************************** */

/* El siguiente programa: COPIAR3.CPP, ilustra el uso de la función strcpy(). El prototipo para la función strcpy es: char *strcpy(char *destino, const char *fuente) La función copia los caracteres de la cadena fuente a la cadena destino. La función supone que la cadena de destino tiene suficiente espacio para contener la cadena de origen. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strcpy() void main(void) { char titulo[] = "\"El Coronel no tiene quien le escriba\""; char libro[128]; strcpy(libro, titulo); cout << "El nombre del libro es: " << libro << endl; }//Fin de main() /* *********************************************************************** Una implementación de la función strcpy() podría ser la siguiente: char *strcpy(char *destino, const char *fuente) { while (*destino++ = *fuente++) ; return (destino - 1); }//Fin de *strcpy() **************************************************************************/

/* El siguiente programa: ANEXAR.CPP, ilustra el uso de la función strcat(). La función añade el contenido de la cadena fuente a la cadena de destino y regresa el apuntador a la cadena de destino. La función asume que la cadena de destino puede acomodar los caracteres de la cadena de origen. */



#include <iostream.h> //Para cout y cin #include <string.h> //Para strcat() void main(void) { char nombre[64] = "Miguel Angel es tan"; strcat(nombre, " feliz"); cout << nombre; }//Fin de main() /* *********************************************************************** Una posible implementación de la función strcat es la siguiente: char *strcat(char *destino, const char *fuente) { char *original = destino; while (*destino) destino**; // Busca el final de la cadena while (*destino++ = *fuente++) ; return (original) }//Fin de *strcat() ************************************************************************** */

/* El siguiente programa: ANEXAR2.CPP, ilustra el uso de la función strncat(). La función añade num caracteres de la cadena origen a la cadena de destino y regresa un apuntador a la cadena de destino. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strncat() void main(void) { char nombre[64] = "Miguel Angel"; strncat(nombre, " Martínez", 4); cout << "¿Votaste por?: " << nombre << endl; }//Fin de main() /* *********************************************************************** Una posible implementación de la función strncat() es la siguiente: char *strncat(char *destino, const char *fuente, int n) { char *original = destino; int i = 0; while (*destino) destino++; while ((i++ < n) && (*destino++ = *fuente++)) ;



/* El siguiente programa: STRXFRM.CPP, ilustra el uso de la función strxfrm() */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strxfrm() void main(void) { char fuente[64] = "\El Coronel no tiene quien le escriba\""; char destino[64]; int longitud; longitud = strxfrm(destino, fuente, sizeof(fuente)); cout << "Longitud de la cadena: " << longitud << endl; cout << "Contenido del destino: " << destino << endl; cout << "Contenido de la fuente: " << fuente << endl; }//Fin de main()

/* El siguiente programa: STREQL.CPP, ilustra el uso de la función streql() */ #include <iostream.h> //Para cout y cin int streql(char *cadena1, char *cadena2) { while ((*cadena1 == *cadena2) && (*cadena1)) { cadena1++; cadena2++; }//Fin de while return((*cadena1 == NULL) && (*cadena2 == NULL)); }//Fin de streql() void main(void) { cout << "Comparando Abc y Abc : " << streql("Abc", "Abc") << endl; cout << "Comparando abc y Abc : " << streql("abc", "Abc") << endl; cout << "Comparando abcd y abc: " << streql("abcd", "abc") << endl; }//Fin de main()

if (i > n) *destino = NULL; return (original); }//Fin de strncat() ************************************************************************** */



/* El siguiente programa: STRIEQL.CPP, ilustra el uso de la función strieql() */ #include <iostream.h> //Para cout y cin #include <ctype.h> //Para toupper() int strieql(char *cadena1, char *cadena2) { while ((toupper(*cadena1) == toupper(*cadena2)) && (*cadena1)) { cadena1++; cadena2++; }//Fin de strieql() return((*cadena1 == NULL) && (*cadena2 == NULL)); }//Fin de strieql() void main(void) { cout << "Comparando Abc y Abc : " << strieql("Abc", "Abc") << endl; cout << "Comparando abc y Abc : " << strieql("abc", "Abc") << endl; cout << "Comparando abcd y abc: " << strieql("abcd", "abc") << endl; }//Fin de main()

/* El siguiente programa: STRLWR.CPP, ilustra el uso de la funciones strlwr() y strupr(). */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strlwr() y strupr() void main(void) { cout << strlwr("\"El Coronel no tiene quien le escriba\"") << endl; cout << strupr("\"El Coronel no tiene quien le escriba\"") << endl; }//Fin de main() /* ********************************************************************* Una posible implementación de la función strlwr() es la siguiente: #include <ctype.h> char *strlwr(char *cadena) { char *original = cadena; while (*cadena) { *cadena = tolower(*cadena); cadena++; }//Fin de while return(original) }//Fin de *strlwr() ************************************************************************** */



/* El siguiente programa: STRCHR.CPP, ilustra el uso de la función strchr */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strchar() void main(void) { char titulo[64] = "\"El Coronel no tiene quien le escriba\""; char *ptr; if (ptr = strchr(titulo, 'C')) cout << "La primera ocurrencia de C es en el desplazamiento: " << (ptr - titulo) << endl; else cout << "¡NO SE ENCONTRÓ EL CARÁCTER BUSCADO!" << endl; }//Fin de main() /* *********************************************************************** Una posible implementación de la función strchr() es la siguiente: char *strchr(const char *cadena, int letra) { while ((*cadena != letra) && (*cadena) cadena++; return(cadena); }//Fin de *strchr() ************************************************************************** */

/* El siguiente programa: STRRCHR.CPP, ilustra el uso de la función strrchr */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strrchr() char *strrchr(char *cadena, char letra) { char *ptr = NULL; while (*cadena) { if (*cadena == letra) ptr = cadena; cadena++; }//Fin de while return(ptr); }//Fin de *strrchr() void main(void) { char titulo[64] = "\"El Coronel no tiene quien le escriba\""; char *ptr; if (ptr = strrchr(titulo, 'n')) cout << "La última vez en que se encontró la letra n a la derecha: " << (ptr - titulo) << endl; else cout << "!NO SE ENCONTRÓ EL CARÁCTER BUSCADO!" << endl; }//Fin de main()



FUNCIONES DE CADENA QUE UTILIZAN CADENAS UBICADAS FUERA DE LOS 64KB (far string) Algunos compiladores poseen funciones que aceptan apuntadores ubicados fuera de los 64 kbyes. Por ejemplo, para determinar la longitud de una cadena referenciada por un apuntador far, puede utilizar la función _fstrlen(), como se muestra a continuación: #include <string.h> size_t _fstrlen(const char *string) En el caso de que no exista en el compilador y usted tenga una función que maneje apuntadores ubicados en los 64 kbytes, puede modificar los mismos como se muestra en el siguiente ejemplo, para la función fstreql(): NUMERO DE OCURRENCIAS DE UN CARÁCTER DENTRO DE UNA CADENA. A continuación escribiremos la función chrcnt() que resuelve el problema planteado:

/* *********************************************************************** Una posible implementación de la función strrchr() es la siguiente: char *strrchr(const char *cadena, int letra) { char *ptr = NULL; while (*cadena) { if (*cadena == letra) ptr = cadena; cadena++; }//Fin de while return(ptr); }//Fin de *strrch() ************************************************************************** */

int fstreql (char far *str1, char far *str2) { while ((*str1 == *str2) && (*str1)) { str1++; str2++; }//Fin de while return ((*str1 == NULL) && (*str2 ==NULL)); }//Fin de fstreql()

int chrcnt (const char *cadena, int letra) { int contador = 0; while (*cadena) if (*cadena == letra) contador++; return (contador); }//Fin de chrcnt()



A continuación escribiremos la función strrev() que invierta una cadena. A continuación escribiremos la función strset() sustituye todos los caracteres de una cadena por un carácter especificado.

char *strrev (char *cadena) { char *original = cadena; char *adelante = cadena; char temp; while (*cadena) cadena++; while (adelante < cadena) { temp = *(--cadena); *cadena = *adelante; *adelante++ = temp; }//Fin de while() return (original); }//Fin de *strrev()

char * strset (char *cadena, int letra) { char *original = cadena; while (*cadena) *cadena++ = letra; return (original); }//Fin de *strset()

/* El siguiente programa: STRCMP.CPP, ilustra el uso de la función strcmp(), la cual compara dos cadenas por menor, mayor o igual. Devolviendo 0 si ambas son iguales, si la primera es mayor que la segunda devuelve un número negativo, finalmente si la segunda es mayor que la primera devuelve un número positivo. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strcmp() void main(void) { cout << "Comparando Abc y Abc : " << strcmp("Abc", "Abc") << endl; cout << "Comparando abc y Abc : " << strcmp("abc", "Abc") << endl; cout << "Comparando abcd y abc: " << strcmp("abcd", "abc") << endl; cout << "Comparando Abc y Abcd: " << strcmp("Abc", "Abcd") << endl; }//Fin de main()



/* *********************************************************************** Una posible implementación de la función strcmp() es la siguiente: int strcmp(const char *s1, const char *s2) { while ((*s1 == *s2) && (*s1)) { s1++; s2++; }//Fin de while if ((*s1 == *s2) && (! *s1) // Las cadenas son iguales return(o); else if ((*s1) && (! *s2)) // cadena s1 > cadena s2 return(-1); else if ((*s2) && (! *s1)) // cadena s2 > cadena s1 return(1); else return ((*s1 > *s2) ? -1; 1); }//Fin de strcmp() ************************************************************************** */

/* El siguiente programa: STRNCMP.CPP, muestra la función strncpm(), la cual compara cierto numero de caracteres de una cadena con otra. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strncmp() void main(void) { cout << "Comparando tres letras de Abc con Abc: " << strncmp("Abc", "Abc", 3) << endl; cout << "Comparando tres letras de abc con Abc: " << strncmp("abc", "Abc", 3) << endl; cout << "Comparando tres letras de abcd con abc: " << strncmp("abcd", "abc", 3) << endl; cout << "Comparando cinco letras de Abc con Abcd: " << strncmp("Abc", "Abcd", 5) << endl; }//Fin de main()



/* *********************************************************************** Una posible implementación de la función strncmp() es la siguiente: int strncmp(const char *s1, const char *s2, int n) { int i = o; while ((*s1 == *s2) && (*s1) && i < n) { s1++; s2++; i++ }//Fin de while if (i == n) // Las cadenas son iguales return (0); else if ((*s1 == *s2) && (! *s1) // Las cadenas son iguales return(o); else if ((*s1) && (! *s2)) // cadena s1 > cadena s2 return(-1); else if ((*s2) && (! *s1)) // cadena s2 > cadena s1 return(1); else return ((*s1 > *s2) ? -1; 1); }//Fin de strncmp() ************************************************************************** */

/* El siguiente programa: CMPCASE.CPP, ilustra el uso de las funciones stricmp() y strncmpi(), las cuales hacen comparaciones sin diferenciar mayúsculas de minúsculas. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para stricmp() y strncmpi() void main(void) { cout << "Comparando Abc con Abc: " << stricmp("Abc", "Abc") << endl; cout << "Comparando abc con Abc: " << stricmp("abc", "Abc") << endl; cout << "Comparando tres letras de abcd con ABC: " << strncmpi("abcd", "ABC", 3) << endl; cout << "Comparando 5 letras de abc con Abcd: " << strncmpi("abc", "Abcd", 5); }//Fin de main()



/* La mayoría de los compiladores ofrecen un conjunto de funciones para convertir caracteres ASCII a números, véase la tabla siguiente: función propósito atof() Convierte de ascii a punto flotante. atoi() Convierte de ascii a entero. atol() Convierte de ascii a entero largo. strtod() Convierte de ascii a doble precisión. strtol() Convierte de ascii a entero largo. El siguiente programa: ASCIINUM.CPP, ilustra el uso de algunas de las funciones anteriores. */ #include <iostream.h> //Para cout y cin #include <stdlib.h> //Para las funciones anteriores #include <iomanip.h> //Para setprecision() void main(void) { int intResultado; float floatResultado; long longResultado; intResultado = atoi("1234"); floatResultado = atof("12345.678"); longResultado = atol("1234567L"); cout << intResultado << ' ' << setprecision(8) << floatResultado << ' ' << longResultado; }//Fin de main()

/* El siguiente programa: STRDUP.CPP, ilustra el uso de la función strdup() para copiar una cadena de caracteres a un área dinámica de la memoria. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strdup() void main(void) { char *titulo; if ((titulo = strdup("\"El Coronel no tiene quien le escriba\""))) cout << "Título: " << titulo << endl; else cout << "Error al duplicar la cadena" << endl; }//Fin de main()



/* *********************************************************************** Una posible implementación de la función strdup() es la siguiente: #include <string.h> //Para cout y cin #include <malloc.h> //Para malloc() char *strdup(const char *s1) { char *ptr; if ((ptr = malloc(strlen(s1)))) // Localiza area dinámica de memoria strcpi(ptr,s1); return(ptr); }//Fin de *strdup() ************************************************************************** */

/* El siguiente programa: STRSPN.CPP, ilustra el uso de la función strspn(). Esta función busca en una cadena por la primera ocurrencia de cualquiera de los caracteres de una subcadena. La función devuelve el desplazamiento dentro de la cadena del primer caracter que no esta contenido en la segunda cadena especificada. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strspn() void main(void) { cout << "Buscando la subcadena Abc en la cadena AbcDef: " << strspn("AbcDef", "Abc") << endl; cout << "Buscando la subcadena cbA en la cadena AbcDef: " << strspn("AbcDef", "cbA") << endl; cout << "Buscando la subcadena Def en AbcAbc: " << strspn("AbcAbc", "Def"); }//Fin de main() /* ********************************************************************** Una posible implementación de la función strspn es la siguiente: size_t strspn(const char *s1, const char *s2) { int i, j; for (i = 0; *s1; i++, s1++) { for (j = 0; s2[j]; j++) if (*s1 == s2[j]) break; if (s2[j] == NULL); break; }//Fin del for return (i); }//Fin de sstrspn() ************************************************************************** */



CONTAR EL NÚMERO DE OCURRENCIA DE UNA SUBCADENA DENTRO DE UNA CADENA La siguiente función: strstr_cnt() cuenta el número de veces en el que una subcadena se encuentra dentro de una cadena.

/* El siguiente programa: STRSTR.CPP, ilustra el uso de la función strstr(), la cual busca una subcadena dentro de una cadena. Si la encuentra devuelve un apuntador a la primera ocurrencia de la subcadena. Si no la encuentra devuelve NULL. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strstr() void main(void) { cout << "Buscando la subcadena Abc en la cadena AbcDef: " << (strstr("AbcDef", "Abc") ? "Encontrado" : "No encontrado") << endl; cout << "Buscando la subcadena Abc en la cadena abcDef: " << (strstr("abcDef", "Abc") ? "Encontrado" : "No encontrado") << endl; cout << "Buscando la subcadena Abc en la cadena AbcAbc: " << (strstr("AbcAbc", "Abc") ? "Encontrado" : "No encontrado"); }//Fin de main() /* *********************************************************************** Una posible implementación de la función strstr() es la siguiente: char *strstr(const char *s1, const char *s2) { int i, j, k; for (i = 0; s1[i]; i++) for (j = i, k = 0; s1[j] == s2[k]; j++, k++) if (! s2[k + 1]) return (s1 + i); return (NULL); }//Fin de *strstr() ************************************************************************** */

int strstr_cnt (const char *cadena, const char *subcadena) { int i, j, k, contador = 0; for (i = 0; cadena[i]; i++) for (j = i, k = 0; cadena[j] == subcadena[k]; j++, k++) if (! subcadena[k + 1]) contador++; return (contador); }//Fin de strstr_cnt()



OBTENER UN ÍNDICE A UNA SUBCADENA La siguiente función strstr_index(), devuelve el índice donde se encuentra la subcadena dentro de la cadena: OBTENER LA OCURRENCIA MAS A LA DERECHA DE UNA SUBCADENA La función r_strstr() devuelve un apuntador a la ocurrencia de más a la derecha de una subcadena dentro de una cadena: REMOVER UNA SUBCADENA CONTENIDA DENTRO DE UNA CADENA La siguiente función strstr_rem() remueve la primera ocurrencia de una subcadena contenida en una cadena.

char *strstr_index(const char *s1, const char *s2) { int i, j, k; for (i = 0; s1[i]; i++) for (j = i, k = 0; s1[j] == s2[k]; j++, k++) if (! s2[k + 1]) return (i); return (i); }//Fin de *strstr_index()

char *r_strstr(const char *s1, const char *s2) { int i, j, k , izquierda = 0; for (i = 0; s1[i]; i++) for (j = i, k = 0; s1[j] == s2[k]; j++, k++) if (! s2[k + 1]) izquierda = i; return ((izquierda) ? s1 + izquierda: NULL); }//Fin de *r_strstr()

char *strstr_rem (char *cadena, char *subCadena) { int i, j, k, loc = -1; for (i = 0; cadena[i] && (loc == -1); i++) for (j =i, k = 0; str[j] == subCadena[k]; j++, k++) if (! subCadena[k + 1] ) loc = i; if (loc != -1) // La cadena fue encontrada { for (k = 0; subCadena[k]; k++) for (j = loc, i = loc + k; cadena[i]; j++, i++) cadena[j] = cadena[i];



REEMPLAZO DE UNA SUBCADENA POR OTRA La siguiente función: strstr_rep(), reemplaza la primera ocurrencia de una subcadena por otra subcadena.

#include <string.h> char *strsstr_rep (char *fuente, char *viejo, char *nuevo) { char *original = fuente; char temp[256]; int longitudVieja = strlen(viejo); int i, j, k, localizacion = -1; for (i = 0; fuente[i] && (localizacion == -1); ++i) for (j = i, k = 0; fuente[j] == viejo[k]; j++, k++) if (! viejo[k + 1]) localizacion = i; if (localizacion != -1) { for (j = 0; j < localizacion; j++) temp[j] = fuente[j]; for (i = 0; nuevo[i]; i++, j++) temp[j] = nuevo[i]; for (k = localizacion + longitudVieja; fuente[k]; k++, j++) temp[j] = fuente[k]; temp[j] = NULL; for (i = 0; fuente[i] = temp[i]; i++)//Ciclo nulo ; }//Fin de if return (original); } //Fin de *strstr_rep()

cadena [i] == NULL; }//Fin de if return (cadena); }//Fin de *strstr_rem



DETERMINAR SI UN CARÁCTER ES ALFANUMÉRICO Un carácter es alfanumérico si es letra o dígito. El archivo de cabecera ctype.h contiene una macro llamada isalnum que determina si un carácter es alfanumérico:

if (isalnum(letra))

Considere la siguiente implementación de dicha macro:

#define isalnum(c) ((toupper( (c) ) >= ‘A’ ) && (toupper ((c)) <= ‘Z’) || ((c) >= ‘0’ ) && ((c) <= ‘9’))

DETERMINAR SI UN CARÁCTER ES UNA LETRA DEL ALFABETO El archivo de cabecera ctype.h proporciona la macro isalpha para determinar si un carácter es una letra:

if (isalpha(carácter))


#define isalpha(c) (toupper((c)) >= ‘A’ && (toupper((c)) <= ‘Z’)

DETERMINAR SI UN CARÁCTER CONTIENE UN VALOR ASCII Un valor es ASCII si se encuentra en el rango comprendido entre 0 y 127. El archivo cabecera ctype.h contiene la macro isascii que le ayuda a determinar si un carácter contiene un valor ASCII:

if (isascii(carácter))


#define isascii(ltr) ((unsigned) (ltr) < 128) DETERMINAR SI UN CARÁCTER ES UN CARÁCTER DE CONTROL Un carácter de control es un valor comprendido entre ^A y ^Z o ^a y ^z. El archivo cabecera ctype.h contiene la macro iscntrl que le ayuda a determinar si un carácter es de control:

if (iscntrl(carácter)) DETERMINAR SI UN CARÁCTER ES UN DIGITO Un dígito es un valor ASCII comprendido entre 0 y 9. El archivo de cabecera ctype.h contiene la macro isdigit que le ayuda a determinar si un carácter es o no dígito:

if (isdigit(carácter))


#define isdigit(c) ((c) >= ‘0’ && (c) <= ‘9’)



DETERMINAR SI UN CARÁCTER ES UN CARÁCTER GRAFICO Un carácter es gráfico si es un carácter imprimible (ver isprint), excluyendo el carácter espacio (ASCII 32) El archivo de cabecera ctype.h contiene la macro isgraph que le ayuda a determinar si un carácter es o no gráfico:

if (isgraph(carácter)) Considere la siguiente implementación de dicha macro:

#define isgraph(ltr) ((ltr) >=33) && ((ltr) <= 127)

DETERMINAR SI UN CARÁCTER ES MAYÚSCULA O MINÚSCULA

El archivo de cabecera ctype.h contiene las macros islower y isupper que le ayudan a determinar si un carácter es minúscula o mayúscula respectivamente:

if (islower(carácter))

if(isupper(carácter))

Considere las siguiente implementaciones de dichas macros:

#define islower(c) ((c) >= ‘a’ && (c) <= ‘z’) #define isupper(c) ((c) >= ‘A’ && (c) <= ‘Z’)

DETERMINAR SI UN CARÁCTER ES IMPRIMIBLE Un carácter es imprimible si se encuentra en el rango comprendido entre 32 y 127. El archivo de cabecera ctype.h contiene la macro isprint que le ayuda a determinar si un carácter es o no imprimible:

if (isprint(carácter))


#define isprint(ltr) ((ltr) >=32) && ((ltr) <= 127) DETERMINAR SI UN CARÁCTER ES UN SÍMBOLO DE PUNTUACIÓN Desde el punto de vista gramatical los símbolos de puntuación incluyen a la coma, punto y coma, punto, interrogación y así sucesivamente. Desde punto de vista del lenguaje C un símbolo es de puntuación si es un carácter gráfico que no sea alfanumérico. El archivo de cabecera ctype.h contiene la macro ispunct que le ayuda a determinar si un carácter es o no símbolo de puntuación:

if (ispunct(carácter)) Considere la siguiente implementación de dicha macro:

#define ispunct(c) (isgraph(c)) && ! isalphanum((c)))



DETERMINAR SI UN CARÁCTER ES EL CARÁCTER ESPACIO El carácter espacio incluye el espacio, tabulador, retorno de carro, nueva línea, tabulador vertical y alimentación de hoja. El archivo de cabecera ctype.h contiene la macro isspace que le ayuda a determinar si un carácter es o no carácter espacio:

if (isspace(carácter))


#define isspace(c) (((c) == 32) || ((c) == 9) || ((c) == 13)) DETERMINAR SI UN CARÁCTER ES UN VALOR HEXADECIMAL Un carácter es hexadecimal si es un dígito entre 0 y 9 o una letra entre A y F. El archivo de cabecera ctype.h contiene la macro isxdigit que le ayuda a determinar si un carácter es o no un carácter hexadecimal:

if (isxdigit(carácter))


#define isxdigit(c) (isnum((c)) || (toupper((c)) >= ‘A’ && (toupper((c)) <= ‘F’))

/* El siguiente programa: TOUPPER.CPP, ilustra el uso de la macro _toupper y la función toupper. Se observa el error que puede ocurrir cuando se utilizan letras mayúsculas con la macro _toupper. */ #include <stdio.h> //Para putchar #include <ctype.h> //Para _toupper() y toupper() void main (void) { char cadena[] = "\"El Coronel No Tiene Quien Le Escriba\""; int i; for (i = 0; cadena[i]; i++) putchar(toupper(cadena[i])); putchar('\n'); for (i = 0; cadena[i]; i++) putchar(_toupper(cadena[i])); putchar('\n'); }//Fin de main()



CARÁCTER ASCII VÁLIDO Para asegurar que un carácter es un carácter ASCII válido, su valor se encuentra entre 0 y 127 utilice la macro toascii contenida en archivo de cabecera ctype.h: Una implementación de dicha macro es la siguiente:

#define toascii(character) ((character) & 0x7F) Lo que se logra con el valor hexadecimal 0x7F es hacer que el valor ASCII sea siempre positivo (0 a 127)

/* El siguiente programa: TOLOWER.CPP, ilustra el uso de la macro _tolower y la función tolower. Se observa el error que puede ocurrir cuando se utilizan letras minúscula con la macro _tolower. */ #include <stdio.h> //Para putchar() #include <ctype.h> //Para tolower() y _tolower() void main (void) { char cadena[] = "\"El Coronel No Tiene Quien Le Escriba\""; int i; for (i = 0; cadena[i]; i++) putchar(tolower(cadena[i])); putchar('\n'); for (i = 0; cadena[i]; i++) putchar(_tolower(cadena[i])); putchar('\n'); }//Fin de main()

/* La función printf, le permite escribir salida formateada a la pantalla. Dependiendo de los requerimientos de su programa, existen ocasiones en que necesita trabajar con una cadena de caracteres que contiene salida formatea da. Por ejemplo, suponga que sus empleados tienen 5 dígitos como número de empleado y tres caracteres que identifican la región (tal como OAX para Oaxaca). Suponga que almacena información acerca de cada empleado en un archivo cuyo nombre es una combinación de estos dos valores (tal como OAX12345). La función sprintf le permite escribir salida formateada en una cadena de caracteres. El siguiente programa: SPRINTF.CPP, utiliza la función sprintf para crear un nombre de archivo de 8 caracteres. */ #include <stdio.h> //Para la función sprintf() y printf()



void main(void) { int numeroEmpleado = 12345; char region[] = "OAX"; char nombreArchivo[64]; sprintf(nombreArchivo, "%s%d", region, numeroEmpleado); printf("Nombre del empleado: %s\n", nombreArchivo); }//Fin de main()

/* La función scanf() le permite leer entrada formateada desde stdin. Dependiendo de su programa, existen ocasiones en las cuales una cadena de caracteres contiene campos que desea asignar a variables específicas. La función sscanf() le permite leer valores de una cadena, asignando los valores a variables específicas. El siguiente programa: SSCANF.CPP, ilustra el uso de la función sscanf(). */ #include <stdio.h> //Para sscanf() y printf() void main(void) { int edad; float salario; char cadena[] = "33 25000.00"; sscanf(cadena, "%d %f\n", &edad, &salario); printf("Edad: %d salario %f\n", edad, salario); }//Fin de main()

/* El siguiente programa: CADENA1.CPP, utiliza las funciones strlen(), strcat() busca un caracter en una cadena y lo remplaza por otro caracter. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strlen(), strcat() const unsigned MAX1 = 40; const unsigned MAX2 = 80; void main(void) { char cadenaPequena[MAX1 + 1]; char cadenaGrande[MAX2 + 1]; char caracterBuscar, caracterRemplazar; cout << "Introduzca la cadena pequeña: "; cin.getline(cadenaPequena, MAX1); cout << "Introduzca la cadena grande : "; cin.getline(cadenaGrande, MAX2); cout << endl << endl;



cout << "La cadena pequena tiene " << strlen(cadenaPequena) << " caracteres" << endl; cout << "La cadena grande tiene " << strlen(cadenaGrande) << " caracteres" << endl << endl; // Encadena cadenaPequena a cadenaGrande strcat(cadenaGrande, cadenaPequena); cout << "Las cadenas encadenadas son: " << cadenaGrande << endl; cout << "La nueva cadena tiene " << strlen(cadenaGrande) << " caracteres" << endl << endl; // Obtiene los caracteres de búsqueda y reemplazo cout << "Introduzca el caracter a buscar: "; cin >> caracterBuscar; cout << "Introduzca el caracter que reemplaza: "; cin >> caracterRemplazar; // Reemplaza caracter en la cadena cadenaGrande for (int i = 0; i < strlen(cadenaGrande); i++) if (cadenaGrande[i] == caracterBuscar) cadenaGrande[i] = caracterRemplazar; // Despliega la cadena cadenaGrande actualizada cout << "\nLa nueva cadena es: " << cadenaGrande;

}//Fin de main()

/* El siguiente programa: CADENA2.CPP, utiliza el método de ordenamiento de la burbuja para ordenar un arreglo de cadenas de caracteres. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strcmp(), strcpy() const unsigned TAMANO_CADENA = 40; const unsigned TAMANO_ARREGLO = 11; void main(void) { char cadena[TAMANO_ARREGLO][TAMANO_CADENA] = { "California", "Virginia", "Alaska",

"New York", "Michigan", "Nevada", “Ohio", "Florida", "Washington", "Oregon", "Arizona" };

cout << "El arreglo desordenado es:" << endl; for (int i = 0; i < TAMANO_ARREGLO; i++) cout << cadena[i] << endl; cout << endl; // Usa el método de ordenamiento de la burbuja para ordenar el arreglo for (int i = 0; i < TAMANO_ARREGLO; ++i) for (int j = 0; j < i; ++j) if (strcmp(cadena[i], cadena[j]) < 0)



/* El siguiente programa: CADENA3.CPP, convierte una cadena de caracteres en minúsculas, mayúsculas e invierte la cadena. Si se introduce puras minúsculas o puras mayúsculas, el programa lo advierte. También advierte si las palabras son palíndromos. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strcpy(), strlwr(), strupr() const unsigned TAMANO_CADENA = 40; void main(void) { char str1[TAMANO_CADENA+1]; char str2[TAMANO_CADENA+1]; bool esMinuscula, esMayuscula, esSimetrico; cout << "Introduzca una cadena: "; cin.getline(str1, TAMANO_CADENA); cout << "\nLa cadena que introdujo fue: " << str1 << endl; strcpy(str2, str1); // Copia str1 a str2 strlwr(str2); // Convierte a minúsculas esMinuscula = (strcmp(str1, str2) == 0) ? true : false; cout << "\nMinúsculas: " << str2 << endl; strupr(str2); // Convierte a mayúsculas esMayuscula = (strcmp(str1, str2) == 0) ? true : false; cout << "Mayúsculas: " << str2 << endl << endl; strcpy(str2, str1); // Copia str1 a str2 strrev(str2); // Invierte los caracteres esSimetrico = (strcmp(str1, str2) == 0) ? true : false; cout << "Invertido: " << str2 << endl; if (esMinuscula) cout << "Su entrada no tiene letras mayúsculas" << endl; if (esMayuscula) cout << "Su entrada no tiene letras minúsculas" << endl; if (esSimetrico) cout << "Su entrada tiene caracteres simétricos" << endl; }//Fin de main()

{ char temp[TAMANO_CADENA]; strcpy(temp, cadena[i]); strcpy(cadena[i], cadena[j]); strcpy(cadena[j], temp); }//Fin de if cout << "El arreglo ordenado es:" << endl; for (int i = 0; i < TAMANO_ARREGLO; i++) cout << cadena[i] << endl; }//Fin de main()



/* El siguiente programa: CADENA4.CPP, busca una subcadena dentro de una cadena e indica en donde comienza. Busca también un caracter indicando en que posición se encuentra. */ #include <iostream.h> //Para cout y cin #include <string.h> //Para strstr(), strchr const unsigned TAMANO_CADENA = 40; void main(void) { char cadenaPrincipal[TAMANO_CADENA+1]; char subCadena[TAMANO_CADENA+1]; char caracterBuscar; char *p; int indice; int contador; cout << "Introduzca una cadena : "; cin.getline(cadenaPrincipal, TAMANO_CADENA); cout << "Introduzca una subcadena de búsqueda: "; cin.getline(subCadena, TAMANO_CADENA); cout << "Introduzca un caracter de búsqueda : "; cin >> caracterBuscar; cout << endl; cout << " 1 2 3 4" << endl; cout << "01234567890123456789012345678901234567890" << endl; cout << cadenaPrincipal << endl << endl; cout << "Buscando la cadena " << subCadena << endl; p = strstr(cadenaPrincipal, subCadena); contador = 0; while (p) { contador++; indice = p - cadenaPrincipal; cout << "Localizado en el índice " << indice << endl; p = strstr(++p, subCadena); }//Fin de while if (contador == 0) cout << "No se localizó la subcadena en la cadena principal" << endl; cout << "\nBuscando el caracter " << caracterBuscar << endl; p = strchr(cadenaPrincipal, caracterBuscar);



PENSANDO EN OBJETOS: Iteraciones entre los objetos

Ésta es la última de las tareas de diseño orientado a objetos antes de iniciar el estudio de la programación orientada a objetos en otro curso. Después de completar esta tarea, estará preparado (y probablemente ansioso) para comenzar a codificar su simulador del elevador. Para completar el simulador del elevador como se definió, necesitará las técnicas de C++ de otro curso.

En esta sección nos concentraremos en las interacciones entre los objetos. Esperamos que le sea de ayuda

para armar el cuadro. Probablemente hará adiciones a la lista de objetos, atributos y comportamientos que antes fueron desarrollados.

Hemos aprendido que la mayoría de los objetos en C++ no hacen las cosas de manera espontánea. En

cambio, los objetos responden a estímulos, que vienen en forma de mensajes, los cuales de hecho son llamadas de función que invocan las funciones miembro de los objetos.

Consideremos varias de las interacciones entre las clases de la simulación del elevador. El planteamiento

del problema indica la persona oprime el botón que se encuentra en ese piso. El sujeto del enunciado es una persona y el objeto es el botón. Éste es un ejemplo de interacción entre clases. Un objeto de la clase persona envía un mensaje a un objeto botón. A ese mensaje lo llamamos oprimirBotón. Antes hemos hecho que el mensaje fuera una función miembro de la clase botón.

En este punto, bajo Otros hechos de cada una de las clases de su simulación, todo lo que ha debido poner han sido las interacciones entre las clases. Algunas de ellas muestran explícitamente las interacciones entre los objetos de clase. Pero considere la oración

"una persona espera a que se abra la puerta del elevador"

Anteriormente hemos listados los dos comportamientos de la puerta del elevador, abrirPuerta y cerrarPuerta. Pero ahora queremos determinar qué clase de objetos envían estos mensajes. No se indican explícitamente en la oración entrecomillada anterior. Así que le damos algunas vueltas a esto y nos damos cuenta de que el elevador mismo envía el mensaje a la puerta. Estas interacciones entre los objetos de clase están implícitas en el planteamiento del problema.

Ahora continúe refinando la sección Otros hechos de las distintas clases del simulador del elevador. Estas

secciones ahora deberán contener principalmente las interacciones entre las clases. Vea cada una de ellas como:

1. un objeto de clase de envío particular 2. que envía un mensaje particular 3. a un objeto de clase de recepción particular

Bajo cada clase, añada la sección Mensajes enviados a los objetos de otras clases (a tales mensajes se les llama colaboraciones; a partir de ahora emplearemos este término) y liste las interacciones entre las clases que quedan, es decir, bajo la clase persona, incluya la entrada :

contador = 0; while (p) { contador++; indice = p - cadenaPrincipal; cout << "Localizado en el índice " << indice << endl; p = strchr(++p, caracterBuscar); }//Fin de while if (contador == 0) cout << "No localizado el caracter en la cadena principal" << endl; }//Fin de main()



la persona le envía el mensaje oprimirBotón al botón de ese piso

Bajo la clase botón, bajo Colaboraciones, coloque el mensaje:

el botón le envía el mensaje venPorMí al elevador

A medida que añada estas entradas, podrá agregar atributos y comportamientos a sus objetos. Esto es perfectamente natural.

Cuando complete este ejercicio de laboratorio, tendrá una lista razonablemente completa de las clases que

tendrá que implementar su simulador del elevador. Y por cada clase tendrá una lista razonablemente completa de sus atributos y comportamientos, así como de los mensajes que los objetos de dicha clase envían a los objetos de otras clases

En el curso de la especialidad, estudiará la programación orientada a objetos en C++. Aprenderá cómo

crear nuevas clases. Estará listo para escribir en C++ una parte importante del simulador de elevador. Conforme avance en sus conocimientos habrá aprendido lo suficiente para implementar un simulador operativo. Finalmente aprenderá a valerse de la herencia para explotar los puntos comunes entre las clases y minimizar la cantidad de software que necesitará escribir para resolver un problema.

Hagamos un resumen del proceso de diseño orientado a objetos que hemos presentado:

1. Escriba el planteamiento del problema en un archivo de texto. 2. Descarte la información irrelevante. 3. Extraiga todos los hechos. Disponga cada hecho en una línea independiente de un archivo de hechos. 4. Busque los sustantivos en los hechos; con gran probabilidad serán muchas de las clases que necesitará.

Por cada clase, poniéndola en primer nivel, escriba una lista de resumen. 5. Ponga cada hecho en el segundo nivel de la lista, bajo la clase apropiada. Si un hecho menciona varias

clases (como sucederá en muchos casos), póngalo bajo todas ellas. 6. Ahora refine el conjunto de hechos bajo cada una de las clases. Liste tres subencabezados bajo cada

clase: Atributos, Comportamientos y Colaboraciones. 7. Bajo Atributos liste la información asociada con cada clase. 8. Bajo Comportamientos liste las acciones que pueden llevar a cabo los objetos de dicha clase en respuesta

a la recepción de un mensaje. Cada comportamiento es una función miembro de la clase. 9. Bajo Colaboraciones liste los mensajes que los objetos de esta clase envían a los objetos de otras clases y

las clases que reciben estos mensajes. 10. En este punto su diseño probablemente tendrá todavía algunas piezas faltantes, que tal vez queden claras a

medida que proceda con la implementación de su simulador en C++ conforme sus conocimientos de la programación orientada a objetos sean más amplios.

Los atributos y comportamientos con frecuencia se llaman responsabilidades de una clase. La

metodología de diseño que hemos perfilado aquí a veces se llama clases, responsabilidades y colaboraciones, o simplemente CRC. ERRORES COMUNES DE PROGRAMACIÓN 1. Suponer que el * con el que se declara un apuntador se extiende a todos los nombres de variables de una lista de

variables de apuntador separada por comas puede causar que tales apuntadores se declaren como no apuntadores. Cada apuntador debe declararse con un * como prefijo del nombre.

2. Desreferenciar un apuntador que no ha sido inicializado de manera apropiada o al que no se le ha indicado que apunte a una localidad específica de memoria, puede producir un error fatal de tiempo de ejecución o modificar accidentalmente información importante, permitiendo que el programa se ejecute hasta el final, lo que arrojará resultados incorrectos.

3. El intento por desreferenciar un no apuntador es un error de sintaxis. 4. Desreferenciar un apuntador 0 por lo general causa un error fatal en tiempo de ejecución. 5. Es un error no desreferenciar un apuntador cuando es necesario hacerlo con el fin de obtener el valor al que

apunta el apuntador. 6. No inicializar un apuntador que se ha declarado corno const es un error de sintaxis.



7. El empleo del operador sizeof en una función con el fin de determinar el tamaño en bytes de un parámetro de arreglo da como resultado el tamaño en bytes del apuntador, no el tamaño en bytes del arreglo.

8. La omisión de los paréntesis en una operación sizeof cuando el operando es un nombre de tipo es un error de sintaxis.

9. La utilización de aritmética de apuntadores sobre un apuntador que no hace referencia a un arreglo de valores normalmente es un error de lógica.

10. La resta o comparación de dos apuntadores que no hacen referencia a elementos del mismo arreglo por lo general es un error de lógica.

11. Salirse de cualquiera de los extremos de un arreglo al aplicar aritmética de apuntadores normalmente es un error de lógica.

12. La asignación de un apuntador de un tipo a otro apuntador de un tipo distinto (que no sea void *) sin convertir el primer apuntador al tipo del segundo es un error de sintaxis.

13. Desreferenciar un apuntador void * es un error de sintaxis. 14. Aunque los nombre de arreglos son apuntadores al inicio de éstos y aunque los apuntadores se pueden modificar

con expresiones aritméticas, los nombres de los arreglos no pueden modificarse mediante expresiones aritméticas, dado que son apuntadores constantes.

15. Es un error no asignar suficiente espacio en un arreglo de caracteres para almacenar el carácter nulo de terminación de la cadena.

16. Es un error crear o utilizar una “cadena” que no contenga un carácter nulo de terminación. 17. El procesamiento de un solo carácter como cadena puede generar un error fatal en tiempo de ejecución. Una

cadena es un apuntador -probablemente sea un entero de tamaño respetablemente grande. Sin embargo, un carácter es un entero pequeño (los valores ASCII van de 0 a 255) En muchos sistemas, esto provoca un error, pues las direcciones de memoria bajas se reservan para fines especiales, como controladores de interrupciones del sistema operativo -por lo tanto, suceden “violaciones de acceso”.

18. Si pasa un carácter como argumento a una función cuando se espera una cadena, puede causar un error fatal en tiempo de ejecución.

19. Pasar una cadena como argumento de una función cuando se espera un carácter es un error de sintaxis. 20. Es un error olvidar incluir el archivo de encabezado <string.h> cuando se emplean funciones de la biblioteca

de manejo de cadenas. 21. No agregar un carácter nulo de terminación al primer argumento de strncpy cuando el tercer argumento es

menor o igual que la longitud de la cadena del segundo argumento puede ser causa de errores fatales en tiempo de ejecución.

22. La suposición de que strcmp y strncmp devuelven 1 cuando sus argumentos son iguales es un error de lógica. Ambas funciones devuelven 0 (que es el valor de falso de C++) cuando hay una igualdad. Por lo tanto, al probar la igualdad de dos cadenas, el resultado de la función strcmp o strncmp debe compararse con 0 para determinar si son iguales.

23. Es un error no notar que strtok modifica la cadena que se está dividiendo en tokens y luego intentar utilizarla como si fuera la cadena original, sin modificaciones.

BUENAS PRÁCTICAS DE PROGRAMACIÓN 1. Aunque no se requiere, la inclusión de las letras Ptr en los nombres de variables de apuntador deja claro que

dichas variables son apuntadores y que necesitan manipularse como tales. 2. Utilice una llamada por valor para pasar argumentos a una función, a menos que el invocador requiera

explícitamente que la función llamada modifique el valor de la variable argumento en el entorno del invocador. Éste es otro ejemplo del principio de menor privilegio.

3. Antes de utilizar una función, revise su prototipo de función a fin de determinar los parámetros que puede modificar.

4. Utilice la notación de arreglos en lugar de la notación de apuntadores cuando manipule arreglos. Aunque la compilación del programa tal vez tarde un poco más, con seguridad será más claro.

5. Al almacenar una cadena de caracteres en un arreglo de caracteres, debe asegurarse de que el arreglo es lo bastante grande para contener la cadena más grande que almacenará. C++ permite el almacenamiento de cadenas de cualquier longitud. Si una cadena es más grande que el arreglo en el que la almacenará, los caracteres que estén después del final del arreglo sobrescribirán la información en memoria que se encuentre a continuación de dicho arreglo.



PROPUESTAS DE DESEMPEÑO 1. Los objetos grandes, como las estructuras, se deben pasar mediante apuntadores hacia datos constantes o con

referencias hacia datos constantes, con el fin de lograr los beneficios en desempeño de la llamada por referencia y la seguridad de la llamada por valor.

2. sizeof es un operador unario de tiempo de compilación, no una función de tiempo de ejecución. Por lo tanto, la utilización de sizeof no afecta negativamente el desempeño en tiempo de ejecución.

3. A veces los algoritmos que emergen de manera natural pueden tener sutiles problemas de desempeño, como el aplazamiento indefinido. Es importante buscar algoritmos que eviten el aplazamiento indefinido.

PROPUESTAS DE PORTABILIDAD 1. El formato en el que se envía a la salida un apuntador depende de la máquina. Algunos sistemas envían a la

salida los valores de apuntador corno enteros hexadecimales, mientras que otros lo hacen como enteros decimales.

2. Aunque const está bien definido en el ANSI C y C++, algunos compiladores no lo aplican adecuadamente. 3. El número de bytes que se utilizan para almacenar un tipo de datos particular puede variar según el sistema. Al

escribir programas que dependan de los tamaños de los tipos de datos y que se ejecutarán en varios sistemas de cómputo, hay que utilizar sizeof para determinar el número de bytes en que se almacenan los distintos tipos de datos.

4. La mayoría de las computadoras actuales tienen enteros de 2 o 4 bytes. Algunas de las más nuevas utilizan enteros de 8 bytes. Debido a que los resultados de la aritmética de apuntadores dependen del tamaño de los objetos a los que apunta un apuntador, la aritmética de apuntadores depende de la máquina.

5. Cuando se inicializa una variable de tipo char * con una literal de cadena, algunos compiladores pueden poner dicha cadena en alguna localidad de memoria en la que no puede ser modificado. Si necesitara modificar una literal de cadena, deberá almacenarla en un arreglo de caracteres, a fin de asegurar la posibilidad de modificarla en todos los sistemas.

6. Los códigos numéricos empleados para la representación de caracteres pueden cambiar según la computadora. 7. No use los códigos ASCII específicos, como en el caso de if ( ch == 65 ) más bien, emplee la constante del

carácter, como en if ( ch = = ‘A’ ). OBSERVACIONES DE INGENIERÍA DE SOFTWARE 1. El calificador const puede servir para aplicar el principio de menor privilegio. La utilización del principio de

menor privilegio para diseñar software de la manera correcta puede reducir en gran medida el tiempo de depuración y los efectos secundarios, así como simplificar la modificación y el mantenimiento de los programas.

2. Si un valor no cambia (o no debe cambiar) en el cuerpo de una función a la cual se pasa, el parámetro debe ser declarado como const con el fin de asegurar que no sea modificado por accidente.

3. Sólo es posible alterar un valor en un invocador cuando se efectúa una llamada por valor. Este valor debe asignarse a partir del valor de devolución de la función. Si hay que modificar varios valores en un invocador, es necesario pasar varios argumentos mediante llamada por referencia.

4. La colocación de prototipos de función en las definiciones de otras funciones aplica el principio de menor privilegio, restringiendo las llamadas de función a las funciones en las que aparecen los prototipos.

5. Al pasar un arreglo a una función, también hay que pasar su tamaño (en lugar de integrarlo en la función) Esto contribuye a hacer más general la función. Las funciones generales con frecuencia son reutilizables en otros programas.

INDICACIONES DE PRUEBA Y DEPURACIÓN 1. Los apuntadores se deben inicializar con el fin de evitar que apunten a áreas desconocidas o no inicializadas de

la memoria.



LO QUE NECESITA SABER Antes de continuar con la siguiente lección, asegúrese de haber aprendido lo siguiente:

!!!!""""Los apuntadores son variables que contienen como valor la dirección de otras variables. !!!!""""La declaración:

int *ptr; declara que ptr es un apuntador a un objeto de tipo int, y se lee ptr es un apuntador a int. El * como se emplea en una declaración, indica que la variable es un apuntador.

!!!!""""Hay tres valores que se pueden utilizar para inicializar un apuntador: 0, NULL o la dirección de un objeto del mismo tipo. Es lo mismo inicializar un apuntador a 0 que a NULL.

!!!!""""El único entero que se puede asignar a un apuntador es 0. !!!!""""El operador & (de dirección) devuelve la dirección de su operando. !!!!""""El operando del operador de dirección debe ser un nombre de variable; el operador de dirección no se

puede aplicar a constantes, a expresiones que no devuelvan una referencia ni a variables declaradas con la clase de almacenamiento register.

!!!!""""El operador *, conocido como operador de indirección o de desreferencia, devuelve un sinónimo, alias o apodo del nombre del objeto al que apunta su operando en memoria. A esto se le llama desreferenciar el apuntador.

!!!!""""Al llamar una función con un argumento que el invocador desea que la función llamada modifique, debe pasarse la dirección del argumento. La función llamada modifica entonces el valor del argumento del invocador mediante el operador de indirección (*)

!!!!""""Una función que recibe como argumento una dirección debe incluir un apuntador corno su parámetro correspondiente.

!!!!""""No es necesario incluir los nombres de los apuntadores en los prototipos de función; sólo es necesario incluir los tipos de apuntador. Los nombres de apuntador se pueden agregar con fines de documentación, pero el compilador los ignora.

!!!!""""El calificador const le permite al programador informarle al compilador que no se deberá modificar el valor de una variable en particular.

!!!!""""Si se intenta modificar un valor const, el compilador lo detecta y emite un aviso o un error, según el compilador de que se trate.

!!!!""""Hay cuatro maneras de pasar un apuntador a una función: mediante un apuntador no constante hacia datos no constantes, por medio de un apuntador no constante hacia datos constantes, utilizando un apuntador constante hacia datos no constantes y a través de un apuntador constante hacia datos constantes.

!!!!""""Los arreglos se pasan de manera automática por referencia, utilizando apuntadores, pues el valor del nombre del arreglo es la dirección del mismo.

!!!!""""Para pasar un solo elemento de un arreglo como llamada por referencia mediante apuntadores, es necesario pasar la dirección del elemento específico del arreglo.

!!!!""""C++ ofrece el operador unario especial sizeof, que determina el tamaño de un arreglo (o de cualquier otro tipo de datos) en bytes durante la compilación del programa.

!!!!""""Cuando se aplica al nombre de un arreglo, el operador sizeof devuelve, como entero, la cantidad total de bytes que hay en ella.

!!!!""""El operador sizeof se puede aplicar a cualquier nombre de variable, tipo o constante. !!!!""""Las operaciones aritméticas que se pueden llevar a cabo sobre los apuntadores son incremento (++),

decremento (--), suma (+ o + =) o resta (- o - =) de un apuntador y un entero, y resta de un apuntador a otro.

!!!!""""Cuando se suma o resta un entero a un apuntador, el apuntador se incremento o decrementa por dicho entero, multiplicado por el tamaño del objeto al que se apunta.

!!!!""""Las operaciones de aritmética de apuntadores sólo deben efectuarse sobre partes contiguas de la memoria, por ejemplo, sobre un arreglo. Todos los elementos de un arreglo se almacenan en localidades contiguas de memoria.



!!!!""""Al llevar a cabo aritmética de apuntadores sobre un arreglo de caracteres, el resultado es como el de la aritmética normal, pues cada carácter se almacena en un byte de memoria.

!!!!""""Se puede asignar un apuntador a otro si ambos son del mismo tipo. De otra manera, debe aplicarse una conversión mediante cast. La excepción a esto es un apuntador a void, que es un tipo de apuntador general que puede contener apuntadores de cualquier tipo. A los apuntadores a void se les puede asignar apuntadores de otros tipos. Es posible asignar un apuntador void a un apuntador de otro tipo sólo a través de una conversión mediante cast explícita.

!!!!""""No se puede desreferenciar un apuntador a void. !!!!""""Los apuntadores se pueden comparar por medio de los operadores de igualdad y relacionales. Las

comparaciones de apuntadores por lo general sólo tienen sentido si los apuntadores apuntan a miembros del mismo arreglo.

!!!!""""Los apuntadores se pueden indexar de la misma manera que los nombres de arreglos. !!!!""""Un nombre de arreglo es equivalente a un apuntador al primer elemento del mismo. !!!!""""En la notación de apuntador/desplazamiento, el desplazamiento es igual a un índice de arreglo. !!!!""""Todas las expresiones de arreglos indexadas se pueden escribir con un apuntador y un desplazamiento,

utilizando corno apuntador el nombre del arreglo o un apuntador separado que apunte a dicho arreglo. !!!!""""Un nombre de arreglo es un apuntador constante que siempre apunta a la misma localidad de memoria. !!!!""""Es posible tener arreglos de apuntadores. !!!!""""Un apuntador a una función es la dirección donde reside el código de la función. !!!!""""Los apuntadores a funciones pueden ser pasados a otras funciones, devueltos de otras funciones,

almacenados en arreglos y asignados a otros apuntadores. !!!!""""Un uso común de los apuntadores de función es en los llamados sistemas operados por menú. Los

apuntadores de función sirven para seleccionar la función a llamar según un elemento particular del menú. !!!!""""La función strcpy copia su segundo argumento (una cadena) a su primer argumento (un arreglo de

caracteres) El programador debe asegurarse de que el arreglo es lo bastante grande para almacenar la cadena y su carácter nulo de terminación.

!!!!""""La función strncpy es equivalente a strcpy, excepto que una llamada a strncpy especifica el número de caracteres a copiar de la cadena al arreglo. El carácter nulo de terminación sólo se copiará si el número de caracteres a copiar es de uno más que la longitud de la cadena.

!!!!""""La función strcat añade la cadena de su segundo argumento (incluyendo el carácter nulo de terminación) a la cadena de su primer argumento. El primer carácter de la segunda cadena reemplaza el carácter nulo ( ‘\0’ ) de la primera cadena. El programador debe asegurarse de que el arreglo en el que está la primera cadena es lo bastante grande para almacenar tanto la primera cadena como la segunda.

!!!!""""La función strncat agrega un número de caracteres especificado de la segunda cadena a la primera. Se añade un carácter nulo de terminación al resultado.

!!!!""""La función strcmp compara la cadena de su primer argumento con la cadena de su segundo argumento, carácter por carácter. La función devuelve 0 si ambas son iguales, un resultado negativo si la primera es menor que la segunda y un valor positivo si la primera es mayor que la segunda.

!!!!""""La función strncmp es equivalente a strcmp, excepto que strncmp compara un número especificado de caracteres. Si el número de caracteres de una cadena es menor que el número especificado, strncmp compara los caracteres hasta que se encuentra el carácter nulo en la cadena más corta.

!!!!""""Una secuencia de llamadas a strtok divide una cadena en tokens separados por los caracteres contenidos en el segundo argumento. La primera llamada contiene como primer argumento la cadena a dividir en tokens, y las llamadas siguientes que continúan dividiendo la misma cadena en tokens contienen NULL como primer argumento. Cada llamada devuelve un apuntador al token actual. Si no hay más tokens al llamar a strtok, se devuelve NULL.

!!!!""""La función strlen toma como argumento una cadena y devuelve el número de caracteres que hay en ella; en la longitud de la cadena no se incluye el carácter nulo de terminación.

!!!!""""Una cadena de caracteres es un arreglo de caracteres que terminan por los caracteres ASCII 0 o NULL. !!!!""""Puede crear una cadena de caracteres dentro de su programa mediante la declaración de un arreglo de tipo

char. !!!!""""Su programa es responsable de agregar el carácter NULL después del último carácter de la cadena.



!!!!""""Cuando su programa utiliza cadenas constantes entre comillas, el compilador C++ automáticamente agrega el carácter NULL.

!!!!""""C++ le permite inicializar las cadenas al declararlas, especificando los caracteres deseados entre comillas. !!!!""""La mayoría de los compiladores C++ proporcionan un conjunto de funciones para el manejo de cadenas en

las librerías en tiempo de ejecución. PREGUNTAS Y PROBLEMAS

PREGUNTAS 1. Llene los siguientes espacios en blanco:

a) Un apuntador es una variable que contiene como valor la ______________ de otra variable. b) Los tres valores que se pueden utilizar para inicializar un apuntador son __________, _________ y

____________. c) El único entero que se puede asignar a un apuntador es________________

2. Indique si las siguientes oraciones son verdaderas o falsas. Si la respuesta es falsa, explique por qué.

a) El operador de dirección & sólo puede aplicarse a constantes, a expresiones y a variables declaradas con la clase de almacenamiento register.

b) Se puede desreferenciar un operador declarado como void. c) No es posible asignar un apuntador de un tipo a otro de otro tipo sin una operación de conversión

mediante cast.

3. Responda las siguientes preguntas. Suponga que los números de punto flotante de precisión sencilla se almacenan en 4 bytes y que la dirección de inicio del arreglo está en la localidad 1002500 de la memoria. Cada parte del ejercicio debería utilizar el resultado de las partes previas, donde aplique.

a) Declare un arreglo de tipo float llamado numeros que tenga 10 elementos, los cuales deberá inicializar a

los valores 0.0, 1.1, 2.2, ..., 9.9. Suponga que la constante simbólica TAMANO se ha definido como10. b) Declare el apuntador nPtr que apunta a un objeto de tipo float. c) Imprima los elementos del arreglo numeros utilizando la notación de índices de arreglos. Emplee una

estructura for y suponga que se ha declarado la variable de control entera i. Imprima cada número con una posición de precisión a la derecha del punto decimal.

d) Dé dos instrucciones independientes que asignen la dirección de inicio del arreglo numeros a la variable de apuntador nPtr.

e) Imprima los elementos del arreglo numeros por medio de notación de apuntador/desplazamiento con el apuntador nPtr.

f) Imprima los elementos del arreglo numeros utilizando notación de apuntador/desplazamiento con el nombre del arreglo como apuntador.

g) Imprima los elementos del arreglo numeros indexando el apuntador nPtr. h) Haga referencia al elemento 4 del arreglo numeros empleando notación de índices de arreglos, notación

de apuntador/desplazamiento con el nombre del arreglo como apuntador, notación de índice de apuntador con nPtr y notación de apuntador/desplazamiento con nPtr.

i) Suponiendo que nPtr apuntara al inicio del arreglo numeros, ¿a qué dirección hace referencia nPtr + 8? ¿Qué valor se almacena en dicha localidad?

j) Suponiendo que nPtr apunte a numeros[5], ¿qué dirección referencia nPtr después de que se ejecuta nPtr -= 4?. ¿Qué valor se almacena en esa localidad?

4. Escriba una sola instrucción que lleve a cabo la tarea indicada para cada uno de los siguientes casos. Suponga

que ya se han declarado las variables de punto flotante numero1 y numero2, y que numero1 se ha inicializado a 7.3. También suponga que la variable ptr es de tipo char * y que los arreglos s1[100] s2[100] son de tipo char.

a) Declare la variable fPtr como apuntador a un objeto de tipo float. b) Asígnele a la variable de apuntador fPtr la dirección de la variable numero1. c) Imprima el valor del objeto al que apunta fPtr. d) Asígnele a la variable numero2 el valor del objeto al que apunta fPtr.



e) Imprima el valor de numero2. f) Imprima la dirección de numero1. g) Imprima la dirección almacenada en fPtr. ¿El valor que se imprime es igual a la dirección de numero1? h) Copie la cadena almacenada en el arreglo s2 al arreglo s1. i) Compare la cadena en s1 con la cadena en s2. Imprima el resultado. j) Agregue 10 caracteres de la cadena de s2 a la cadena de s1. k) Determine la longitud de la cadena de s1. Imprima el resultado. l) Asígnele a ptr la localidad del primer token de s2. Los tokens de s2 se separan mediante comas (,).

5. Haga lo siguiente:

a) Escriba el encabezado de una función llamada intercambio(), que toma como parámetros los apuntadores a los números de punto flotante x e y y que no devuelve nada.

b) Escriba el prototipo de la función de la parte (a). c) Escriba el encabezado de una función llamada evaluar(), que devuelve un entero y toma como parámetros

el entero x y un apuntador a la función poly. Ésta toma un parámetro entero y devuelve un entero. d) Escriba el prototipo de función de la parte (c) e) Muestre dos métodos diferentes para inicializar el arreglo de caracteres vocal con la cadena de vocales

“AEIOU”. 6. Encuentre los errores en los siguientes segmentos de programa. Suponga que

int *zPtr; // zPtr referenciará el arreglo z int *aPtr = 0; void *sPtr = 0; int numero, i; int z[5] = { 1, 2, 3, 4, 5} sPtr = z;

a) ++zPtr; b) // Utiliza el apuntador para obtener el primer valor del arreglo numero = zPtr; c) // le asigna a numero el elemento 2 del arreglo (el valor 3)

a. numero = *zPtr[ 2]; d) // imprime todo el arreglo z

a. for ( i = 0; i <= 5; i++ ) i. cout << zPtr[ i ] << endl;

e) // le asigna a numero el valor al que apunta sPtr f) numero = *sPtr; g) ++z; h) char s[10]; i) cout << strncpy( s, “adios”, 5) << endl; j) char s[12]; k) strcpy( s, “Bienvenido a casa”); l) if( strcmp( cadena1, cadena2))

cout << “Las cadenas son iguales” << endl; 7. ¿Qué imprimen las siguientes instrucciones cuando se ejecutan (si es que imprimen algo)? Si alguna de estas

contiene un error, descríbalo e indique la manera de corregirlo. Suponga las siguientes declaraciones de variables:

char s1[50] = “jack”, s2[50] = “jill”, s3[50], *sptr;

a) cout << strcpy(s3, s2) << endl; b) cout << strcat(strcat(strcpy(s3, s1), “ and “ ), s2) << endl; c) cout << strlen(s1) + strlen(s2) << endl; d) cout << strlen(s3) << endl;



8. Indique si las siguientes oraciones son verdaderas o falsas. Si la respuesta es falsa, explique por qué.

a) La comparación de dos apuntadores que apuntan a arreglos diferentes no tiene sentido. b) Debido a que el nombre de un arreglo es un apuntador al primer elemento de dicho arreglo, los nombres

de arreglo deben manipularse de la misma manera que los apuntadores.

9. Conteste a lo siguiente. Suponga que los enteros sin signo se almacenan en 2 bytes y que la dirección inicial del arreglo es la localidad 1002500 de la memoria.

a) Declare un arreglo de tipo unsigned int llamado valores que cuente con 5 elementos, los cuales deberá

inicializar a los enteros pares del 2 al 10. Suponga que la constante simbólica se ha definido como 5. b) Declare el apuntador vPtr que apunta a un objeto de tipo unsigned int. c) Imprima los elementos del arreglo valores utilizando notación de índices de arreglo. Emplee una

estructura for y suponga que se ha declarado la variable de control entera i. d) Escriba dos instrucciones separadas que asignen la dirección inicial del arreglo valores a la variable de

apuntador vPtr. e) Imprima los elementos del arreglo valores utilizando notación de apuntador/desplazamiento. f) Imprima los elementos del arreglo valores utilizando notación de apuntador/desplazamiento con el

nombre del arreglo como apuntador. g) Imprima los elementos del arreglo valores indexando el apuntador al arreglo. h) Haga referencia al elemento 5 de valores utilizando notación de índices de arreglo, notación de

apuntador/desplazamiento con el nombre del arreglo como apuntador, notación de índices de apuntador y notación de apuntador/desplazamiento.

i) ¿A qué dirección hace referencia vPtr + 3? ¿Qué valor se almacena en dicha localidad? j) Suponiendo que vPtr apunte a valores[4], ¿a qué dirección hace referencia vPtr -= 4? ¿Qué valor se

almacena en dicha localidad? 10. Para cada uno de los siguientes puntos, escriba una instrucción que lleve a cabo la tarea indicada. Suponga que

se han declarado las variables enteras largas valor1 y valor2, y que valor1 se ha inicializado a 200000.

a) Declare la variable lPtr como apuntador a un objeto de tipo long. b) Asigne la dirección de la variable valor1 a la variable de apuntador lPtr. c) Imprima el valor del objeto al que apunta lPtr. d) Asígnele a la variable valor2 el valor del objeto al que apunta lPtr. e) Imprima el valor de valor2. f) Imprima la dirección de valor1. g) Imprima la dirección almacenada en lPtr. ¿Es igual el valor impreso que la dirección de valor1?

11. Haga lo siguiente.

a) Escriba el encabezado de la función cero, que toma como parámetro el arreglo de enteros largos enterosLargos y no devuelve nada.

b) Escriba el prototipo de la función de la parte (a) c) Escriba el encabezado de la función agrega1YSuma, que toma como parámetro el arreglo de enteros

demasiadoPequeno y devuelve un entero. d) Escriba el prototipo de la función descrita en la parte (c)



PROBLEMAS Nota: Los problemas 1 a 4 son algo complejos. Una vez que los haya hecho, debería poder implementar con

facilidad los juegos de naipes más comunes.

1. Modifique el programa BARAJAS.CPP, para que la función de barajado de los naipes reparta una mano de póquer de cinco naipes. Después escriba las funciones que realicen lo siguiente:

a) Determine si la mano contiene un par. b) Determine si la mano contiene dos pares. c) Determine si la mano contiene una tercia (por ejemplo, tres sotas) d) Determine si la mano contiene un póquer (por ejemplo, cuatro ases) e) Determine si la mano contiene un flux (es decir, los cinco naipes del mismo palo) f) Determine si la mano contiene una corrida (es decir, cinco naipes del mismo palo con valores

consecutivos) 2. Utilice las funciones desarrolladas en el problema 1 para escribir un programa que reparta dos manos de

póquer de cinco naipes, las evalúe y determine cuál es la mejor. 3. Modifique el problema desarrollado en el problema 2 de modo que simule al repartidor. La mano del repartidor

se baraja cerrada, para que el jugador no la pueda ver. El programa deberá evaluar dicha mano y, con base en su calidad, cambiar las inservibles de la mano original por uno, dos o tres naipes. El programa deberá reevaluar la mano del repartidor. (Precaución: éste es un problema complicado)

4. Modifique el programa desarrollado en el problema 3 para que pueda manejar automáticamente la mano del

repartidor, pero que le permita al jugador decidir cuáles de los naipes de su propia mano cambiará. El programa deberá evaluar ambas manos y decidir quién gana. Ahora utilice este nuevo programa para jugar 20 juegos contra la computadora. ¿Quién gana más juegos, usted o la computadora? Haga que uno de sus amigos juegue 20 juegos contra la computadora. ¿Quién gana más juegos? Con base en estos resultados, haga las modificaciones necesarias para refinar el programa de póquer (éste también es un problema difícil) Juegue 20 juegos más. ¿El programa modificado juega mejor?

5. En el programa de barajado y repartición de naipes BARAJAS.CPP, utilizamos intencionalmente un algoritmo

de barajado ineficiente que presentó la posibilidad de aplazamiento indefinido. En este problema, creará un algoritmo de barajado de alto desempeño que evite el aplazamiento indefinido.

Modifique el programa BARAJAS.CPP, como sigue. Inicialice el arreglo paquete como se muestra en la figura 20.10 . Modifique la función barajar() para que haga un ciclo fila por fila y columna por columna a través del arreglo, tocando una vez todos los elementos. Cada elemento debe intercambiarse con otro elemento del arreglo seleccionado al azar. Imprima el arreglo resultante para determinar si se barajó de manera adecuada (como en la figura 20.11, por ejemplo) Tal vez desee que el programa llame varias veces a la función barajar(), a fin de asegurar un barajado satisfactorio. Note que, aunque este enfoque mejor el algoritmo de barajado, éste aún tiene que buscar en el arreglo paquete el naipe 1, luego el 2, el 3, etc. Es más, aún después de que el algoritmo de barajado encuentra y reparte el naipe, sigue buscando en el resto de los naipes. Modifique el programa BARAJAS.CPP para que, una vez repartido un naipe, no se hagan mas intentos por encontrarlo, procediendo de inmediato a repartir el siguiente.

Arreglo paquete sin barajar 0 1 2 3 4 5 6 7 8 9 10 11 12

0 1 2 3 4 5 6 7 8 9 10 11 12 13 1 14 15 16 17 18 19 20 21 22 23 24 25 26 2 27 28 29 30 31 32 33 34 35 36 37 38 39 3 40 41 42 43 44 45 46 47 48 49 50 51 52

Figura 20.10. Arreglo paquete sin barajar



Ejemplo del arreglo paquete sin barajado 0 1 2 3 4 5 6 7 8 9 10 11 12

0 19 40 27 25 36 46 10 34 35 41 18 2 44 1 13 28 14 16 21 30 8 11 31 17 24 7 1 2 12 33 15 42 43 23 45 3 29 32 4 47 26 3 50 38 52 39 48 51 9 5 37 49 22 6 20

Figura 20.11. Ejemplo del arreglo paquete sin barajado

6. (Simulación: la tortuga y la liebre) En este problema, recreará la carrera clásica de la tortuga y la liebre. Se

valdrá de la generación de números aleatorios para desarrollar la simulación de este memorable evento.

Nuestros contendientes comienzan la carrera en el cuadro 1 de una serie de 70 cuadros. Cada cuadro representa una posición posible en la ruta de la carrera. La línea de meta está en el cuadro 70. El primer contendiente que llegue o pase el cuadro 70 obtiene como recompensa un cubo de zanahorias y lechuga fresca. La ruta sube serpenteando por la ladera de una montaña resbalosa, por lo que ocasionalmente los contendientes pierden terreno. Hay un reloj que pulsa una vez por segundo. Con cada pulso del reloj, el programa deberá ajustar la posición de los animales, de acuerdo con las siguientes reglas:

Animal Tipo de movimiento Porcentaje del tiempo Movimiento real

Tortuga Paso veloz 50% 3 cuadros a la derecha Resbalón 20% 6 cuadros a la izquierda Paso lento 30% 1 cuadro a la derecha Liebre Duerme 20% No se mueve Gran salto 20% 9 cuadros a la derecha Gran resbalón 10% 12 cuadros a la izquierda Salto pequeño 30% 1 cuadro a la derecha Resbalón pequeño 20% 2 cuadros a la izquierda Utilice variables para llevar el registro de las posiciones de los animales (las posiciones son de la 1 a la 70) Cada animal debe comenzar en la posición 1 (es decir, la puerta de salida) Si un animal resbala hacia la izquierda, quedando antes del cuadro 1, devuélvalo al cuadro 1. Genere los porcentajes de la tabla previa produciendo un entero aleatorio, i, que esté en el rango 1 ≤≤≤≤ i ≤≤≤≤ 10. Para la tortuga, efectúe un paso veloz cuando 1 ≤≤≤≤ i ≤≤≤≤ 5, un resbalón cuando 6 ≤≤≤≤ i ≤≤≤≤ 7 y un paso lento cuando 8 ≤≤≤≤ i ≤≤≤≤ 10. Utilice una técnica similar para mover a la liebre. Comience la carrera imprimiendo

¡BANG! ¡Y ARRANCAN!

Por cada pulso del reloj (es decir, cada repetición del ciclo), imprima una línea de 70 posiciones que muestre la posición de la tortuga mediante la letra T y la de la liebre mediante la letra L. Ocasionalmente los contendientes caerán en el mismo cuadro. En este caso, la tortuga morderá a la liebre y el programa deberá imprimir ¡OUCH! en tal posición. Todas las posiciones de impresión que no sean T, L ni ¡OUCH! (en caso de empate), deben estar en blanco. Después de la impresión de cada línea, pruebe si alguno de los animales ha llegado o pasado el cuadro 70. De ser así, imprima el ganador y termine la simulación. Si la tortuga gana, imprima ¡LA TORTUGA GANA! ¡BRAVO! Si la liebre gana, imprima La liebre gana. Ni hablar. Si ambos animales llegan a la meta con el mismo pulso de reloj, tal vez usted quiera favorecer a la tortuga (el desvalido) o imprimir Es un empate. Si ninguno de los animales gana, vuelva a efectuar el ciclo, simulando el siguiente pulso del reloj.



SECCIÓN ESPECIAL: Construya su propia computadora

En los siguientes problemas nos desviaremos temporalmente del mundo de la programación con lenguajes de alto nivel. Abriremos una computadora y veremos su estructura interna. Presentaremos la programación en lenguaje de máquina y escribiremos varios programas en dicho lenguaje. Para hacer que esta sea una experiencia especialmente valiosa, después construiremos una computadora (por medio de la técnica de simulación basada en software) en la que podrá ejecutar sus programas en lenguaje de máquina.

7. (Programación en lenguaje de máquina) Crearemos una computadora a la que llamaremos Simpletron. Como

su nombre implica, es una máquina sencilla, pero como pronto veremos, también es poderosa. La Simpletron ejecuta programas escritos en el único lenguaje que entiende directamente; es decir, el lenguaje de máquina Simpletron, o SML.

La Simpletron contiene un acumulador -es decir, un registro especial en el que se coloca la información antes de que la Simpletron la tome para efectuar cálculos o examinarla de varias maneras. Toda la informa de la Simpletron se maneja en términos de palabras. Una palabra es un número decimal de cuatro dígitos con signo, como +3364, -1293, +0007, -0001, etc. La Simpletron viene equipada con una memoria de 100 palabras, las cuales se referencian por su número de localidad: 00, 01, ..., 99.

Antes de ejecutar un programa SML, debemos cargar el programa en memoria. La primera instrucción de cada programa SML siempre queda en la localidad 00. El simulador comenzará la ejecución a partir de localidad.

Cada instrucción en SML, ocupa una palabra de la memoria de la Simpletron (por lo tanto, las instrucciones son números decimales de cuatro dígitos con un signo) Supondremos que el signo de una instrucción SML siempre es positivo, pero el signo de una palabra de datos puede ser positivo o negativo. Cada localidad de la memoria de la Simpletron puede contener una instrucción, un valor de datos utilizado por el programa o un área no utilizada (y, por lo tanto, indefinida) de la memoria. Los primeros dos dígitos de cada instrucción SML son el código de operación, que especifica que se llevará a cabo. Los códigos de operación de SML aparecen en la figura 20.12.

Código de operación Significado

Operaciones de entrada/salida:

const int READ = 10; Lee a palabra del teclado y la pone en una localidad específica de la memoria

const int WRITE = 11; Escribe en la pantalla la palabra ubicada en una localidad específica de memoria.

Operaciones de carga/almacenamiento:

const int LOAD = 20; Carga en el acumulador la palabra ubicada en una localidad específica de memoria.

Const int STORE = 21; Almacena la palabra que se encuentra en el acumulador en una localidad específica de memoria.

Operaciones aritméticas:

const int ADD = 30; Suma la palabra ubicada en una localidad específica de memoria a la palabra que se encuentra en el acumulador (deja el resultado en el acumulador).

const int SUBTRACT = 31; Resta la palabra ubicada en una localidad específica de memoria de la palabra que se encuentra en el acumulador (deja el resultado en el acumulador).

const int DIVIDE = 32; Divide la palabra ubicada en una localidad específica de memoria entre la palabra que se encuentra en el acumulador (deja el resultado en el acumulador).

const int MULTIPLY = 33; Multiplica la palabra ubicada en una localidad específica de memoria por la palabra que se encuentra



Código de operación Significado

en el acumulador (deja el resultado en el acumulador).

operaciones de transferencia de control:

const int BRANCH = 40; Bifurca a una localidad específica de memoria.

const int BRANCHNEG = 41; Bifurca a una localidad específica de memoria si el acumulador es negativo.

const int BRANCHZERO = 41; Bifurca a una localidad específica de memoria si el acumulador es igual a cero.

const int HALT = 43; Termina, el programa ha completado su trabajo.

Figura 20.12. Códigos de Operación del lenguaje de máquina Simpletron

Los últimos dos dígitos de las instrucciones SML son el operando (la dirección de la localidad específica de memoria que contiene la palabra a la que se aplica la operación) Ahora consideremos varios programas SML sencillos. El primero (ejemplo 1) lee del teclado dos números y calcula e imprime su suma. La instrucción +1007 lee el primer número y lo pone en la localidad 07 (la cual ha sido inicializada a cero) La instrucción +1008 lee el siguiente número, colocándolo en la localidad 08. La instrucción load, +2007, pone (copia) en el acumulador el primer número y la instrucción add, +3008, suma el segundo número al que se encuentra en el acumulador. Todas las instrucciones aritméticas de SML dejan sus resultados en el acumulador. La instrucción store, +2109, pone (copia) el resultado en la localidad de memoria 09, de donde la toma la instrucción write, +1109, y lo imprime (como número decimal de cuatro dígitos con signo) La instrucción halt, +4300, termina la ejecución.

Ejemplo 1 Localidad

Número

Instrucción

00 +1007 (Lee A) 01 +1008 (Lee B) 02 +2007 (Carga A) 03 +3008 (Suma B) 04 +2109 (Almacena C) 05 +1109 (Escribe C) 06 +4300 (Terminación) 07 +0000 (Variable A) 08 +0000 (Variable B) 09 +0000 (Resultado C)

El programa SML del ejemplo 2 lee del teclado dos números y determina e imprime el valor más alto. Note que la instrucción +4107 se utiliza como transferencia de control condicional, a semejanza de la instrucción if de C++.

Ejemplo 2 Localidad

Número

Instrucción

00 +1009 (Lee A) 01 +1010 (Lee B) 02 +2009 (Carga A) 03 +3110 (Resta B) 04 +4107 (Bifurca con negativo a 07) 05 +1109 (Escribe A) 06 +4300 (Terminación) 07 +1110 (Escribe B) 08 +4300 (Terminación) 09 +0000 (Variable A) 10 +0000 (Variable B)



Ahora escriba programas en SML que lleven a cabo las siguientes actividades.

a) Mediante un ciclo controlado por centinela lea 10 números positivos y calcule e imprima su suma. b) Mediante un ciclo controlado por contador, lea siete números, algunos positivos y otros negativos, y

calcule e imprima su promedio. c) Lea una serie de números y determine e imprima el mayor. El primer número indicará la cantidad de

números a procesar. 8. (Simulador de computadora) Al principio parecerá un tanto pretencioso, pero en este problema va a construir

su propia computadora. No, no se encargará de soldar sus componentes. En cambio, se valdrá de la poderosa técnica de la simulación basada en software para crear un modelo en software de la Simpletron. No sé decepcionará. Su simulador convertirá en una Simpletron a la computadora en la que esté trabajando y usted de hecho podrá ejecutar, probar y depurar los programas SML que escribió en el problema 18.

Cuando ejecute su simulador Simpletron, deberá comenzar por imprimir: *** ¡Bienvenidos a Simpletron! *** *** Por favor introduzca su programa una instrucción *** *** (o dato) a la vez. Presentaré *** *** la localidad y un signo de interrogación (?) . *** *** Después usted tecleará la palabra para esa localidad. *** *** Para detener la introducción de su programa, *** *** teclee el centinela -99999. *** Simule la memoria de la Simpletron con el arreglo memoria de un solo índice, que tiene 100 elementos. Supongamos ahora que está ejecutándose el simulador y examinemos el diálogo a medida que ingresamos el programa del ejemplo 2 del ejercicio 18:

00 ? +1009 01 ? +1010 02 ? +2009 03 ? +3110 04 ? +4107 05 ? +1109 06 ? +4300 07 ? +1110 08 ? +4300 09 ? +0000 10 ? +0000 11 ? -99999 12 *** Se ha completado la carga del programa *** *** Inicia la ejecución del programa ***

El programa SML ha sido colocado (o cargado) en el arreglo memoria. Ahora la Simpletron ejecuta su programa SML. La ejecución inicia con la instrucción de la localidad 00 y, como C++, continúa secuencialmente, a menos que se le dirija a otra parte del programa mediante una transferencia de control. Mediante la variable acumulador represente el registro del acumulador. Emplee la variable contador para llevar el registro de la localidad de memoria que contiene la instrucción en ejecución. En la variable codigoOperacion indique la operación actual, es decir, los dos dígitos de la izquierda de la palabra de instrucción. Mediante la variable operando indique la localidad de memoria sobre la que opera la instrucción actual. Así, operando está formado por los dos dígitos más a la derecha de la instrucción que se está ejecutando en el momento. No ejecute las instrucciones directamente en la memoria. En cambio, transfiera la siguiente instrucción a ejecutar de la memoria a una variable llamada registroInstruccion. Luego tome los dos dígitos de la izquierda, poniéndolos en codigoOperacion, y tome los dos de la derecha y colóquelos en operando. Cuando comienza la operación de la Simpletron, los registros especiales se inicializan a 0.



Ahora hagamos el recorrido por la ejecución de la primera instrucción SML, +1009. que está en la localidad de memoria 00. A esto se le llama ciclo de ejecución de instrucción. contador nos dice la localidad de la siguiente instrucción a ejecutar. Obtenemos de la memoria el contenido de dicha localidad mediante la instrucción de C++.

registroInstruccion = memoria[contador];

El código de operación y el operando se extraen del registro de instrucciones por medio de las instrucciones:

codigoOperacion = registroInstruccion / 100; operando = registroInstruccion %100; Ahora la Simpletron deberá determinar que el código de operación es en realidad una read, o lectura, (en lugar de write, load, etc.) Una switch se encarga de diferenciar las doce operaciones de SML. En la estructura switch se simula el comportamiento de varias instrucciones SML como sigue (dejaremos las demás para que las resuelva el lector):

read: cin >> memoria[ operando]; load: acumulador = memoria[operando]; add: acumulador += memoria[operando]; branch: Pronto estudiaremos las instrucciones de bifurcación halt: Esta instrucción imprime el mensaje

*** Ha terminado la ejecución de Simpletron ***

y luego imprime el nombre y contenido de los registros, así como el contenido completo de la memoria. Tal impresión con frecuencia es conocida como vaciado de computadora. Para ayudarle a programar su función de vaciado, la figura 20.13 muestra un ejemplo de formato de vaciado. Observe que el vaciado tras la ejecución del programa Simpletron mostraría los valores reales de las instrucciones y de los datos al momento de terminación de la ejecución. Prosigamos con la ejecución de la primera instrucción de nuestro programa: +1009 en la localidad 00. Como hemos indicado, la instrucción switch simula esto ejecutando la instrucción C++:

cin >> memoria[ operando ];

Antes de la ejecución de cin, se deberá presentar un signo de interrogación (?) en la pantalla, para pedirle al usuario una entrada. La Simpletron espera a que el usuario introduzca un valor y oprima la tecla Retorno. El valor queda en la localidad 09. En este punto se ha completado la simulación de la primera instrucción. Lo que queda es preparar a Simpletron para que ejecute la siguiente instrucción. Dado que la instrucción que se acaba de ejecutar no fue una transferencia de control, simplemente necesitamos incrementar el registro del contador de instrucciones como sigue:

++contador;

Con esto se completa la ejecución simulada de la primera instrucción. El proceso completo (es decir, el ciclo de ejecución de instrucción) inicia nuevamente con la obtención de la siguiente instrucción a ejecutar. Ahora consideremos la manera como se simulan las instrucciones de bifurcación (las transferencias de control) Todo lo que necesitamos hacer es ajustar el valor de contador de instrucciones. Por lo tanto, se simula la instrucción de bifurcación incondicional (40) dentro de switch con:

contador = operando;

La instrucción condicional bifurca si el acumulador es igual a cero se simula con:



if ( acumulador == 0) contador = operando;

En este punto, usted deberá implementar el simulador Simpletron y ejecutar los programo SML que escribió en el problema 18. Puede embellecer el SML con características adicionales e incluirlas en su simulador. El simulador deberá buscar varios tipos de errores. Durante la fase de carga del programa, por ejemplo, cada número tecleado por el usuario para memoria deberá estar en el rango de -9999 a +9999. El simulador deberá comprobar mediante un ciclo while que cada número digitado esté en este rango y, si no, solicitar al usuario que lo vuelva a teclear hasta que esté correcto.

+0000 00 +0000 00

REGISTROS acumulador contador registroInstrucción codigoOperacion operando 00 MEMORIA 0 1 2 3 4 5 6 7 8 9

0 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 10 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 20 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 30 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 40 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 50 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 60 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 70 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 80 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 90 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000 +0000

Figura 20.13. Ejemplo de vaciado

Durante la fase de ejecución, el simulador deberá buscar varios errores serios, como división entre cero, códigos de ejecución inválidos, sobrecargas del acumulador (es decir, operaciones aritméticas que den valores mayores que +9999 o menores que -9999) y otros. Tales errores serios se llaman errores fatales. Al detectar un error fatal, el simulador deberá imprimir un mensaje de error como:

*** Intento de dividir entre cero *** *** Terminación anormal de Simpletron ***

así como un vaciado completo con el formato que indicamos previamente. Con él se ayudará al usuario a localizar el error en el programa.

MÁS PROBLEMAS DE APUNTADORES 9. Modifique el programa de barajado y repartición de naipes del programa BARAJAS.CPP, para que las

operaciones de barajado y repartición se lleven a cabo mediante la misma función (barajarRepartir()) La función deberá contener una estructura de ciclo anidada semejante a la función barajar() del programa BARAJAS.CPP.



10. ¿Qué hace este programa? 11. ¿Qué hace este programa? 12. Encuentre el error en los siguientes segmentos de programa. Si es posible corregir el error, explique cómo. 13.

a) int * numero; b) cout << numero << endl; c) float *realPtr; d) long *enteroPtr; e) enteroPtr = realPtr; f) int *x, y; g) x = y;

// Problema21.cpp #include <iostream.h> //Para cout y cin void misterio1(char *, const char *); void main(void) { char cadena1[80], cadena2[80]; cout << “Introduzca dos cadenas de caracteres: ”; cin >> cadena1 >> cadena2; misterio1(cadena1, cadena2); cout << cadena1 << endl; }//Fin de main() void misterio1(char *s1, const char *s2) { while(*s1 != ‘\0’) ++s1; for(; *s1 = *s2; s1++, s2++) ; //Instrucción vacía }//Fin de misterio1()

//Problema11.cpp #include <iostream.h> //Para cout y cin int misterio2(const char *); void main(void) {

char cadena[80]; cout << “Introduzca una cadena de caracteres: ”; cin >> cadena; cout << misterios2(cadena) << endl;

}//Fin de main() int misterio2(const char *s) {

for(int x = 0; *s != ‘\0’; s++) ++x;

return x; }//Fin de misterio2()



h) char s[] = “éste es un arreglo de caracteres”; i) for(; *s != ‘\0’; s++)

cout << *s << ‘ ’ ; j) short *numPtr, resultado; k) void *genericPtr = numPtr;

a. result = *genericPtr + 7; l) float x = 19.34; m) float xPtr = &x; n) cout << xPtr << endl; o) char *s; p) cout << s << endl;

14. (Quicksort) En los ejemplos y ejercicios de la lección 19 estudiamos las técnicas de ordenamiento de burbuja, ordenamiento en cubetas y ordenamiento por selección. Ahora presentamos la técnica recursiva de ordenamiento llamada Quicksort. El algoritmo básico para un arreglo de un solo índice es el siguiente:

a) Paso de particionamiento: tome el primer elemento del arreglo desordenado y determine su localidad

final en el arreglo ordenado, es decir, que todos los valores a la izquierda del elemento sean menores que él y todos los valores a la derecha sean mayores. Ahora tenemos un elemento en su lugar correcto y dos subarreglos desordenados.

b) Paso recursivo: Efectúe el paso 1 sobre cada subarreglo desordenado.

Cada vez que se ejecuta el paso 1 sobre un subarreglo, se coloca otro elemento en su destino final en el arreglo ordenado y se crean dos subarreglos desordenados. Cuando un subarreglo consiste de un elemento, debe estar ordenado, por lo que dicho elemento está en su ubicación final. El algoritmo básico parece bastante sencillo, pero ¿cómo determinamos la posición final del primer elemento de cada subarreglo? Como ejemplo, considere el siguiente conjunto de valores (el elemento en negritas es el elemento de particionamiento; se colocará en su posición en el arreglo ordenado):

37 2 6 4 89 8 10 12 68 45

c) Comenzando por el elemento más a la derecha del arreglo, compare cada elemento contra 37 hasta que encuentre uno menor que 37, luego intercambie 37 y dicho elemento. El primer elemento menor que 37 es 12, por lo que 37 y 12 se intercambian. El nuevo arreglo queda así:

12 2 6 4 89 8 10 37 68 45

El elemento 12 está en cursivas, indicando que se acaba de intercambiar con 37.

d) Comenzando por la izquierda del arreglo, pero iniciando con el elemento que sigue a 12, compare cada elemento contra 37 hasta que se encuentre uno mayor que 37, luego intercambie 37 y dicho elemento. El primer elemento mayor que 37 es 89, por lo que 37 y 89 se intercambian. El nuevo arreglo queda como:

12 2 6 4 37 8 10 89 68 45

e) Comenzando por la derecha, pero iniciando con el elemento anterior a 89, compare los demás elementos

con 37 hasta encontrar uno menor que 37, luego intercambie 37 y dicho elemento. El primer elemento menor que 37 es 10, por lo que 37 y 10 se intercambian. El nuevo arreglo queda como:

12 2 6 4 10 8 37 89 68 45

f) Comenzando por la izquierda, pero iniciando con el elemento que sigue a 10, compare los elementos

contra 37 hasta encontrar uno mayor que 37, luego intercambie 37 y dicho elemento. No hay más elementos mayores que 37, así que, cuando comparamos 37 contra él mismo, sabemos que está en su destino final en el arreglo ordenado.

Una vez aplicada la partición al arreglo anterior, quedan dos arreglos desordenados, El subarreglo con valores menores que 37 contiene 12, 2, 6, 4, 10 y 8. El subarreglo con valores mayores que 37 contiene 89, 68 y 45. El ordenamiento continúa con el particionamiento de ambos arreglos de la misma manera que el arreglo original.



Basándose en el análisis anterior, escriba la función recursiva quicksort() que ordena un arreglo de enteros con un solo índice. La función deberá recibir como argumentos un arreglo de enteros, un índice inicial y un índice final. quicksort() deberá llamar a la función partición() para que lleve a cabo el paso de particionamiento. 14. (Recorrido por un laberinto) El siguiente tramado de # y puntos ( . ) es un arreglo de doble índice que

representa un laberinto.

# # # # # # # # # # # # # . . . # . . . . . . # . . # . # . # # # # . # # # # . # . . . . # . # # . . . . # # # . # . . # # # # . # . # . # . # # . . # . # . # . # . # # # . # . # . # . # . # # . . . . . . . . # . # # # # # # # . # # # . # # . . . . . . # . . . # # # # # # # # # # # # #

En este arreglo de doble índice, los # representan las paredes del laberinto y los puntos los cuadros de las rutas posibles a través del laberinto. Sólo se pueden hacer movimientos a una localidad del arreglo que contenga un punto.

Hay un algoritmo sencillo de recorrido del laberinto que garantiza encontrar la salida (suponiendo que la hay) Si no la hay, usted llegará nuevamente al punto de inicio. Ponga su mano derecha sobre la pared que está a su derecha y avance. Nunca quite su mano de la pared. Si el laberinto da la vuelta a la derecha, siga por la pared de la derecha. Siempre y cuando no quite su mano de la pared, tarde o temprano llegará a la salida del laberinto. Podría haber una ruta más corta que la que ha tomado, pero está garantizado que saldrá del laberinto si sigue este algoritmo. Escriba la función recursiva travesia() que lo guiará por el laberinto. La función deberá recibir como argumentos un arreglo de caracteres de 12 por 12 que represente el laberinto, así como el punto de inicio de dicho laberinto. A medida que travesia() intente localizar la salida del laberinto, deberá poner una x en cada cuadro de la ruta. La función deberá desplegar el laberinto después de cada movida, de modo que el usuario pueda ver cómo se resuelve el problema.

15. (Generación aleatoria de laberintos) Escriba la función generadorLaberinto(), que toma como argumento un

arreglo de caracteres de 12 por 12 y genera aleatoriamente un laberinto. Dicha función deberá proporcionar el punto de inicio y el de terminación del laberinto. Pruebe la función travesía() del problema 25 sobre varios laberintos generados al azar.

16. (Laberintos de cualquier tamaño) Generalice las funciones travesia() y generadorLaberinto() de los

problemas 14 y 15 para que procesen laberintos de cualquier anchura y altura. 17. (Arreglos de apuntadores a funciones) Rescriba el programa FUNARRE3.CPP, (de la lección 19, página 50)

para que opere mediante una interfaz operada por menú. El programa deberá ofrecer las siguientes 5 opciones al usuario, como sigue (deben aparecer en la pantalla):

Introduzca una opción: 0. Imprimir un arreglo de calificaciones 1. Encontrar la mínima calificación 2. Encontrar la máxima calificación 3. Imprimir el promedio de cada estudiante 4. Finalizar el programa

Una restricción al uso de arreglos de apuntadores a funciones es que todos los apuntadores deben ser del mismo tipo. Los apuntadores deben ser a funciones del mismo tipo de devolución y que reciban argumentos



del mismo tipo. Por esta razón, las funciones del programa FUNARRE3.CPP se deben modificar para que todas devuelvan el mismo tipo y tomen los mismos parámetros. Modifique las funciones minimo() y máximo() de modo que impriman el valor mínimo o máximo y no devuelvan nada. En la opción 3, modifique la función promedio() del programa FUNARRE3.CPP para que envíe a la salida el promedio de cada estudiante (no de uno específico) La función promedio() no deberá devolver nada y deberá tomar los mismos parámetros que mostrarArreglo(), minimo() y máximo(). Almacene los apuntadores a las cuatro funciones en el arreglo procesarOpcion() y tome la selección del usuario como el índice del arreglo para llamar a cada función.

18. (Modificaciones al simulador Simpletron) En el problema 7 se escribió un simulador en software de una computadora que ejecuta programas escritos en el SML (lenguaje de máquina Simpletron) En este problema proponemos vanas modificaciones y mejoras al simulador Simpletron. Algunas de las siguientes modificaciones y mejoras podrían ser necesarias para ejecutar los programas generados por el compilador.

a) Aumente la memoria del simulador Simpletron de modo que contenga 1000 localidades de memoria,

permitiendo el manejo de programas más extensos. b) Haga que el simulador pueda efectuar cálculos de módulo. Esto requiere una nueva instrucción en el

lenguaje de máquina Simpletron. c) Permita que el simulador realice cálculos de exponenciación. Esto requiere una nueva instrucción en el

lenguaje de máquina Simpletron. d) Modifique el simulador para que emplee valores hexadecimales, en lugar de valores enteros, para

representar instrucciones en lenguaje de máquina Simpletron. e) Modifique el simulador de modo que permita enviar a la salida un salto de línea. Esto requiere una nueva

instrucción en el lenguaje de máquina Simpletron. f) Modifique el simulador para que procese valores de punto flotante, además de valores enteros. g) Modifique el simulador a fin de que maneje entrada de cadenas. Sugerencia: es posible dividir cada

palabra Simpletron en dos grupos, conteniendo cada una un entero de dos dígitos. Cada entero de dos dígitos representa el equivalente decimal ASCII de un carácter. Agregue una instrucción en lenguaje de máquina que acepte la entrada de una cadena y la almacene a partir de cierta localidad de memoria de la Simpletron. La primera mitad de la palabra en dicha localidad será la cuenta del número de caracteres de la cadena (es decir, la longitud de la cadena) Cada media palabra subsiguiente contiene un carácter ASCII, expresado como dos dígitos decimales. La instrucción en lenguaje de máquina convierte cada carácter en su equivalente ASCII y lo asigna a media palabra.

h) Modifique el simulador para que maneje salida de cadenas almacenadas en el formato de la parte (g) Sugerencia: agregue una instrucción de lenguaje de máquina que imprima una cadena a partir de cierta localidad de memoria de la Simpletron. La primera mitad de la palabra de dicha localidad es la cuenta del número de caracteres de la cadena (es decir, la longitud de la cadena) Cada media palabra subsiguiente contiene un carácter ASCII expresado como dos dígitos decimales. La instrucción de lenguaje de máquina comprueba la longitud e imprime la cadena, traduciendo cada número de dos dígitos a su carácter equivalente.

19. ¿Qué hace este programa?

//Programa19.cpp #include <iostream.h> //Para cout y cin int misterio3(const char *, const char *); void main(void) {

char cadena1[80], cadena2[80]; cout << “Introduzca dos cadenas de caracteres: “; cin >> cadena1 >> cadena2; cout <<“El resultado es “ << misterio3(cadena1, cadena2) << endl;

}//Fin de main() int misterio3(const char *s1, const char *s2)



PROBLEMAS DE MANIPULACIÓN DE CADENAS 20. Escriba un programa que, mediante la función strcmp, compare dos cadenas introducidas por el usuario. El

programa deberá indicar si la primera cadena es menor, igual o mayor que la segunda. 21. Escriba un programa que compare, mediante la función strncmp, dos cadenas introducidas por el usuario. El

programa deberá aceptar como entrada el número de caracteres a comparar, además de indicar si la primera cadena es menor, igual o mayor que la segunda.

22. Escriba un programa que se valga de la generación de números aleatorios para crear oraciones. El programa utilizará cuatro arreglos de apuntadores a char, llamados articulo, sustantivo, verbo y preposicion. Deberá crear una oración seleccionando una palabra al azar de cada arreglo en el siguiente orden articulo, sustantivo, verbo, preposicion, articulo y sustantivo. A medida que se selecciona cada palabra, se le concatenará con las palabras previas en un arreglo lo bastante grande para guardar la oración completa. Las palabras se separarán por espacios. La impresión de la oración generada comenzará con una letra mayúscula y terminará con un punto. El programa generará 20 oraciones.

Los arreglos se llenarán como sigue: el arreglo articulo deberá contener los artículos “e”, “un”, “y”, “algún” y, “cualquier”; el arreglo sustantivo deberá contener los sustantivos “niño”, “señor”, “perro”, “pueblo” y “auto”; el arreglo verbo deberá contener los verbos “manejo”, “saltó”, “corrió”, “caminó” y “evitó”; el arreglo preposicion deberá contener las preposiciones “a”, “de”, “sobre”, “bajo” y “en”. Una vez que el programa haya sido escrito y esté operando, modifíquelo para que genere una historia corta que consista de varias oraciones. (¿Qué tal la posibilidad de un escritor de cuentos para la clase de literatura?)

23. (Quintillas) Una quintilla es una oración en verso, a veces jocoso, de cinco líneas, en el que el primero y segundo versos riman con el quinto y el tercero con el cuarto. Mediante técnicas parecidas a las desarrolladas en el problema 22, escriba un programa en C++ que produzca quintillas al azar. Refinar este programa para que genere buenas quintillas es un problema complejo, pero el resultado vale el esfuerzo.

24. Escriba un programa que codifique frases en pig Latin. (En inglés, pig Latin es un tipo de lenguaje que se utiliza con propósitos de juego.) Hay muchas variaciones en los métodos con los que se forman frases en pig Latin. Por simplicidad, utilice el siguiente algoritmo:

Para formar una frase en pin Latin, divida en palabras dicha frase mediante la función strtok. Para convertir cada palabra a pig Latin, ponga la primera letra de la palabra al final de ella y agregue las letras “ay”. Así, la palabra “salta” se convierte en “altasay”, “las” se vuelve “aslay” y “computadora” queda corno “omputadoracay”. Los espacios entre las palabras quedan igual. Suponga lo siguiente: la frase consiste en palabras separadas por espacios, no hay signos de puntuación y todas las palabras tienen dos o más letras. La función mostrarLatinPalabra() deberá desplegar cada palabra. Sugerencia: cada vez que se encuentre un token durante una llamada a strtok, pase el apuntador del token a la función mostrarLatinPalabra() e imprima la palabra en pig Latin.

25. Escriba un programa que acepte como entrada una cadena con un número telefónico, en la forma (555)555-5555. El programa deberá utilizar la función strtok para obtener como token el código de área, los primeros tres dígitos del número telefónico y los últimos cuatro dígitos. Los siete dígitos del número telefónico deben concatenarse para formar una sola cadena. El programa deberá convertir la cadena con el código de área a int y la cadena con el número telefónico a long. Se deben imprimir el código de área y el número telefónico.

26. Escriba un programa que acepte como entrada una línea de texto, la divida en tokens por medio de la función strtok y envíe los tokens a la salida en orden inverso.

27. Utilice las funciones de comparación de cadenas estudiadas y las técnicas de ordenamiento de arreglos desarrollados para escribir un programa que alfabetice una lista de cadenas. Ordene los nombres de 10 o 15 pueblos de su zona.

{ for(; *s1 != ‘\0’ && *s2 != ‘\0’; s1++, s2++)

if(*s1 != *s2) return 0; return 1;

}//Fin de misterio3()



28. Escriba dos versiones de la función de copia de cadenas y de la función de concatenación de cadenas de la figura 20.9. La primera versión deberá utilizar indización de arreglos, y la segunda apuntadores y aritmética de apuntadores.

29. Escriba dos versiones de cada función de comparación de cadenas de la figura 20.9. La primera versión debe emplear indización de arreglos, y la segunda apuntadores y aritmética de apuntadores.

30. Escriba dos versiones de la función strlen de la figura 20.9. La primera versión debe valerse de indización de arreglos, y la segunda de apuntadores y aritmética de apuntadores.

SECCIÓN ESPECIAL: Manipulación avanzado de cadenas Los problemas anteriores están ligados a las lecciones y se diseñaron para poner a prueba los conocimientos del lector sobre los conceptos fundamentales de manipulación de cadenas. Esta sección incluye un conjunto de problemas de manipulación de cadenas intermedios y avanzados. El lector deberá encontrar interesantes y amenos estos problemas. La dificultad de los problemas varía considerablemente. Algunos requieren de una hora o dos para su escritura e implementación. Otros son útiles corno tareas de laboratorio que podrían tardar dos o tres semanas de estudio e implementación. Varios son proyectos vastos que se extenderán durante todo el curso. 31. (Análisis de texto) La disponibilidad de computadoras con capacidad de manipulación de cadenas ha dado

como resultado algunos enfoques bastante interesantes para el análisis de las obras de los grandes autores. Se ha puesto mucha atención en si William Shakespeare en realidad existió. Algunos estudiosos creen que hay bastante evidencia que indica que las obras maestras atribuidas a Shakespeare en realidad fueron escritas por Christopher Marlowe u otros autores. Los investigadores se han valido de las computadoras para encontrar las similitudes en los escritos de ambos autores. Este ejercicio examina tres métodos de análisis de texto mediante computadoras.

a) Escriba un programa que lea del teclado varias líneas de texto e imprima una tabla que indique el número

de veces que sucede cada letra del abecedario en el texto. Por ejemplo, la frase:

Ser o no ser: ésa es la cuestión

contiene dos “a”, ninguna “b”, una “c”, etcétera.

b) Escriba un programa que lea varias líneas de texto e imprima una tabla que indique el número de palabras de una letra, de dos letras, de tres letras, etc., que hay en el texto. Por ejemplo, la frase

Si es más noble para la mente sufrir

Contiene

Longitud de la palabra Veces

1 0 2 3 3 1 4 1 5 2 6 1 7 0

c) Escriba un programa que lea varias líneas de texto e imprima una tabla que indique el número veces que sucede cada palabra del texto. La primera versión del programa deberá incluir las palabras de la tabla en el mismo orden en que aparecen en el texto. Por ejemplo, las líneas:

Ser o no ser: ésa es la cuestión Si es más noble para la mente sufrir

contienen la palabra “ser“ dos veces, la palabra “más” una vez, “no” una vez, etc. Después deberá intentar una impresión más interesante (y útil) en la que las palabras aparezcan ordenadas alfabéticamente.

32. (Procesamiento de texto) Una importante función de los sistemas de procesamiento de texto es la justificación tipográfica, es decir, la alineación de las palabras tanto con el margen izquierdo como con el derecho. Esto



genera un documento de aspecto profesional que da la apariencia de haber sido formado tipográficamente, en lugar de escrito en una máquina de escribir. La justificación tipográfica puede lograrse en los sistemas de cómputo insertando caracteres en blanco entre las palabras, de modo que la palabra más a la derecha quede alineada con el margen derecho.

Escriba un programa que lea varias líneas de texto y lo imprima en formato justificado. Suponga que texto se debe imprimir en papel de 8 ½ pulgadas de ancho y que se dejan márgenes de una pulgada tanto al lado izquierdo como al derecho. Suponga que la computadora imprime 10 caracteres por pulgada horizontal. Por lo tanto, dicho programa deberá imprimir 6 ½ pulgadas de texto o 65 caracteres por línea.

33. (Impresión de fechas con varios formatos) En la correspondencia comercial, las fechas por lo general se imprimen en varios formatos. Dos de los más comunes son:

21/07/55 y julio 21, 1955

Escriba un programa que lea una fecha con el primer formato y la imprima con el segundo.

34. (Protección de cheques) Con frecuencia las computadoras se utilizan para ejecutar sistemas de impresión de cheques, como sucede con las aplicaciones de nómina y cuentas por pagar. Circulan por allí muchas historias extrañas sobre cheques de nómina emitidos (accidentalmente) que amparan cifras de más de un millón. Los sistemas de cheques imprimen cifras extrañas debido a errores humanos y/o a fallas de la máquina. Los diseñadores de sistemas integran controles en sus sistemas para evitar la emisión de tales cheques.

Otro problema serio es que alguien altere intencionalmente la cifra de un cheque para cobrarlo fraudulentamente. Para evitar la alteración de una cifra, la mayoría de los sistemas de impresión de cheques utiliza una técnica llamada protección de cheques. Los cheques diseñados para impresión en una computadora contienen una cantidad fija de espacios en los que se puede imprimir una cifra. Suponga que un cheque contiene ocho espacios en blanco, donde la computadora debe imprimir el importe de un cheque de nómina. Si la cifra es grande, entonces se llenarán los ocho espacios. Por ejemplo:

1,230.60 (importe del cheque) ----------- 12345678 (posiciones)

Por otra parte, si la cifra es menor que $100.00, entonces quedarían en blanco varios de los espacios. Por ejemplo,

99.87 ------------ 12345678

contiene tres espacios en blanco. Si un cheque se imprime con espacios en blanco, es fácil de alterar. Para evitar esto, muchos sistemas de impresión de cheques protegen la cifra insertando asteriscos iniciales como sigue:

***99.87 ----------- 12345678

Escriba un programa que acepte una cifra y luego la imprima en formato de protección de cheques, con asteriscos iniciales, de ser necesario. Suponga que se dispone de nueve espacios para imprimir la cifra.

35. (Escritura del importe de un cheque con palabras) Prosiguiendo el estudio del ejemplo previo, reiteramos la

importancia de diseñar sistemas de impresión de cheques que eviten la alteración de sus importes. Un método de seguridad común requiere que la cifra sea escrita tanto con números como con palabras. Inclusive si alguien es capaz de alterar la cifra numérica, es muy difícil modificar la cifra en palabras.



Muchos sistemas computarizados de impresión de cheques no imprimen la cifra del cheque con palabras. Tal vez la razón principal de esta omisión es que la mayoría de los lenguajes de alto nivel empleados para las aplicaciones comerciales no cuentan con características adecuadas de manipulación de cadenas. Otra razón es que la lógica de la escritura de las cifras con palabras es un tanto complicada. Escriba un programa en C++ que acepte una cifra numérica y la imprima con palabras. Por ejemplo, la cifra 112.43 deberá escribirse como:

CIENTO DOCE con 43/100

36. (Código Morse) Tal vez el esquema de codificación más famoso de todos es el código Morse, desarrollador por

Samuel Morse en 1832 para el sistema telegráfico. El código Morse asigna una serie de puntos y rayas a cada letra del abecedario, a cada dígito y a algunos caracteres especiales (punto, coma, dos puntos y punto y coma) En los sistemas audibles, el punto representa un sonido corto y la raya un sonido largo., Otras representaciones de puntos y rayas son las empleadas en los sistemas de orientación por luz y los de señalización con indicadores.

La separación entre palabras se indica mediante un espacio o, sencillamente, por la ausencia de un punto o raya. En los sistemas sonoros, se indica un espacio mediante un periodo corto en el que no se transmite ningún sonido. En la figura 20.14 aparece la versión internacional del código Morse. Escriba un programa que lea una frase en español y la codifique en código Morse. También escriba un programa que lea una frase en código Morse y la convierta en su equivalente en inglés. Ponga un espacio entre cada letra codificada en Morse y tres espacios entre cada palabra.

Carácter Código Carácter Código

A .- T - B -... U ..- C -.-. V ...- D -.. W .-- E . X -..- F ..-. Y -.-- G --. Z --.. H .... I .. Dígitos J .--- 1 .---- K -.- 2 ..--- L .-.. 3 ...-- M -- 4 ....- N -. 5 ..... O --- 6 -.... P .--. 7 --... Q --.- 8 ---.. R .-. 9 ----. S ... 0 -----

Figura 20.14. Las letras del abecedario como se expresan con el código Morse internacional

37. (Programa de conversión entre Sistema métrico y sistema inglés) Escriba un programa que apoye al usuario en las conversiones entre el sistema métrico y el inglés. El programa deberá permitirle al usuario especificar como cadenas los nombres de las unidades (es decir, centímetros, litros, gramos, etc., en el sistema métrico y pulgadas, cuartillos, libras, etc., en el sistema inglés) y deberá responder a preguntas sencillas como:

“¿Cuántas pulgadas hay en 2 metros?” “¿Cuántos litros hay en 10 cuartillos?”

El programa deberá reconocer las conversiones inválidas. Por ejemplo, la pregunta:

“¿Cuántos pies hay en 5 kilogramos”



no tiene sentido, pues los pies, son unidades de longitud, mientras que los kilogramos, son unidades de peso. INTERESANTE PROYECTO DE MANIPULACIÓN DE CADENAS 38. (Generador de crucigramas) Mucha gente ha resuelto crucigramas, pero pocos han intentado generar uno. La

generación de crucigramas es difícil. Aquí se sugiere como un proyecto de manipulación de cadenas de alta complejidad y esfuerzo. Hay muchos asuntos que el programador debe resolver para lograr que funcione incluso el programa generador de crucigramas más sencillo. Por ejemplo, ¿cómo se representa el tramado de un crucigrama en la computadora? ¿Deberá utilizarse una serie de cadenas o arreglos de doble índice? El programador necesita una fuente de palabras (es decir, un diccionario computarizado) al que pueda hacer referencia directa el programa. ¿De qué forma deben almacenarse estas palabras para simplificar las complejas manipulaciones requeridas por el programa? El lector realmente ambicioso deseará generar la parte de claves del crucigrama, donde se imprimen las pistas para determinar las palabras horizontales y verticales. La simple impresión de una versión en blanco del crucigrama es un problema complejo.

Leccion Punteros Cadenas

Documents

Transcript of Leccion Punteros Cadenas