Capítulo 5. Punteros y Cadenas de Caracteres

1. Capítulo 5. Punteros y Cadenas de Caracteres Índice del Capítulo5.1 Introducción5.2 Declaración e Inicialización de Variables Punteros5.3 Operadores de Punteros5.4 Llamada a Funciones por Referencia5.5 Uso de const con Punteros5.6 Operador unario sizeof5.7 Expresiones y Aritmética de Punteros5.8 Relación entre Punteros y Arrays5.9 Arrays de Punteros5.10 Procesado de Caracteres y Cadenas - Fundamentos de Caracteres y Cadenas - Funciones de la Biblioteca de Manipulación de Cadenas

2. 5.1 Introducción • Punteros • Muy potentes, pero difíciles de manejar • Simulan el paso-por-referencia • Permiten manipular estructuras de datos dinámicas (pueden crecer y decrecer dinámicamente) • Estrecha relación con arrays y cadenas de caracteres

3. cont contPtr cont 7 7 5.2 Declaración e Inicialización de Punteros • Variables puntero • Contienen direcciones de memoria como valores • Normalmente, una variable contiene un valor específico (referencia directa) • Los punteros contienen direcciones de variables que tienen un valor específico (referencia indirecta) • Indirección • Referenciar un valor a través de un puntero

4. 5.2 Declaración e Inicialización de Punteros • Declaración de punteros • * indica que la variable es un puntero int *miPtr; declara un puntero a int • Varios punteros requieren varios asteriscos int *miPtr1, *miPtr2; • Se pueden declarar punteros a cualquier tipo de dato • Inicialización de punteros • Inicializados a 0, NULL, o a una dirección de memoria • 0 o NULL no apuntan a nada • NULL: constante simbólica definida en el archivo de encabezado <iostream>

5. yptr y y 5 yPtr 500000 600000 600000 5 La dirección de y es el valor de yptr 5.3 Operadores de Punteros • & (operador de dirección) • Operador unario que devuelve la dirección de memoria de su operando • Ejemplo: int y = 5;int *yPtr;yPtr = &y; // yPtr toma la dirección de y • yPtr “apunta a” y, referencia indirectamente al valor de y

6. 5.3 Operadores de Puntero • * (Operador de indirección/desreferenciación) • Devuelve un sinónimo del objeto al que apunta su puntero operando • *yPtr devuelve el valor de y (porque yPtr apunta a y). • El puntero desreferenciado se puede usar en la parte izquierda de una asignación *yptr = 9; // asigna 9 a y cin >> *yptr; //lee un valor; lo asigna a y • * y & son operadores inversos entre sí

7. 1 // Fig. 5.4: fig05_04.cpp 2 // Uso de los operadores & y *. 3 #include <iostream> 4 5 using std::cout; 6 using std::endl; 7 8 int main() 9 { 10 int a; // a es un entero 11 int *aPtr; // aPtr es un puntero a un entero 12 13 a = 7; 14 aPtr = &a; // a aPtr se le asigna la dirección de a 15 16 cout << "La dirección de a es " << &a << endl; 17 cout << "El valor de aPtr es " << aPtr << endl << endl; 18 19 cout << "El valor de a es " << a << endl; 20 cout << "El valor de *aPtr es " << *aPtr << endl << endl; 21 22 cout << "Mostramos que * y & son operadores inversos entre sí" << endl; 23 cout << "&*aPtr = " << &*aPtr << endl; 24 cout << "*&aPtr = " << *&aPtr << endl; 25 26 return0; 27 28 } * y & son operadores inversos entre sí

8. La dirección de a es 0012FED4 El valor de aPtr es 0012FED4 El valor de a es 7 El valor de *aPtr es 7 Mostramos que * y & son operadores inversos entre sí. &*aPtr = 0012FED4 *&aPtr = 0012FED4 Dependiendo de la máquina, la dirección se imprime como entero hexadecimal o decimal. * y & son inversos; cuando se aplican ambos a aPtr se produce el mismo resultado.

