Cadenas y apuntadores Programacin Variables de tipo char

Cadenas y apuntadores Programación

Variables de tipo char Las variables de tipo char ocupan un byte. Los valores posibles son de -128 a 127. Las constantes de tipo char pueden especificarse utilizando un carácter o una secuencia de escape encerrada entre apóstrofos. ‘a’, ‘ 5’, ‘n’ Pueden mezclarse con variables enteras. char x, y; int a, b; x = 45; y = ‘a’; a = 2*x; b = 3*x – y;

Lectura de caracteres scanf (stdio. h) utilizando el formato %c. requiere presionar ENTER getch (conio. h) no requiere de ENTER. getchar (stdio. h) requiere presionar ENTER #include <stdio. h> #include <conio. h> printf("n"); main(){ printf("ningrese otro caracter: "); char p 1, p 2, p 3=65; scanf("%c", &p 2); printf("ningrese un caracter: "); printf("%c", p 2); p 1 = getchar(); printf("ningrese otro caracter: "); putchar(p 1); p 2 = getch(); printf("n"); printf("caracter leido: %c", p 2); printf("nel caracteer p 3 es: "); getch(); putchar(p 3); }

Uso de fflush Se requiere borrar el buffer para leer correctamente #include <stdio. h> #include <conio. h> printf("ningrese otro caracter: "); main(){ scanf("%c", &p 2); char p 1, p 2, p 3=65; printf("%c", p 2); printf("ningrese un caracter: "); printf("ningrese otro caracter: "); p 1 = getchar(); fflush(stdin); putchar(p 1); p 2 = getch(); printf("n"); fflush(stdin); printf("caracter leido: %c", p 2); printf("nel caracteer p 3 es: "); getch(); putchar(p 3); printf("n"); }

Funciones básicas de ctype. h Función Significado isdigit(c) Regresa un 1 si el argumento c es un dígito, sino regresa 0. isalpha(c) Regresa un 1 si el argumento c es una letra, sino regresa 0. islower(c) Regresa un 1 si el argumento c es una letra minúscula, sino regresa 0. isupper(c) Regresa un 1 si el argumento c es una letra mayúscula, sino regresa 0. tolower(c) Regresa el carácter c convertido a minúscula. toupper(c) Regresa el carácter c convertido a mayúscula.

ejemplo #include <stdio. h> #include <conio. h> #include <ctype. h> main(){ char c 1, c 2, c 3, c 4; printf("tecle un caracter: "); c 1 = getch(); fflush(stdin); if(isdigit(c 1)) printf("%c es un digiton", c 1); else printf("%c NO es un digiton", c 1); printf("tecle un caracter: "); c 2 = getch(); fflush(stdin); if(isalpha(c 2)) printf("%c es una letran", c 2); else printf("%c NO es una letran", c 2); printf("tecle un caracter: "); c 3 = getch(); fflush(stdin); if(isupper(c 3)){ printf("%c es una letra mayusculan", c 3); printf("La minuscula de %c es %cnn", c 3, tolower(c 3)); } if(islower(c 3)){ printf("%c es una letra minusculan", c 2); printf("La mayuscula de %c es %cnn", c 3, toupper(c 3)); } getch(); }

Ejemplo de Conversión #include <stdio. h> #include <conio. h> #include <ctype. h> char a. Mayuscula(char c){ if(isalpha(c)) return toupper(c); switch(c){ case 'á': return 'Á'; case 'é': return 'É'; case 'í': return 'Í'; case 'ó': return 'Ó'; case 'ú': return 'Ú'; case 'ñ': return 'Ñ'; } } main(){ printf("%cn", a. Mayuscula(‘á')); getch(); }

Función issymbol #include <stdio. h> #include <conio. h> char issymbol(char c){ if(c<=47||c>=58&&c<=64||c>=91&&c<=96||c>=123) return 1; return 0; } main(){ printf("%d printf("%d getch(); } n", issymbol('2')); n", issymbol('a')); n", issymbol('A')); n", issymbol('(')); n", issymbol('? ')); n", issymbol('[')); n", issymbol('{'));

tarea Escriba una función que regrese 1 si el parámetro de tipo char es letra o número.

