Capítulo 5. Punteros y Cadenas de Caracteres

Presentación del tema: "Capítulo 5. Punteros y Cadenas de Caracteres"— Transcripción de la presentación:

1 Capítulo 5. Punteros y Cadenas de Caracteres
Índice del Capítulo Introducción Declaración e Inicialización de Variables Punteros Operadores de Punteros Llamada a Funciones por Referencia Uso de const con Punteros Operador unario sizeof Expresiones y Aritmética de Punteros Relación entre Punteros y Arrays Arrays de Punteros 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 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 cont 7 cont 7 contPtr

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 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 yPtr y 5 yptr 500000 600000 La dirección de y es el valor de yptr

6 * (Operador de indirección/desreferenciación)
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 * y & son operadores inversos entre sí
// Fig. 5.4: fig05_04.cpp // Uso de los operadores & y *. #include <iostream> 4 using std::cout; using std::endl; 7 int main() { int a; // a es un entero int *aPtr; // aPtr es un puntero a un entero 12 a = 7; aPtr = &a; // a aPtr se le asigna la dirección de a 15 cout << "La dirección de a es " << &a << endl; cout << "El valor de aPtr es " << aPtr << endl << endl; 18 cout << "El valor de a es " << a << endl; cout << "El valor de *aPtr es " << *aPtr << endl << endl; 21 cout << "Mostramos que * y & son operadores inversos entre sí" << endl; cout << "&*aPtr = " << &*aPtr << endl; cout << "*&aPtr = " << *&aPtr << endl; 25 return 0; 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 Paso numero por valor; resultado devuelto por cuboPorValor
// Cubo de una variable usando paso-por-valor. #include <iostream> using std::cout; using std::endl; 5 int cuboPorValor( int ); // prototipo 7 int main() 9 { int numero = 5; 11 cout << "El valor original de numero es " << numero; // paso numero por valor a cuboPorValor numero = cuboPorValor( numero ); cout << "\nEl nuevo valor de numero es " << numero << endl; 16 return 0; 18 } 19 // calcula y devuelve el cubo de un argumento entero 20 int cuboPorValor( int n ) 21 { 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 El prototipo indica que el parámetro es un puntero a int
// Cubo de una variable usando paso-por-referencia con un argumento puntero #include <iostream> using std::cout; using std::endl; 5 void cuboPorReferencia( int * ); // prototipo 7 8 int main() 9 { int numero = 5; 11 cout << "El valor original de numero es " << numero; // paso dirección de numero a cuboPorReferencia cuboPorReferencia( &numero ); cout << "\nEl nuevo valor de numero es " << numero << endl; 16 return 0; 18 } 19 // calcula cubo de *nPtr; modifica variable numero en main 20 void cuboPorReferencia( int *nPtr ) 21 { *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 cuboPorReferencia modificó variable numero cuboPorReferencia recibe la dirección de una variable int, es decir, un puntero a int Modifica y accede a la variable int usando el operador de indirección * 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 El parámetro es un puntero no constante a datos no constantes
// PUNTERO NO CONSTANTE A DATOS NO CONSTANTES: Conversión de minúsculas a mayúsculas #include <iostream> using std::cout; using std::endl; #include <cctype> // prototipos para islower y toupper 6 7 void convertirAMayusculas( char * ); 8 9 int main() 10 { char frase[] = "caracteres y 32.98$"; 12 cout << "La frase antes de la conversión es: " << frase; convertirAMayusculas( frase ); cout << "\nLa frase después de la conversión es: " << frase << endl; 16 return 0; 18 } 19 // convierte cadena a mayúsculas 20 void convertirAMayusculas( char *cPtr ) 21 { while ( *cPtr != '\0' ) { if ( islower( *cPtr ) ) *cPtr = toupper( *cPtr ); cPtr; } // 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 El parámetro es un puntero no constane a datos constantes.
// PUNTERO NO CONSTANTE A DATOS CONSTANTES: Impresión de una cadena carácter a carácter #include <iostream> using std::cout; using std::endl; 5 void imprimeCaracteres( const char * ); 7 int main() { char frase[] = "imprime caracteres de una cadena"; 11 cout << "La cadema es:\n"; imprimeCaracteres( frase ); cout << endl; 15 return 0; 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 { for ( ; *cPtr != '\0'; cPtr++ ) // no inicialización 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 El parámetro es un puntero no constante a datos constantes
// fig05_12.cpp: PUNTERO NO CONSTANTE A DATOS CONSTANTES: Intento de modificación de datos 2 void f( const int * ); // prototipo 4 int main() { int y; 8 f( &y ); // f intenta una modificación no permitida 10 return 0; 12 } 13 14 // xPtr no puede modificar el valor de la variable a la que apunta 15 void f( const int *xPtr ) 16 { *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 int y 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 ptr es un puntero constante a un entero.
// fig05_13.cpp // PUNTERO CONSTANTE A DATOS NO CONSTANTES: Intento de modificar el puntero. 3 int main() { int x, y; 7 // ptr es un puntero contante a un entero que puede modificarse a través de ptr // pero ptr siempre apunta a la misma localización de memoria int * const ptr = &x; 11 *ptr = 7; // permitido: *ptr no es constante ptr = &y; // error: ptr es const; no puede asignársele una nueva dirección 14 return 0; 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. fig05_13.cpp: In function 'int main()': fig05_13.cpp: 13: Assignment of read-only variable 'ptr' La línea 13 genera un error de compilación al intentar asignar una nueva dirección a un puntero constante.