9. 5.4 Llamada a Funciones por Referencia • 3 formas de pasar argumentos a una función • Paso-por-valor • Paso-por-referencia con argumentos referencia • Paso-por-referencia con argumentos puntero • Paso-por-valor: • return puede devolver un único valor desde una función • Paso-por referencia con argumentos referencia: • Modifican los valores originales de los argumentos • “Devuelven” más de un valor

10. 5.4 Llamada a Funciones por Referencia • Paso-por-referencia con argumentos puntero • Simulan el paso-por referencia mediante el uso de punteros y operador de indirección (*) • Pasa la dirección del argumento usando el operador & • Los arrays no se pasan usando & porque el nombre del array ya es un puntero • miarray => &miarray[0] • Operador * usado para formar un sinónimo para el nombre de la variable dentro de la función

11. 1 // Cubo de una variable usando paso-por-valor. 2 #include <iostream> 3 using std::cout; 4 using std::endl; 5 6 int cuboPorValor( int ); // prototipo 7 8 int main() 9 { 10 int numero = 5; 11 12 cout << "El valor original de numero es " << numero; 13 // paso numero por valor a cuboPorValor 14 numero = cuboPorValor( numero ); 15 cout << "\nEl nuevo valor de numero es " << numero << endl; 16 17 return0; 18 } 19 // calcula y devuelve el cubo de un argumento entero 20 int cuboPorValor( int n ) 21 { 22 return n * n * n; // cubo de variable local n y devuelve resultado 23 } // fin de función cuboPorValor Paso numero por valor; resultado devuelto por cuboPorValor cuboPorValor recibe un parámetro pasado-por-valor Eleva al cubo y devuelve la variable local n El valor original de numero es 5 El nuevo valor de numero es 125

12. 1 // Cubo de una variable usando paso-por-referencia con un argumento puntero 2 #include <iostream> 3 using std::cout; 4 using std::endl; 5 6 void cuboPorReferencia( int * ); // prototipo 7 8 int main() 9 { 10 int numero = 5; 11 12 cout << "El valor original de numero es " << numero; 13 // paso dirección de numero a cuboPorReferencia 14 cuboPorReferencia( &numero ); 15 cout << "\nEl nuevo valor de numero es " << numero << endl; 16 17 return0; 18 } 19 // calcula cubo de *nPtr; modifica variable numero en main 20 void cuboPorReferencia( int *nPtr ) 21 { 22 *nPtr = *nPtr * *nPtr * *nPtr; // cubo de *nPtr 23 } // fin de función cuboPorReferencia El prototipo indica que el parámetro es un puntero a int Aplica el operador dirección & para pasar la dirección de numero a cuboPorReferencia Modifica y accede a la variable int usando el operador de indirección * cuboPorReferencia modificó variable numero cuboPorReferencia recibe la dirección de una variable int, es decir, un puntero a int El valor original de numero es 5 El nuevo valor de numero es 125

13. 5.5 Uso de const con Punteros • Calificador const • El valor de la variable no puede ser modificado • const se usa cuando la función no necesita modificar la variable • Principio de menor privilegio • Permitir a la función suficiente acceso para realizar la tarea, pero no más • Cuatro formas de pasar un puntero a una función • Puntero no constante a datos no constantes • Mayor privilegio de acceso • Puntero no constante a datos constantes • Puntero constante a datos no constantes • Puntero constante a datos constantes • Menor privilegio de acceso