Quiz Que valores se imprimen en la pantalla con las siguientes sentencias: El código ASCII de ‘A’ es 65. char a = ‘E’; printf(“%c es una letra, su codigo ASCII es %dn”, a, a); printf(“%c %d”, tolower(a), isdigit(a));

Cadenas Una cadena de caracteres es un arreglo unidimensional de caracteres que termina con el carácter . El nombre de la variable de cadena se utiliza como un apuntador al inicio del arreglo de caracteres. Las constantes de tipo cadena se encierran entre comillas dobles. Ejemplos: char a[10] = “hola”; char m[25] = “”; char *x = “San Luis Potosí”;

Declaración e inicialización #include <stdio. h> #include <conio. h> main(){ // declara una cadena de longitud 20 como máximo. char a[20]; // declara una cadena de longitud 20 como máximo. // el contenido es la cadena “hola”, x[4] = ‘’. char x[10] = "hola"; // declara una cadena de 4 caracteres mas char *m = "que tal"; // declara una cadena con longitud variable char s[] = {'B', 'i', 'e', 'n', 'v', 'e', 'n', 'i', 'd', 'o', ''}; // declara una cadena con longitud variable char nom[] = "juan perez"; puts(x); puts(m); puts(s); puts(nom); printf("x es "%s", ", x); printf("m es "%s", ", m); printf("s es "%s", ", s); printf("nom es "%s" ", nom); getch(); }

Lectura de cadenas #include <stdio. h> #include <conio. h> main(){ //cadena de longitud variable char cad 2[10]="hola"; char *cad 0; char *cad 1; cad 0 = "Marruecos"; puts(cad 0); cad 0 = "San Luis Potosi"; puts(cad 0); //lectura de cadena variable gets(cad 1); puts(cad 1); //lectura de cadena de longitud fija printf("%sn", cad 2); gets(cad 2); puts(cad 2); scanf("%s", cad 2); puts(cad 2); getch(); }

Biblioteca stdlib. h Función Significado atoi(cad) Convierte cadena a entero atof(cad) Convierte cadena a double strtod(cad, &cad 2) Convierte cadena a double atol(cad) Convierte cadena a long strtol(cad, &cad 2, base) Convierte cadena a long

Ejemplo #include <stdio. h> #include <stdlib. h> #include <conio. h> main(){ char s 1[20], *s 2; int i; long l; double d; printf("introduce cadena: "); gets(s 1); i = atoi(s 1); l = atol(s 1); d = atof(s 1); printf("s 1 = "%s"n", s 1); printf("i = %dn", i); printf("l = %dn", l); printf("d = %lfn", d); l = strtol(s 1, &s 2, 0); printf("%d, s 2= %sn", l, s 2); d = strtod(s 1, &s 2); printf("%lf, s 2= %sn", d, s 2); getch(); }

Quiz ¿Qué función realiza la conversión especificada? 1. atol ___ convierte carácter a mayúscula 2. atod ___ convierte cadena a entero 3. atoi ___ convierte carácter a minúscula 4. tolower ___ convierte cadena a entero largo 5. toupper ___ convierte cadena a double

Contar caracteres #include <stdio. h> #include <stdlib. h> #include <conio. h> int cuenta(char s[], char c){ int i=0, cuenta=0; while(s[i]){ if(s[i]==c) cuenta++; i++; } return cuenta; } main(){ char s[50], c; printf("Cuenta el numero de veces que aparecenun caracter en una cadenan"); printf("introduce cadena: "); gets(s); printf("introduce el caracter a contar: "); c = getchar(); printf("el caracter '%c' aparece %d vecesn“ , c, cuenta(s, c)); getch(); }

Cuenta las vocales de una cadena int cuenta. Vocales(char s[]){ int i=0, cuenta=0; while(s[i]){ if(tolower(s[i])=='a'|| tolower(s[i])=='e'|| tolower(s[i])=='i'|| tolower(s[i])=='o'|| tolower(s[i])=='u' ) cuenta++; i++; } return cuenta; }