19 ptr es un puntero constante a un entero constante.
// fig05_14.cpp // PUNTERO CONSTANTE A DATOS CONSTANTES: Intento de modificación de datos y puntero #include <iostream> using std::cout; using std::endl; 6 int main() { int x = 5, y; 10 // ptr es un puntero constante a un entero constante. // ptr siempre apunta a la misma localización; // el entero en dicha localización no puede modificarse. const int *const ptr = &x; 15 cout << *ptr << endl; *ptr = 7; // error: *ptr es const; no se le puede asignar un nuevo valor ptr = &y; // error: ptr es const; no se le puede asignar una nueva dirección 19 return 0; 21 } ptr es un puntero constante a un entero constante. No se puede modificar x (apuntado por ptr) pues *ptr se declara constante. No se puede modificar ptr para apuntar a una nueva dirección pues ptr es 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
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 Operador sizeof devuelve el número de bytes del puntero.
// fig05_16.cpp // Operador sizeof usado con nombre de array devuelve el nº de bytes del array. #include <iostream> #include <cstddef> using std::cout; using std::endl; size_t obtieneTamanho( double * ); // prototipo 7 8 int main() 9 { double array[ 20 ]; cout << "El número de bytes del array es " << sizeof( array ); cout << "\nEl número de bytes devuelto por obtieneTamanho es " << obtieneTamanho( array ) << endl; 15 return 0; 17 } 18 // función que devuelve el tamaño de ptr 19 size_t obtieneTamanho( double *ptr ) 20 { return sizeof( 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 Operador sizeof puede usarse con nombre de variable.
// fig05_17.cpp: Demostración del operador sizeof. #include <iostream> using std::cout; using std::endl; int main() { char c; short s; int i; long l; float f; double d; long double ld; int array[ 20 ]; int *ptr = array; 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 array = " << sizeof array << "\nsizeof ptr = " << sizeof ptr << endl; return 0; 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 5.7 Expresiones y 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; puntero a variable vPtr v[0] v[1] v[2] v[4] v[3] 3000 3004 3008 3012 3016 localización

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 Usando notación de índices de array.
// fig05_20.cpp: Uso de notación de punteros e índices con arrays #include <iostream> using std::cout; using std::endl; int main() { int b[] = { 10, 20, 30, 40 }; int *bPtr = b; // hago que bPtr apunte al array b cout << "Array b impreso con:\n"; 10 // imprimo array b usando notación de índices cout << "\nNotación de índices de arrays\n"; for ( int i = 0; i < 4; i++ ) cout << "b[" << i << "] = " << b[ i ] << endl; 16 // imprimo array b usando nombre de array y notación de puntero y desplazamiento cout << "\nNotación puntero/desplazamiento con puntero=nombre de array\n"; for ( int desplaz1 = 0; desplaz1 < 4; desplaz1++ ) cout << "*(b + " << desplaz1 << ") = " << *( b + desplaz1 ) << endl; 21 // imprimo array b usando bPtr y notación de índices de arrays cout << "\nNotación puntero/subíndice\n"; for ( int j = 0; j < 4; j++ ) cout << "bPtr[" << j << "] = " << bPtr[ j ] << endl; 26 // imprimo array b usando bPtr y notación puntero/desplazamiento cout << "\nNotación puntero/desplazamiento\n"; for ( int desplaz2 = 0; desplaz2 < 4; desplaz2++ ) cout << "*(bPtr + " << desplaz2 << ") = " << *( bPtr + desplaz2 ) << endl; return 0; 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
#include <iostream> using std::cout; using std::endl; void copia1( char *, const char * ); // prototipo void copia2( char *, const char * ); // prototipo int main() 8 { char cadena1[ 10 ]; char *cadena2 = "Hola"; char cadena3[ 10 ]; char cadena4[] = "Hasta luego"; 13 copia1( cadena1, cadena2 ); cout << "cadena1 = " << cadena1 << endl; copia2( cadena3, cadena4 ); cout << "cadena3 = " << cadena3 << endl; return 0; 19 } 20 // función que copia c2 a c1 usando notación de arrays 21 void copia1( char *c1, const char *c2 ) 22 { for ( int i = 0; ( c1[ i ] = c2[ i ] ) != '\0'; i++ ) ; // 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, const char *c2 ) 28 { for ( ; ( *c1 = *c2 ) != '\0'; c1++, c2++ ) ; // 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 Los arrays pueden contener punteros
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 palos[3] palos[2] palos[1] palos[0] ’C’ ’o’ ’r’ ’a’ ’z’ ’n’ ’T’ ’é’ ’b’ ’l’ ’e’ ’s’ ’\0’ ’P’ ’i’ ’c’ ’D’ ’m’ ’t’ ’e’ ’s’ ’\0’ ’e’ ’s’ ’\0’