14. 1 // PUNTERO NO CONSTANTE A DATOS NO CONSTANTES: Conversión de minúsculas a mayúsculas 2 #include <iostream> 3 using std::cout; 4 using std::endl; 5 #include <cctype> // prototipos para islower y toupper 6 7 void convertirAMayusculas( char * ); 8 9 int main() 10 { 11 char frase[] = "caracteres y 32.98$"; 12 13 cout << "La frase antes de la conversión es: " << frase; 14 convertirAMayusculas( frase ); 15 cout << "\nLa frase después de la conversión es: " << frase << endl; 16 17 return0; 18 } 19 // convierte cadena a mayúsculas 20 void convertirAMayusculas( char *cPtr ) 21 { 22 while ( *cPtr != '\0' ) { 23 if ( islower( *cPtr ) ) 24 *cPtr = toupper( *cPtr ); 25 ++cPtr; 26 } // fin de while 27 } // fin de la función convierteAMayusculas El parámetro es un puntero no constante a datos no constantes convertirAMayusculas modifica la variable frase cPtr: puntero no constante a datos no constantes Función islower devuelve true si carácter en minúsculas Function toupper devuelve carácter en mayúsculas si estaba en minúsculas; sino lo deja como estaba Cuando se aplica el operador ++ a un puntero que apunta a un array, la dirección de memoria almacenada en el puntero se modifica para apuntar al siguiente elemento del array. La frase antes de la conversión es: caracteres y 32.98$ La frase después de la conversión es: CARACTERES Y 32.98$

15. 1 // PUNTERO NO CONSTANTE A DATOS CONSTANTES: Impresión de una cadena carácter a carácter 2 #include <iostream> 3 using std::cout; 4 using std::endl; 5 6 void imprimeCaracteres( const char * ); 7 8 int main() 9 { 10 char frase[] = "imprime caracteres de una cadena"; 11 12 cout << "La cadema es:\n"; 13 imprimeCaracteres( frase ); 14 cout << endl; 15 16 return0; 17 } 18 // cPtr no puede modificar el carácter al que apunta 19 // es decir, cPtr es un puntero de "sólo-lectura" 20 void imprimeCaracteres( const char *cPtr ) 21 { 22 for ( ; *cPtr != '\0'; cPtr++ ) // no inicialización 23 cout << *cPtr; 24 } // fin de función imprimeCaracteres El parámetro es un puntero no constane a datos constantes. Pasa el puntero frase a la función imprimeCaracteres. cPtr es un puntero no constante a datos constantes; no se puede modificar el carácter al que apunta cPtr. Incrementa cPtr para apuntar al siguiente carácter. La cadena es: imprime caracteres de una cadena

16. 1 // fig05_12.cpp: PUNTERO NO CONSTANTE A DATOS CONSTANTES: Intento de modificación de datos 2 3 void f( const int * ); // prototipo 4 5 int main() 6 { 7 int y; 8 9 f( &y ); // f intenta una modificación no permitida 10 11 return0; 12 } 13 14 // xPtr no puede modificar el valor de la variable a la que apunta 15 void f( const int *xPtr ) 16 { 17 *xPtr = 100; // error: no se puede modificar un objeto const 18 } // fin de función f El parámetro es un puntero no constante a datos constantes Pasa la dirección de una variable inty para intentar una modificación no permitida. Intento modificar el objeto const apuntado por xPtr. Error producido al intentar compilar. fig05_12.cpp: In function 'void f (const int *)': fig05_12.cpp: 17: assignment of read-only location

17. 5.5 Uso de const con Punteros • Punteros const • Siempre apuntan a la misma localización de memoria • Calificador por defecto para el nombre de un array • Deben inicializarse al declararlos

18. 1 // fig05_13.cpp 2 // PUNTERO CONSTANTE A DATOS NO CONSTANTES: Intento de modificar el puntero. 3 4 int main() 5 { 6 int x, y; 7 8 // ptr es un puntero contante a un entero que puede modificarse a través de ptr 9 // pero ptr siempre apunta a la misma localización de memoria 10 int * const ptr = &x; 11 12 *ptr = 7; // permitido: *ptr no es constante 13 ptr = &y; // error: ptr es const; no puede asignársele una nueva dirección 14 15 return0; 16 } ptr es un puntero constante a un entero. Puede modificarse x (apuntado por ptr) pues x no es constante. No puede modificarse ptr para apuntar a una nueva dirección pues ptr es constante. La línea 13 genera un error de compilación al intentar asignar una nueva dirección a un puntero constante. fig05_13.cpp: In function 'int main()': fig05_13.cpp: 13: Assignment of read-only variable 'ptr'