Otra solución para contar vocales main(){ int cuenta. Vocales; char s[50]; printf("Escriba cadena: "); gets(s); cuenta. Vocales=cuenta(s, 'a')+cuenta(s, 'e')+ cuenta(s, 'i')+cuenta(s, 'o')+cuenta(s, 'u'); printf("Total de vocales %d", cuenta. Vocales); getch(); }

Convierte a mayúsculas una cadena void a. Mayusculas(char s[]){ int i=0; while(s[i]){ s[i] = toupper(s[i]); i++; } } main(){ char s[50]; printf("Cuenta el número de vocales en una cadenan"); printf("introduce cadena: "); gets(s); a. Mayusculas(s); printf("la cadena en mayusculas es: n%s", s); getch(); }

Reemplazar un carácter por otro void reemplaza(char s[], char c 1, char c 2){ int i=0; while(s[i]){ if(s[i]==c 1) s[i] = c 2; i++; } } main(){ char s[50], c 1, c 2; printf("reemplaza un caracter por otro en una cadenan"); printf("introduce cadena: "); gets(s); printf("introduce el caracter a reemplazar: "); c 1 = getchar(); fflush(stdin); printf("introduce el caracter de reemplazo: "); c 2 = getchar(); reemplaza(s, c 1, c 2); printf("la cadena reeplazada es: n%s", s); getch(); }

Suma de dígitos de un número #include <stdio. h> #include <ctype. h> #include <conio. h> main(){ int suma. Digitos(char int suma; s[]){ char s[50]; int i=0, suma=0; printf("Escriba cadena: "); while(s[i]){ gets(s); if(isdigit(s[i])) suma = suma. Digitos(s); suma += s[i]-'0'; printf("Suma de digitos = %d", suma); i++; getch(); } } return suma; }

Extraer fecha del CURP El CURP está formado por una cadena de 18 caracteres, la fecha la forman los caracteres del 5 al 10. La siguiente función extrae el día, el mes y el año de nacimiento. #include <stdio. h> #include <ctype. h> #include <conio. h> void *a *m *d } fecha. CURP(char s[], int *d, int *m, int *a){ = 1900+(s[4]-'0')*10+(s[5]-'0'); = (s[6]-'0')*10+(s[7]-'0'); = (s[8]-'0')*10+(s[9]-'0');

Actividad Escriba una función que cambie todos los dígitos iguales a ‘ 0’ por la letra ‘o’ y los unos ‘ 1’ por letras ‘I’ de una cadena que pase como parámetro. void reemplaza(char s[], char c 1, char c 2){ int i=0; while(s[i]){ if(s[i]==c 1) s[i] = c 2; i++; } }

Funciones de cadenas Biblioteca string. h Función Descripción strcpy(cad 1, cad 0) Copia la cadena cad 0 en la cadena cad 1 strncpy(cad 1, cad 0, n) Copia n caracteres de la cadena cad 0 en la cadena cad 1 strcat(cad 1, cad 0) Añade una copia de cad 0 al final de la cadena cad 1. strncat(cad 1, cad 0, n) Añade n caracteres de cad 0 al final de la cadena cad 1 strstr(cad 1, cad 0) Localiza la primera ocurrencia de la cadena cad 0 en la cadena cad 1, regresa el apuntador a esa cadena. strlen(cad 0) Regresa la longitud de la cadena cad 0 strcmp(cad 0, cad 1) Compara cad 0 con cad 1, regresa un entero mayor, igual o menor que cero según si la cadena cad 0 es mayor, igual o menor que cad 2. strchr(cad, c) Localiza la primera ocurrencia del carácter c dentro de la cadena cad y regresa el apuntador a la cadena restante.

Ejemplo strcpy #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s 2[8] = "abcdefg"; char s 1[8]; strcpy( s 1, s 2 ); printf( "s 2=%sn", s 2 ); printf( "s 1=%sn", s 1 ); getch(); return 0; }

Ejemplo strncpy #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s 2[8] = "abcdefg"; char s 1[8]; strncpy( s 1, s 2, 3); printf( "s 2=%sn", s 2 ); printf( "s 1=%sn", s 1 ); getch(); return 0; }