32 Constantes de caracteres
5.10 Procesado de Caracteres y Cadenas 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
5.10 Procesado de Caracteres y Cadenas 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
5.10 Procesado de Caracteres y Cadenas 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
5.10 Procesado de Caracteres y Cadenas 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
5.10 Procesado de Caracteres y Cadenas 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
5.10 Procesado de Caracteres y Cadenas Funciones de la Biblioteca de Manipulación de Cadenas char *strcpy( char *s1, const char *s2 ); Copia la cadena s2 en el array de caracteres s1. Se devuelve el valor de s1. char *strncpy( char *s1, const char *s2, size_t n ); Copia un máximo de n caracteres de la cadena s2 en el array de caracteres s1. Se devuelve el valor de s1. char *strcat( char *s1, const char *s2 ); Añade la cadena s2 a la cadena s1. El primer carácter de s2 sobreescribe el carácter nulo de terminación de s1. Se devuelve el valor de s1. char *strncat( char *s1, const char *s2, size_t n ); Añade un máximo de n caracteres de la cadena s2 a la cadena s1. El primer carácter de s2 sobreescribe el carácter nulo de terminación de s1. Se devuelve el valor de s1. int strcmp( const char *s1, const char *s2 ); Compara la cadena s1 con la cadena s2. La función devuelve cero, menor que cero o mayor que cero si s1 es igual, menor o mayor que s2, respectivamente.

38 5. 10 Procesado de Caracteres y Cadenas 5. 10
5.10 Procesado de Caracteres y Cadenas Funciones de la Biblioteca de Manipulación de Cadenas int strncmp( const char *s1, const char *s2, size_t n ); Compara un máximo de n caracteres de la cadena s1 con la cadena s2. La función devuelve cero, menor que cero o mayor que cero si s1 es igual, menor o mayor que s2, respectivamente. char *strtok( char *s1, const char *s2 ); Una secuencia de llamadas a strtok rompe la cadena s1 en “átomos”—partes lógicas como palabras en un texto—delimitadas por caracteres contenidos en la cadena s2. La primera llamada contiene s1 como primer argumento, y las siguientes llamadas que dividen la misma cadena en átomos contienen NULL como primer argumento. Cada llamada devuelve un apuntador al átomo actual. Si no hay más átomos 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.