19. 1 // fig05_14.cpp 2 // PUNTERO CONSTANTE A DATOS CONSTANTES: Intento de modificación de datos y puntero 3 #include <iostream> 4 using std::cout; 5 using std::endl; 6 7 int main() 8 { 9 int x = 5, y; 10 11 // ptr es un puntero constante a un entero constante. 12 // ptr siempre apunta a la misma localización; 13 // el entero en dicha localización no puede modificarse. 14 const int *const ptr = &x; 15 16 cout << *ptr << endl; 17 *ptr = 7; // error: *ptr es const; no se le puede asignar un nuevo valor 18 ptr = &y; // error: ptr es const; no se le puede asignar una nueva dirección 19 20 return0; 21 } No se puede modificar ptr para apuntar a una nueva dirección pues ptr es constante. No se puede modificar x (apuntado por ptr) pues *ptr se declara constante. ptr es un puntero constante a un entero constante. fig05_14.cpp: In function 'int main()': fig05_14.cpp: 18: Assignment of read-only location fig05_14.cpp: 18: Assignment of read-only variable 'ptr'

20. 5.6 Operador unario sizeof • sizeof • Operador unario (no función) que devuelve tamaño del operando en bytes como un valor de tipo size_t (definido en archivo <cstddef>), que generalmente es un unsigned int • <cstddef> suele estar incluido en otros archivos como <cstdlib> y <cstring> • Para arrays, sizeof devuelve: ( tamaño de 1 elemento ) * ( número de elementos ) • Si sizeof( int ) es 4, entonces int miArray[10]; cout << sizeof miArray; imprimirá 40 • *ptr=miArray; cout << sizeof ptr; imprimirá el tamaño en bytes del puntero (4), no del tamaño del array. • Nº elementos = sizeof miArray / sizeof ( int ); • sizeof puede usarse con: • Nombres de variables • Nombres de tipos (paréntesis obligatorios) • Valores constantes

21. 1 // fig05_16.cpp 2 // Operador sizeof usado con nombre de array devuelve el nº de bytes del array. 3 #include <iostream> 4 #include <cstddef> 4 using std::cout; 5 using std::endl; 6 size_t obtieneTamanho( double * ); // prototipo 7 8 int main() 9 { 10 double array[ 20 ]; 11 cout << "El número de bytes del array es " 12 << sizeof( array ); 13 cout << "\nEl número de bytes devuelto por obtieneTamanho es " 14 << obtieneTamanho( array ) << endl; 15 16 return0; 17 } 18 // función que devuelve el tamaño de ptr 19 size_t obtieneTamanho( double *ptr ) 20 { 21 returnsizeof( ptr ); 22 } // fin de la función obtieneTamanho Operador sizeof aplicado a un array devuelve el número total de bytes que ocupa el array. Función obtieneTamanho devuelve el número de bytes usado para almacenar la dirección array. Operador sizeof devuelve el número de bytes del puntero. El número de bytes del array es 160 El número de bytes devuelto por obtieneTamanho es 4

22. 1 // fig05_17.cpp: Demostración del operador sizeof. 2 #include <iostream> 3 using std::cout; 4 using std::endl; 5 int main() 6 { 7 char c; 8 short s; 9 int i; 10 long l; 11 float f; 12 double d; 13 longdouble ld; 14 int array[ 20 ]; 15 int *ptr = array; 16 cout << "sizeof c = " << sizeof c << "\tsizeof(char) = " << sizeof( char ) 17 << "\nsizeof s = " << sizeof s << "\tsizeof(short) = " << sizeof( short ) 18 << "\nsizeof i = " << sizeof i << "\tsizeof(int) = " << sizeof( int ) 19 << "\nsizeof l = " << sizeof l << "\tsizeof(long) = " << sizeof( long ) 20 << "\nsizeof f = " << sizeof f << "\tsizeof(float) = " << sizeof( float ) 21 << "\nsizeof d = " << sizeof d << "\tsizeof(double) = " << sizeof( double ) 22 << "\nsizeof ld = " << sizeof ld 23 << "\tsizeof(long double) = " << sizeof( long double ) 24 << "\nsizeof array = " << sizeof array << "\nsizeof ptr = " << sizeof ptr 25 << endl; 26 return0; 27 } Operador sizeof puede usarse con nombre de variable. Operador sizeof puede usarse con nombre de tipo.