Ejemplo strcat #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s 1[11] = "Hola "; char s 2[8] = "amigos"; printf( "s 1=%st", s 1 ); printf( "s 2=%sn", s 2 ); strcat( s 1, s 2 ); printf( "s 1=%sn", s 1 ); getch(); return 0; }

Ejemplo strncat #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s 1[11] = "Hola "; char s 2[8] = "amigos"; printf( "s 1=%st", s 1 ); printf( "s 2=%sn", s 2 ); strncat( s 1, s 2, 4); printf( "s 1=%sn", s 1 ); getch(); return 0; }

Ejemplo strstr #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s 1[13] = "Hola a todos"; char s 2[3] = "la"; printf( "s 1=%sn", s 1 ); printf( "s 2=%sn", s 2 ); printf( "strstr(s 1, s 2) = %sn", strstr( s 1, s 2 ) ); getch(); return 0; }

Ejemplo strlen #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s[13] = "Hola a todos"; printf( "s=%sn", s ); printf( "strlen(s) = %dn", strlen( s ) ); getch(); return 0; }

Ejemplo strcmp #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s 1[10] = "Abeja"; char s 2[10] = "Abeja"; int i; printf( "s 1=%st", s 1 ); printf( "s 2=%sn", s 2 ); i = strcmp( s 1, s 2 ); printf( "s 1 es " ); if( i < 0 ) printf( "menor que" ); else if( i > 0 ) printf( "mayor que" ); else printf( "igual a" ); printf( " s 2 (strcmp = %d)n", i); getch(); return 0; }

Ejemplo strchr #include <stdio. h> #include <conio. h> #include <string. h> int main() { char s[20] = "Hola amigos"; char c = 'a'; printf( "s=%st", s ); printf( "c=%cn", c ); printf( "strchr=%sn", strchr( s, c ) ); getch(); return 0; }

Ejemplo contar caracteres #include <stdio. h> #include <conio. h> #include <string. h> int main() { char cad 1[50], cad 2[50], *cad 3; int i=0; printf("escriba cadeba: "); gets(cad 1); printf("escriba cadeba a contar: "); gets(cad 2); strcpy(cad 3, cad 1); //localiza la primera ocurrencia printf("AQUI"); cad 3 = strstr(cad 3, cad 2); //licaliza las demás ocurrencias while(cad 3!=NULL){ i++; cad 3 = strstr(cad 3+1, cad 2); } printf("n. Se encontraron %d ocurrencias. n", i); getch(); }

Actividad Cual es la salida del siguiente programa: #include <stdio. h> #include <conio. h> #include <string. h> int main() { char cad 1[50]="bienvenidos a Mexico"; char cad 2[50]; strcpy(cad 2, cad 1); printf("cad 2 = %sn", cad 2); strcat(cad 1, strstr(cad 2, "Mex")); printf("cad 1 = %sn", cad 1); strncat(cad 1, cad 2, 10); printf("cad 1 = %sn", cad 1); getch(); }

Quiz Escriba una sentencia utilizando las funciones de cadena para extraer las cadenas que se solicita de la cadena suministrada. s 1 = “San Luis Potosí” extraer “Luis” Obtenga la cadena “esta es una cadena concatenada” a partir de las cadenas y las funciones de cadena (AYUDA: puede hacer llamadas anidadas de la función strcat) s 1 = “cadena ” s 2 = “concate” s 3 = “ es una ” s 4 = “esta” strcpy(cad 1, cad 0) strncpy(cad 1, cad 0, n) strcat(cad 1, cad 0) strncat(cad 1, cad 0, n) strstr(cad 1, cad 0) strlen(cad 0) strcmp(cad 0, cad 1) strchr(cad, c)

Arreglos de cadenas Un arreglo de cadenas es una arreglo bidimensional de caracteres. Podemos ver el arreglo bidimensional como un arreglo de una dimensión de cadenas de caracteres. Se pueden utilizar las funciones revisadas anteriormente en cada elemento del arreglo.

Ordenación de una lista de nombres #include <stdio. h> #include <string. h> #include <conio. h> void intercambia(char cad 1[50], char cad 2[50]){ char temp[50]; strcpy(temp, cad 1); strcpy(cad 1, cad 2); strcpy(cad 2, temp); } void ordena(char lista[][50], int num){ int i, j; for(i = 0; i<num-1; i++){ for(j = i+1; j<num; j++) if(strcmp(lista[i], lista[j])>0) intercambia(lista[i], lista[j]); } }