23. sizeof c = 1 sizeof(char) = 1 sizeof s = 2 sizeof(short) = 2 sizeof i = 4 sizeof(int) = 4 sizeof l = 4 sizeof(long) = 4 sizeof f = 4 sizeof(float) = 4 sizeof d = 8 sizeof(double) = 8 sizeof ld = 12 sizeof(long double) = 12 sizeof array = 80 sizeof ptr = 4

24. localización 3000 3004 3008 3012 3016 puntero a variable vPtr v[0] v[1] v[2] v[4] v[3] 5.7 Expresiones y Aritmética de Punteros • Aritmética de punteros • Incremento/decremento de un puntero (++ o --) • Suma/resta de un entero a/de un puntero( + o += , - o -=) • Los punteros se pueden restar entre sí • Aritmética de punteros sin significado a no ser que se realice sobre un puntero a array • Ejemplo: Array de 5 elementos int en máquina con tamaño 4 bytes para ints • vPtr apunta al primer elemento v[ 0 ], que es la localización de memoria 3000, vPtr=v; vPtr=&v[0]; • vPtr += 2; fija vPtr a 3008 vPtr apunta a v[ 2 ] • ++vPtr; --vPtr;

25. 5.7 Expresiones y Aritmética de Punteros • Resta de punteros • Devuelve el número de elementos entre las dos direcciones vPtr2 = &v[ 2 ];vPtr = &v[ 0 ];vPtr2 - vPtr == 2 • Asignación de punteros • Un puntero puede asignarse a otro puntero si ambos son del mismo tipo • Si no son del mismo tipo, se debe usar un operador de molde • Excepción: puntero a void (tipo void *) • Puntero genérico, representa cualquier tipo • No se necesita molde para convertir puntero a puntero a void pero sí viceversa. • Punteros a void no pueden desreferenciarse, pues no se sabe el tipo de datos del puntero no se sabe cuántos bytes ocupa.

26. 5.7 Expresiones y Aritmética de Punteros • Comparación de punteros • Mediante los operadores de igualdad y relacionales • Comparaciones sin significado a no ser que los punteros apunten a miembros del mismo array • Comparación de direcciones almacenadas en punteros • Ejemplo: podríamos mostrar que un puntero apunta a un elemento del array con mayor índice que otro puntero • Uso común para determinar si un puntero es 0 (no apunta a nada)

27. 5.8 Relación entre Punteros y Arrays • Arrays y punteros estrechamente relacionados • Nombre de un array similar a puntero constante • Punteros pueden realizar operaciones de índices de arrays • Acceso a los elementos de un array con punteros: • Ejemplo: int b[5]; bPtr=&b[0]; o bPtr=b; • Notación de puntero y desplazamiento: Acceso al elemento b[ n ] mediante *(bPtr+n) • Direcciones: • &b[ 3 ] es lo mismo que bPtr + 3 • El nombre del array puede tratarse como un puntero: • b[ 3 ] es lo mismo que *( b + 3 ) • Notación de puntero y subíndice: los punteros pueden usar índices • bPtr[ 3 ] es lo mismo que b[ 3 ] • b=puntero constante b+=3; produce error de sintaxis

28. 1 // fig05_20.cpp: Uso de notación de punteros e índices con arrays 2 #include <iostream> 3 using std::cout; 4 using std::endl; 5 int main() 6 { 7 int b[] = { 10, 20, 30, 40 }; 8 int *bPtr = b; // hago que bPtr apunte al array b 9 cout << "Array b impreso con:\n"; 10 11 // imprimo array b usando notación de índices 12 cout << "\nNotación de índices de arrays\n"; 13 for ( int i = 0; i < 4; i++ ) 14 cout << "b[" << i << "] = " << b[ i ] << endl; 16 17 // imprimo array b usando nombre de array y notación de puntero y desplazamiento 18 cout << "\nNotación puntero/desplazamiento con puntero=nombre de array\n"; 19 for ( int desplaz1 = 0; desplaz1 < 4; desplaz1++ ) 20 cout << "*(b + " << desplaz1 << ") = " << *( b + desplaz1 ) <<endl; 21 22 // imprimo array b usando bPtr y notación de índices de arrays 23 cout << "\nNotación puntero/subíndice\n"; 24 for ( int j = 0; j < 4; j++ ) 25 cout << "bPtr[" << j << "] = " << bPtr[ j ] << endl; 26 27 // imprimo array b usando bPtr y notación puntero/desplazamiento 28 cout << "\nNotación puntero/desplazamiento\n"; 29 for ( int desplaz2 = 0; desplaz2 < 4; desplaz2++ ) 30 cout << "*(bPtr + " << desplaz2 << ") = " << *( bPtr + desplaz2 ) << endl; 31 return0; 32 } Usando notación de índices de array. Usando nombre de array y notación puntero/desplazamiento. Usando notación de puntero/subíndice. Usando bPtr y notación puntero/desplazamiento.

29. Array b impreso con: Notación de índices de arrays b[0] = 10 b[1] = 20 b[2] = 30 b[3] = 40 Notación puntero/desplazamiento con puntero=nombre de array *(b + 0) = 10 *(b + 1) = 20 *(b + 2) = 30 *(b + 3) = 40 Notación puntero/subíndice bPtr[0] = 10 bPtr[1] = 20 bPtr[2] = 30 bPtr[3] = 40 Notación puntero/desplazamiento *(bPtr + 0) = 10 *(bPtr + 1) = 20 *(bPtr + 2) = 30 *(bPtr + 3) = 40

30. 1 // fig05_21.cpp: Copia de una cadena usando notación de arrays y notación de punteros 2 #include <iostream> 3 using std::cout; 4 using std::endl; 5 void copia1( char *, const char * ); // prototipo 6 void copia2( char *, const char * ); // prototipo 7 int main() 8 { 9 char cadena1[ 10 ]; 10 char *cadena2 = "Hola"; 11 char cadena3[ 10 ]; 12 char cadena4[] = "Hasta luego"; 13 14 copia1( cadena1, cadena2 ); 15 cout << "cadena1 = " << cadena1 << endl; 16 copia2( cadena3, cadena4 ); 17 cout << "cadena3 = " << cadena3 << endl; 18 return0; 19 } 20 // función que copia c2 a c1 usando notación de arrays 21 void copia1( char *c1, const char *c2 ) 22 { 23 for ( int i = 0; ( c1[ i ] = c2[ i ] ) != '\0'; i++ ) 24 ; // no hace nada en el cuerpo del bloque for 25 } // fin de función copia1 26 // función que copia c2 en c1 usando notación de punteros 27 void copia2( char *c1, constchar *c2 ) 28 { 29 for ( ; ( *c1 = *c2 ) != '\0'; c1++, c2++ ) 30 ; // no hace nada en el cuerpo del bloque for 31 } // fin de la función copia2 Usa notación de índices de array para copiar la cadena c2 al array de caracteres c1. Usa notación de punteros para copiar cadena c2 al array de caracteres c1. Incrementa ambos punteros para apuntar a los siguientes elementos en sus arrays correspondientes. cadena1 = Hola cadena3 = Hasta luego