int leer. Lista(char lista[][50]){ int i=0, hecho=0; char s[50]; printf("Escriba los nombres (FIN=terminar)n"); do{ gets(lista[i]); if(strcmp(lista[i], "FIN")!=0) i++; else hecho = 1; }while(!hecho); return i; } void imprime(char lista[][50], int num){ int i; for(i = 0; i<num; i++) puts(lista[i]); }

main(){ char nombres[50]; int total; total = leer. Lista(nombres); ordena(nombres, total); imprime(nombres, total); getch(); }

Apuntadores Una variable de tipo apuntador contiene una dirección de memoria. La dirección de memoria señalada por el apuntador es la que contiene el dato que puede ser de cualquier tipo, incluso void. entero Asigna la dirección de entero a 548 pentero int entero, *pentero; entero = 548; pentero = &entero; entero 548 *pentero = -234; pentero NOTA: a los apuntadores solo puede asignárseles: 0, NULL o una dirección entero -234

Ejemplo #include <stdio. h> #include <conio. h> main(){ int entero, *pentero; entero = 548; pentero = &entero; printf("La dirección de entero es %dn", &entero); printf("el valor de pentero es %dn", pentero); printf("el valor de entero es %dn", entero); printf("el valor de *pentero es %dn", *pentero); *pentero = -234; printf("el valor de entero es %dn", entero); printf("el valor de *pentero es %dn", *pentero); getch(); }

Aritmética de apuntadores Los apuntadores pueden utilizarse para acceder a los elementos de un arreglo. #include <stdio. h> #include <conio. h> main(){ int a[10]={3, 4, 1, 8, 2, 3, 4, 5, 7, 0}, *b; b = a; //b apunta al inicio del arreglo a printf("dirección de b es %d, el contenido %dn", b, *b); b = b + 1; //b apunta a a[1] printf("dirección de b es %d, el contenido %dn", b, *b); b = b + 3; //b apunta a a[4] printf("dirección de b es %d, el contenido %dn", b, *b); b = b - 2; //b apunta a a[2] printf("dirección de b es %d, el contenido %dn", b, *b); es es

#include <stdio. h> #include <conio. h> main(){ double a[10]={3, 4, 1, 8, 2, 3, 4, 5, 7, 0}, *b; b = a; //b apunta al inicio del arreglo a printf("dirección de b es %d, el contenido b = b + 1; //b apunta a a[1] printf("dirección de b es %d, el contenido b = b + 3; //b apunta a a[4] printf("dirección de b es %d, el contenido b = b - 2; //b apunta a a[2] printf("dirección de b es %d, el contenido getch(); } es %lfn", b, *b);

Apuntadores y subíndices La aritmética de apuntadores y los subíndices son equivalentes. #include <stdio. h> #include <conio. h> main(){ double a[10]={3, 4, 1, 8, 2, 3, 4, 5, 7, 0}, *b; int i; b = a; //b apunta al inicio del arreglo a for(i=0; i<10; i++) printf("a[%d]=%lfn", i, a[i]); for(i=0; i<10; i++) printf("*(b+%d)=%lfn", i, *(b+i)); getch(); }

Apuntadores a funciones Las funciones se comportan como apuntadores. El nombre de la función es un apuntador al inicio del código de la función. Las funciones pueden pasarse como parámetros a otras funciones.

Ejemplo de apuntador a función #include <stdio. h> #include <conio. h> #include <math. h> void tabula(double a, double b, double (*fun)(double )){ double x, y; for(x=a; x<=b; x+=(b-a)/10. 0){ y = (*fun)(x); printf("f(%lf) = %lf n", x*180/3. 1416, y); } } main(){ tabula(0, 3. 1416/2, sin); tabula(0, 3. 1416/2, cos); getch(); }

Salida de apuntador a función f(0. 000000) = 0. 000000 f(9. 000000) = 0. 156435 f(18. 000000) = 0. 309018 f(27. 000000) = 0. 453991 f(36. 000000) = 0. 587786 f(45. 000000) = 0. 707108 f(54. 000000) = 0. 809018 f(63. 000000) = 0. 891008 f(72. 000000) = 0. 951057 f(81. 000000) = 0. 987689 f(0. 000000) = 1. 000000 f(9. 000000) = 0. 987688 f(18. 000000) = 0. 951056 f(27. 000000) = 0. 891006 f(36. 000000) = 0. 809016 f(45. 000000) = 0. 707105 f(54. 000000) = 0. 587783 f(63. 000000) = 0. 453988 f(72. 000000) = 0. 309014 f(81. 000000) = 0. 156431

¿Que valores tienen las variables? int x. *px: float y, *py; x = 5; px = &x; *px = 2*x + *px; y = x; py = y; y = *py + x; printf(“*p = %d x = %dn”, *px, x); printf(“*p = %f x = %fn”, *py, y); x *px y *py

Suponga la siguiente declaración: float n 1 = 7. 3, n 2; Escriba una sentencia para cada una de las siguientes acciones: Declare ptr. F como un apuntador a un objeto tipo float Asigne la dirección de n 1 a ptr. F Despliegue el valor del objeto apuntado por ptr. F Asigne el valor del objeto apuntado por ptr. F a n 2 Despliegue el valor de n 2 Despliegue la dirección de n 1 Despliegue la dirección almacenada en ptr. F Asigne a ptr. F la dirección de n 2 Asigne al valor del objeto apuntado por ptr. F el valor 8. 1 Despliegue el valor de n 2

Funciones de cadenas estilo Pascal Las siguientes funciones implementan algunas de las funciones y procedimientos utilizadas en el lenguaje Pascal. Supondremos que las cadenas están declaradas como arreglos de 256 caracteres (incluyendo el de terminación). Función Descripción copystr extrae una subcadena de una cadena deletestr borra una subcadena de una cadena inserta una subcadena dentro de otra pos busca una subcadena dentro de otra cadena

Función copystr void copystr(char s[256], char s 1[256], int n, int c){ int i, l=strlen(s 1); if(l<n)s[0] = ''; else{ for(i=0; i<c&&i<l; i++) s[i]=s 1[n+i]; s[i]=''; } }

Función deletestr void deletestr(char s[256], int n, int c){ int i=0, l=strlen(s); if(!(l<n)) while(s[i+n]){ s[i+n]=s[i+n+c]; i++; } }

Función insertstr void insertstr(char s[256], char s 1[256], int n){ int i, len=strlen(s); char temp[256]; copystr(temp, s 1, n, 256); for(i=0; i<len&&i<255; i++) s 1[i+n] = s[i]; for(i=0; i<len&&(i+n+len<255); i++) s 1[i+n+len] = temp[i]; s 1[i+n+len] = ''; }

Función pos int pos(char s 1[256], char s 2[256]){ int len 1, len 2, i, j 1, j 2; len 1 = strlen(s 1); len 2 = strlen(s 2); for(i=0; i<=len 2 -len 1; i++){ j 1 = 0; j 2 = i; while(s 1[j 1]==s 2[j 2]&&s 1[j 1]!=''){ j 1++; j 2++; } if(j 1==len 1)return i; } return -1; }

Ejemplo main(){ char c 1[256], c 2[256]; strcpy(c 1, "hola tal"); printf("c 1 = %sn", c 1); strcpy(c 2, "que "); printf("c 2 = %sn", c 2); insertstr(""esta es una prueba "", c 1, 5); printf("inserta "esta es una prueba " en c 1 = %sn", c 1); deletestr(c 1, 0, 8); printf("borra de 0 a 8 en c 1 = %sn", c 1); deletestr(c 1, 10, 7); printf("borra de 10 a 17 en c 1 = %sn", c 1); deletestr(c 1, 16, 5); printf("borra de 16 a 21 en c 1 = %sn", c 1); printf("pos de "una" = %dn", pos("una", c 1)); printf("pos de "xxx" = %dn", pos("xxx", c 1)); printf("pos de "tal" = %dn", pos("tal", c 1)); getch(); }