31. ’\0’ ’t’ ’\0’ ’n’ ’a’ ’c’ ’s’ ’l’ ’o’ ’e’ ’a’ ’m’ ’\0’ ’P’ ’o’ ’r’ ’T’ ’r’ ’é’ ’b’ ’o’ ’C’ ’s’ ’a’ ’i’ ’z’ ’e’ ’e’ ’\0’ ’n’ ’s’ ’i’ ’D’ ’s’ ’a’ palos[0] palos[2] palos[1] palos[3] 5.9 Arrays de Punteros • Los arrays pueden contener punteros • Comúnmente usados para almacenar arrays de cadenas de caracteres char * palos[ 4 ] = {"Corazones", "Tréboles","Picas", "Diamantes" }; • Cada elemento de palos apunta a un char * (una cadena) • El array no almacena cadenas, sólo punteros a cadenas • El array palos tiene tamaño fijo, pero las cadenas pueden ser de cualquier tamaño Cada elemento es un puntero a char Array de 4 elementos

32. 5.10 Procesado de Caracteres y Cadenas 5.10.1 Fundamentos de Caracteres y Cadenas • Constantes de caracteres • Valores enteros representados como un carácter entre comillas simples • 'z' es el valor entero de z (122 en ASCII) • Cadenas • Serie de caracteres tratados como una unidad • Puede incluir letras, dígitos, caracteres especiales +, -, * ... • Constantes de cadena • Encerradas entre comillas dobles, por ejemplo: "Me gusta programar en C++" • Array de caracteres, finaliza con carácter nulo '\0' • Una cadena es un puntero constante, es decir, es un puntero al primer carácter de la cadena (como los arrays)

33. 5.10 Procesado de Caracteres y Cadenas 5.10.1 Fundamentos de Caracteres y Cadenas • Asignación de cadenas • Array de caracteres • char color[] = "azul"; • Crea un array color de 5 elementos char (el último elemento es '\0‘) • Alternativa: char color[] = {'a', 'z', 'u', 'l', '\0'}; • Variable de tipo char * • char *colorPtr = "azul"; • Crea puntero colorPtr a letra 'a' en cadena "azul" • "azul" en algún lugar de la memoria

34. 5.10 Procesado de Caracteres y Cadenas 5.10.1 Fundamentos de Caracteres y Cadenas • Lectura de cadenas • Asigna la entrada al array de caracteres palabra[ 20 ] cin >> palabra; • Lee caracteres hasta que encuentra espacio, tabulación, salto de línea o fin de fichero • La cadena podría exceder el tamaño del array. • Solución: cin >> setw( 20 ) >> palabra; • Lee 19 caracteres (el carácter nº 20 se reserva para '\0')

35. 5.10 Procesado de Caracteres y Cadenas 5.10.1 Fundamentos de Caracteres y Cadenas • cin.getline • Lee una línea de texto • Formato: • cin.getline( array, tamanho, delimitador ); • delimitador no necesario (valor por defecto = '\n') • Copia entrada en array especificado hasta que se cumple alguna de las condiciones: • Se alcanza tamanho-1 • Se introduce el carácter delimitador • Se alcanza el fin del fichero • Ejemplo: char frase[ 80 ]; cin.getline( frase, 80, '\n' ); cin.getline( frase, 80 );

36. 5.10 Procesado de Caracteres y Cadenas 5.10.2 Funciones de la Biblioteca de Manipulación de Cadenas • Biblioteca de manipulación de cadenas <cstring> proporciona funciones para: • Manipular cadenas de datos • Comparar cadenas • Búsqueda de caracteres y cadenas dentro de cadenas • Atomizar cadenas (separación de cadenas en partes lógicas) • Determinar longitud de cadena • En algunas de estas funciones: • Tipo de datos size_t: definido en archivo <cstddef> (incluido en <cstring> y en <cstdlib> como entero sin signo).

37. 5.10 Procesado de Caracteres y Cadenas 5.10.2 Funciones de la Biblioteca de Manipulación de Cadenas

38. 5.10 Procesado de Caracteres y Cadenas 5.10.2 Funciones de la Biblioteca de Manipulación de Cadenas