apéndicesdea.unsj.edu.ar/informatica2/recursos/apuntes/apendices.pdf · dentro de una cadena...

Facultad de Ingeniería

Departamento de Electrónica y Automática

Apéndices

Cátedra:

Computación II (ELO)

Informática II (BIO)

COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO) Introducción al Lenguaje de Programación C

INDICE 10 Apéndice de tablas y funciones de utilidad........................................................................................ 1

10.1 Secuencias de Escape ................................................................................................................. 1 10.2 Resumen de Operadores ............................................................................................................. 1 10.3 Tipos de datos y reglas de conversión de datos.......................................................................... 2

10.3.1 Reglas de Conversión.......................................................................................................... 2 10.3.2 Reglas de Asignación .......................................................................................................... 3

10.4 El conjunto de caracteres ASCII................................................................................................. 3 10.5 Resumen de estructuras de control ............................................................................................. 4 10.6 Especificadores de formato más usados en la función scanf. ..................................................... 4 10.7 Especificadores de formato de la función printf......................................................................... 5

10.7.1 Indicadores .......................................................................................................................... 6 10.7.2 Funciones de biblioteca....................................................................................................... 6

COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO-ELO) Introducción al Lenguaje de Programación C

1

Apéndices

10 Apéndice de tablas y funciones de utilidad

10.1 Secuencias de Escape

Caracter Secuencia de escape Valor ASCII Campana (alerta) \a 7

Espacio atrás (backspace) \b 8 Tabulador horizontal \t 9

Nueva línea (cambio de línea) \n 10 Tabulador vertical \v 11

Alimentación de página \f 12 Retorno de carro \r 13

Comillas (“) \” 34 Apóstrofe (‘) \’ 39

Interrogación (?) \? 63 Barra invertida (\) \\ 92

Caracter nulo \0 0 Constante octal \ooo (o es un nro. octal)

Constante hexadecimal \xh (h es un nro. hexad.)

La mayoría de los compiladores permiten que el apóstrofe (‘) y la interrogación (?) aparezcan dentro de una cadena constante como un caracter ordinario o como una secuencia de escape.

10.2 Resumen de Operadores

Grupo de precedencia Operadores Asociatividad Función, Arreglos ( ) [ ] I�D

Miembro de estructura, puntero a miembro de

estructura . -> I�D

Operadores unarios - ++ -- ! ~ * & sizeof(tipo) D�I Multiplicación numérica,

División y resto * / % I�D

Suma y resta numérica + - I�D Operadores de desplazamiento

<< >> I�D

Operadores relacionales < <= > >= == != I�D Y(And) a nivel de bits & I�D

O exclusiva a nivel de bits ^ I�D O a nivel de bits | I�D

Y lógica(Comparación) && I�D O lógica (Comparación) || I�D Operador condicional ? : D�I

Operadores de asignación = += -= *= /= %= &= ^= |= <<= >>= D�I Operador coma , I->D


2

Nota: Los grupos de precedencia están ordenador de mayor a menor precedencia. Algunos compiladores modernos del Lenguaje C también incluyen un operador mas unario (+) para complementar el operador menos unario (- ). Por tanto una expresión con el + unario es equivalente al valor de su operando, por ejemplo +v tiene el mismo valor que v .

10.3 Tipos de datos y reglas de conversión de datos Tipo de dato Descripción

int cantidad entera short entero corto(puede tener menos bytes que int) long entero largo (puede tener mas bytes que int)

unsigned entero sin signo (no neg. siendo el doble que int) char caracter

signed char caracter con valores entre –128 y +127 unsigned char caracter con valores de 0 a 255

float número de coma flotante (con . decimal y/o exponente) double número de coma flotante en doble presicion

long double número de coma flotante en doble precisión (mayor a double) void tipo especial de datos para funciones que no retornan valor enum constante de enumeración (tipo especial de int)

Nota: El calificador unsigned puede aparecer con short int o long int, por ejemplo unsigned short int.

10.3.1 Reglas de Conversión

Estas reglas se aplican a operaciones aritméticas entre dos operadores de distinto tipo de datos. Puede existir alguna variación de una versión de C a otra. 1) Si uno de los operandos es long double , el otro será convertido a long double .

2) En otro caso si, uno de los operandos es double , el otro se convertirá a double y resultado será double .

3) Si uno de los operandos es float , el otro será convertido a float y el resultado será float .

4) Si uno de los operandos es unsigned long int , el otro será convertido a unsigned long int y el resultado será unsigned long int .

5) Si uno de los operando es long int y el otro es unsigned long int , entonces:

a) Si unsigned int puede convertirse a long int , el operando unsigned int será convertido y el resultado será long int

b) En otro caso, ambos operandos serán convertidos a unsigned long int y el resultado será unsigned long int .

6) Si uno de los operandos es long int , el otro será convertido a long int y el resultado será long int .

7) Si uno de los operandos es unsigned int el otro será convertido a unsigned int y el resultado será unsigned int .

8) Si no se puede aplicar ninguna de las condiciones anteriores, entonces ambos operandos serán convertidos a int (si es necesario) y el resultado será int .


3

10.3.2 Reglas de Asignación

Si los dos operandos en una expresión de asignación son de tipos distintos, entonces el valor del operando de la derecha será automáticamente convertido al tipo de operando de la izquierda. La expresión completa de asignación será de este mismo tipo. Además:

1) Un valor en coma flotante puede truncarse si se asigna a un valor entero.

2) Un valor de doble precisión puede ser redondeado si se asigna a un identificador de coma flotante (Simple precisión).

3) Una cantidad entera puede ser alterada si se asigna a un identificador de entero más corto o a un identificador de caracter (algunos de los bits más significativos pueden perderse).

10.4 El conjunto de caracteres ASCII

Valor ASCII Caracter Valor

ASCII Caracter Valor ASCII Caracter Valor

ASCII Caracter

000 NUL 032 blanco 064 @ 096 `

001 SOH 033 ! 065 A 097 a

002 STX 034 " 066 B 098 b

003 ETX 035 # 067 C 099 c

004 EOT 036 $ 068 D 100 d

005 ENQ 037 % 069 E 101 e

006 ACK 038 & 070 F 102 f

007 BEL 039 ' 071 G 103 g

008 BS 040 ( 072 H 104 h

009 HT 041 ) 073 I 105 i

010 LF 042 * 074 J 106 j

011 VT 043 + 075 K 107 k

012 FF 044 , 076 L 108 l

013 CR 045 - 077 M 109 m

014 SO 046 . 078 N 110 n

015 SI 047 / 079 O 111 o

016 DLE 048 0 080 P 112 p

017 DC1 049 1 081 Q 113 q

018 DC2 050 2 082 R 114 r

019 DC3 051 3 083 S 115 s

020 DC4 052 4 084 T 116 t

021 NAK 053 5 085 U 117 u

022 SYN 054 6 086 V 118 v

023 ETB 055 7 087 W 119 w

024 CAN 056 8 088 X 120 x

025 EM 057 9 089 Y 121 y

026 SUB 058 : 090 Z 122 z

027 ESC 059 ; 091 [ 123 {

028 FS 060 < 092 \ 124 |

029 GS 061 = 093 ] 125 }

030 RS 062 > 094 ^ 126 ~

031 US 063 ? 095 _ 127 DEL

Nota: Los 32 primeros caracteres y el último son ca racteres de control; no se pueden imprimir.


4

10.5 Resumen de estructuras de control Estructura Forma general Ejemplos

break break; for (n=1; n<=100; ++n) { scanf(“%f”,&x); if (x<0) {

printf(“ERROR”); break;

} ... }

continue continue; for (n=1; n<=100; ++n) { scanf(“%f”,&x); if (x<0) {

printf(“ERROR”); continue;

} ... }

do-while do { estructura

} while( expresion );

do { printf(“%d\n”, digito++);

} while(digito<=9 ); for for(exp1; exp2; exp3)

estructura for (digito=0; digito<=9; ++digito) {

printf(“%d\n”, digito); }

if if( expresion ) estructura

if(x<0) printf(“%f”,x);

if-else if( expresion ) estructura 1

else estructura 2

if(estado==’S’) tasa=0.20*paga;

else tasa=0.14*paga;

return return expresion; return ( n1+n2 ); switch switch(expresion-entera){

case expresion 1: estructura 1 estructura 2 ... estructura m break;

case expresion 2: estructura 1 estructura 2 ... estructura n break; ...

default: estructura 1 estructura 2 ... estructura k

}

switch(eleccion=getchar()) { case ‘R’:

printf(“ROJO”); break;

case ‘B’: printf(“BLANCO”); break;

case ‘A’: printf(“AZUL”); break;

default: printf(“ERROR”);

}

while while(expresion) estructura

while(digito<=9) { printf(“%d\n”,digito++);

}

10.6 Especificadores de formato más usados en la fu nción scanf. Especificador de

formato Significado

c el dato es un caracter


5

d el dato es un entero decimal e el dato es un valor en coma flotante f el dato es un valor en coma flotante g el dato es un valor en coma flotante h el dato es un entero corto i el dato es un entero decimal, hexadecimal u octal o el dato es un entero octal s el dato es una cadena seguida por un espacio en blanco (el

caracter nulo \0 se añade automáticamente al final) u el dato es un entero sin signo x el dato es un entero hexadecimal

[...] el dato es una cadena que puede contener espacios en blanco

Un prefijo puede preceder ciertas conversiones de caracteres.

Prefijo Significado h dato corto (entero corto o entero sin signo corto) l dato largo (entero largo, entero largo sin signo o real de

doble precisión) L dato largo (real en doble precisión largo)

Ejemplo: int a;

short b;

long c;

unsigned d;

double x;

char str[80];

scanf("%5d %3hd %12ld %12lu %15lf", &a, &b, &c, &d, &x);

scanf("%[^\n]", str);

10.7 Especificadores de formato de la función print f Especificador

de formato Significado

c el dato se muestra como un caracter d el dato se muestra como un entero decimal e el dato se muestra como un valor en coma flotante con exponente f el dato se muestra como un valor en coma flotante sin exponente g el dato se muestra como un valor en coma flotante usando la conversión de

tipo e o f, dependiendo del valor; no se muestran ceros no significativos ni el punto decimal si no es significativo

i el dato se muestra como un entero decimal con signo o el dato se muestra como un entero octal, sin el cero inicial s el dato se muestra como una cadena u el dato se muestra como un entero decimal sin signo x el dato se muestra como un entero hexadecimal, sin el 0x del principio

Se debe tener en cuenta que algunos especificadores de formato se interpretan de modo diferente que con la función scanf.

Un prefijo puede preceder ciertas conversiones de caracteres.

Prefijo Significado h dato corto (entero corto o entero sin signo corto)


6

l dato largo (entero largo, entero largo sin signo o real de doble precisión) L dato largo (real en doble precisión largo)

Ejemplo: int a;

short b;

long c;

unsigned d;

double x;

char str[80];

printf("%5d %3hd %12 ld %12lu %15.7 le", a, b, c, d, x);

printf("%40s\n", str);

10.7.1 Indicadores Indicador Significado

- El dato es justificado a la izquierda dentro del campo (los espacios en blanco necesarios para rellenar la anchura de campo mínima se añadirán detrás del dato en vez de delante)

+ Un signo (+ o -) precederá a cada valor numérico con signo. Sin este indicador, sólo los valores negativos estarán precedidos por un signo.

0

Produce la aparición de ceros iniciales en vez de blancos. Se aplica sólo a los datos que están justificados a la derecha en campos cuya anchura mínima es mayor que el dato. (Nota: Algunos compiladores consideran el indicador cero como una parte de la especificación de anchura de campo en vez de como un indicador real. Esto asegura que el 0 se procesa el último si están presentes múltiples indicadores.)

‘ ‘ (espacio en blanco)

Un espacio en blanco precederá a cada valor positivo. Este indicador es anulado por el indicador + si ambos están presentes.

# (con conversiones de

tipo o- y x-)

Produce que los datos octales y hexadecimales sean precedidos por 0 y 0x respectivamente.

# (con conversiones de

tipo e-, f- y g-)

Produce que esté presente el punto decimal en todos los números en coma flotante, incluso si el número no tiene decimales. También trunca los ceros no significativos en una conversión del tipo g-.

Ejemplo: int a;

short b;

long c;

unsigned d;

double x;

printf("%+5d %+5hd %+12 ld %-12 lu %#15.7 le", a, b, c, d, x);

10.7.2 Funciones de biblioteca

El lenguaje C contiene numerosas funciones prediseñadas agrupadas en bibliotecas y cuando se emplean funciones de alguna de esas bibliotecas, se incrementa la portabilidad de los programas. Algunas de estas bibliotecas son:

Nombre de Biblioteca Descripción

assert.h Proporciona la definición de la macro assert , que imprime un mensaje de error y aborta el programa


7

Nombre de Biblioteca Descripción

ctype.h Contiene funciones que permiten conocer la naturaleza de un caracter, o bien para convertir de mayúsculas a minúsculas y viceversa; y valores enteros a códigos ASCII.

dir.h Contiene funciones que permiten ordenar, crear, modificar, mover y eliminar directorios

errno.h Representa los números de error: después que ocurre un error se puede consultar el valor de la variable del sistema errno para obtener mas información sobre ese error.

float.h Define los limites de los tipos de coma flotante limits.h Define los limites de los diferentes tipos de enteros

math.h Contiene las funciones matemáticas estándar utilizadas en C. signal.h Contiene funciones relacionadas con las señales del sistema operativo.

stdarg.h Brinda soporte a funciones con listas de argumentos de longitud variable.

stdef.h Se definen algunos tipos de datos especiales.

stdio.h Incorporan las funciones de Entrada y Salida estándar, tipos de datos y macros.

stdlib.h Declara funciones que son útiles para diferentes propósitos, en especial de gestión de memoria y de búsqueda/ordenación.

string.h Este archivo contiene funciones para manejo de cadenas de caracteres. time.h Contiene funciones relativas a fechas y horas

Para usar una función contenida en alguna biblioteca, es necesario indicar al compilador el nombre de la biblioteca en la cual está definida dicha función, y esto se logra nombrando la biblioteca en una cláusula #include

COMPUTACIÓN II (ELO) - INFORMÁTICA II (BIO) Lenguaje de Programación C

8

Nombre de función Tipo

Biblioteca a la cual

pertenece Sintaxis Descripción Ejemplo

1 abs(i) int stdlib.h int abs(int i); Devuelve el valor absoluto de i x = abs(-7)

2 acos(d) double math.h double acos(double d); Devuelve el arco coseno de d angulo = acos(0.5);

3 asin(d) double math.h double asin(double d); Devuelve el arco seno de d angulo = asin(0.707);

4 atan(d) double math.h double atan(double d); Devuelve la arco tangente de d. angulo atan(1.0);

5 atan(d1, d2) double math.h double atan(double d1, double d2); Devuelve el arco tangente de d1/d2 angulo = atan(y, x)

double x;

char *cad_dbl = "200.85";

6 atof(s) double stdlib.h double atof(const char *cadena)

Convierte la cadena s a una cantidad de doble precisión. Requiere el llamado de la biblioteca math.h

x=atof(cad_dbl);

Convierte la cadena s a un entero. int i;

La cadena debe tener el siguiente formato:

char *cad_ent="123";

[espacio en blanco][signo][ddd] (siendo obligatorio los dígitos decimales).

...

7 atoi(s) int stdlib.h int atoi(const char *cadena)

i=atoi(cad_ent);

Convierte la cadena s a un entero largo.

long int i;

La cadena debe tener el siguiente formato:

char cad_ent="9876543";

[espacio en blanco][signo][ddd] (siendo obligatorio los dígitos decimales).

... 8 atol(s) long stdlib.h

long atol(const char *cadena);

i=atoi (cad_ent);


9




malloc.h y stdlib.h

Reserva memoria para una formación de n elementos, cada uno de s bytes. Devuelve un puntero al principio del espacio reservado.

long *buffer

o bien Si no existente bastante espacio para el nuevo bloque o bien n o s es 0, calloc devuelve nulo.

buffer=(long *) calloc(40, sizeof(long));

alloc.h y

9 calloc(n,s) void *

stdlib.h

void *calloc(size_t n, size_t s);

10 ceil(d) double math.h double ceil(double d); Devuelve un valor redondeado por exceso al siguiente entero mayor

redondeo=ceil(5.1);

double cos(double d); 11 cos(d) double math.h

Devuelve el coseno de d coseno_x=cos(1.6543)

double cos(double d); d=1.00; 12 cosh(d) double math.h

Devuelve el coseno hiperbólico de d

printf("d=%f.\n\n,d);

time_t inicio, fin;

clrscrl();

inicio=time(NULL);

delay(5000)

fin=time(NULL)

print("Diferencia en segundos: %f\n",

13 difftime(11,12) double time.h double difftime(time_t hora2, time_t hora1)

Devuelve la diferencia de tiempo 11(hora2) - 12(hora1) , donde 11 y 12 representan el tiempo transcurrido después de un tiempo base (ver función time)

difftime(inicio,fin));

14 exit(u) void stdlib.h void exit(int estado)

Cierra todos los archivos y buffers y termina el programa. El valor de estado se emplea para indicar el estado de terminación.

exit(0);

double exp(double d); d=100.00;

y=exp(d); 15 exp(d) double math.h

Eleve e a la potencia d (e=2,7182818... es la base del sistema de logaritmos naturales (neperianos)) printf("El exponencial de

x=%f.\n\n",y);


10




16 fabs(d) double math.h double fabs(double d); Devuelve el valor absoluto de d y=fabs(-7.25); // y vale 7.25

17 fclose(f) int stdio.h int fclose(FILE *f); Cierra el archivo f . Devuelve el valor 0 si el archivo se ha cerrado con éxito.

fclose("archivo");

18 feof(f) int stdio.h int feof(FILE *f);

Verifica si se ha encontrado el fin de un archivo: si es así, devuelve un valor distinto de cero, en caso contrario devuelve 0.

feof(fichen);

19 fgetc(f) int stdio.h int fgetc(FILE f); Lee un caracter del archivo f c+fgetc(fp)

20 fegts(s,i,f) char * stdio.h char *fgets(char s, int s, FILE *f);

Lee una cadena s , con hasta i caracteres desde archivo f

fgets(caddemo, 80, fp);

21 floor(d) double math.h double floor(double d); Devuelve un valor redondeado por defecto al entero menor más cercano.

x=floor(6.25); // x vale 6

22 fmod(d1,d2) double math.h double fmod(double d1, double d2);

Devuelve el resto de d1/d2 (con el mismo signo que d1)

resto=fmod(5.0,2.0);

Abre un archivo llamado s1 preparado para la operación s2 . Devuelve un puntero a la estructura FILE que representa al archivo.

if ((archiv=fopen("datos","w+"))==NULL)

printf("El archivo...no se ha abierto \n");

Modo Acción

"r" Abre para lectura

"w" Abre un archivo vacío para escritura

"a" Abre para escritura al final del archivo

23 fopen(s1, s2) file * stdio.h FILE *fopen(const char *s1, const char *s2)

"r+" Abre para lectura/escritura


11




"w+" Abre un archivo vacío para lectura/escritura

"a+" Abre para lectura y añadir

"rb" Abre un archivo binario para lectura.

"wb" Abre un archivo binario para escritura

"ab" Abre un archivo binario para añadir

"rb+" Abre un archivo binario para lectura/escritura.

"wb+" Abre un archivo binario para lectura/escritura

"ab+" Abre o crea un archivo binario para lectura/escritura

24 fprintf(f, ...) int stdio.h int fprintf(FILE *f, const char *formato [,arg,...]);

Escribe datos en el archivo f fprintf(f1, "El resultado es %f\n",result);

25 fputc(c, f) int stdio.h int fputc(int c, FILE *f); Escribe un caracter en el archivo f fputc(*(p++), stdout);

26 fputs(s, f) int stdio.h int fputs(const char *cad, FILE *f)

Escribe una cadena de caracteres en el archivo f

fputs("esto es una prueba", f1);

27 fread(s, i1, i2, f) int stdio.h size_t fread(void *p, size_t i1, size_t i2, FILE *f);

Lee i2 elementos, cada uno de tamaño i1 bytes, desde el archivo f a la posición de memoria p

fread(buf, strlen(msg)+1, 1, flujo);

28 free(p) void malloc.h o Libera un bloque de memoria char *cad;


12




cad=(char *)malloc(50);

...

stdlib.h void free(void *dir_memoria);

reservada cuyo principio esta indicado por p.

free(cad); // liberar memoria

29 fscanf(f, ...) int math.h int fscanf(FILE *f, const char *formato, [ , direccion,... ]);

Lee datos del archivo f fscanf(flujo,” %s%f “, cad, &f);

Mueve el puntero al archivo f una distancia de cuantos bytes a partir de la posición desde .

Notas:

Origen Significado SEEK_SET Principio de archivo SEEK_CUR Posición actual puntero

30 fseek(f, l, i) int stdio.h int fseek(FILE *f, long cuantos, int desde);

SEEK_END Final del archivo

fseek(f1,0L,SEEK_SET); // ir al principio del archivo

31 ftell(f) long int stdio.h long int ftell(FILE *f);

Devuelve la posición actual del puntero dentro del archivo f

ftell(archiv)

32 fwrite(s, i1, i2, f) int stdio.h size_t fwrite(const void *p, size_t i1, size_t i2, FILE *f);

Escribe i2 elementos, cada uno de tamaño i1 bytes, desde la posición de memoria p al el archivo f

num = fwrite(lista,sizeof(char),25,flujo);

while((c=getc(fx) ) != EOF) {

printf ("%c",c); 33 getc(f) int stdio.h int getc(FILE *f); Lee un caracter del archivo f }

int c;

while((c=getchar()) != '\n') 34 getchar( ) int stdio.h int getchar(void); Lee un caracter desde el dispositivo de entrada estándar

print ("%c",c);


13




35 gets(s) char * stdio.h char *gets(char *cad); Lee una cadena de caracteres desde el dispositivo de entrada estándar

gets(nombre);

carac=getch();

if( isalnum(carac) )

print("%c es una letra o digito\n",carac);

36 isalnum(c) int ctype.h int isalnum(int c);

Determina si el argumento es alfanumérico. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

int c;

37 isalpha(c) int ctype.h int isalpha(int c); Determina si el argumento es alfabético. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isalpha(c) ) printf("%c es letra\n",c);

int c;

38 isascii(c) int ctype.h int isascii(int c);

Determina si el argumento es un caracter ASCII. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isascii(c) ) printf(“%c es un ascii\n",c);

39 iscntrl(c) int ctype.h int isacntrl(int c);

Determina si el argumento es un caracter ASCII de control. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( iscntrl(c) ) printf("%c es un caracter de control\n",c);

40 isdigit(c) int ctype.h int isdigit(int c); Determina si el número es un digito decimal. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isdigit(c) ) printf ("%c es un digito\n",c);

41 isgraph(c) int ctype.h int isgraph(int c);

Determina si el argumento es un caracter ASCII grafico (hex 0x21 -0x7e; octal 041 -176). Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isgraph(c) ) printf ("%c es un caracter imprimible(no espacio)\n",c);

42 islower(c) int ctype.h int islower(int c); Determina si el argumento es una minúscula. Devuelve un valor distinto

if( islower(c) ) printf ("%c es una letra


14




de cero si lo es o 0 en caso contrario. minuscula\n",c);

43 isodigit(c) int ctype.h int isodigit(int c); Determina si el argumento es un digito octal. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isodigit(c) ) printf("%c es un digito octal\n",c);

44 isprint(c) int ctype.h int isprintint c);

Determina si el argumento es un caracter ASCII imprimible (hex 0x20 -0x7e; octal 040 -176). Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isprint(c) ) printf("%c es imprimible\n",c);

45 ispunct(c) int ctype.h int ispunct(int c);

Determina si el argumento es un símbolo de puntuación. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( ispunct(c) ) printf("%c es un simbolo de puntuacion\n",c);

46 isspace(c) int ctype.h int isspace(int c);

Determina si el argumento es un espacio en blanco. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isspace(c) ) printf("%c es un espacio\n",c);

47 isupper(c) int ctype.h int isupper(int c); Determina si el argumento es una mayúscula. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isupper(c) ) printf ("%c es una mayuscula\n",c);

48 isxdigit(c) int ctype.h int isxdigit(int c);

Determina si el argumento es un digito hexadecimal. Devuelve un valor distinto de cero si lo es o 0 en caso contrario.

if( isxdigit(c) ) print ("%c es un digito hexadecimal\n",c);

long lx = -51654,ly; 49 labs(l) long int math.h

long int labs(long int num); Devuelve el valor absoluto de num.

ly = labs(lx);

double x,y; 50 log(d) double math.h double log(double d); Devuelve el logaritmo natural de d x = 10;


15




y = log(x);

double x,y;

x = 10; 51 log10(d) double math.h double log10(double d); Devuelve el logaritmo en base 10 de d y = log10(x);

52 malloc(u) void * stdlib.h void *malloc(size_t u); Reserva u bytes de memoria y devuelve un puntero al inicio del espacio reservado.

cadena = malloc(MAX_CHR);

double x=2.0, y=4.0, z; 53 pow(d1, d2) double math.h

double pow(double d1, double d2); Devuelve d1 elevado a la potencia d2 z = pow(x,y);

//z sera 16.0

Escribe datos en el dispositivo de salida estándar.

Código Formato

%c Caracter

%d Entero Decimal

%e Real (double o float), notación científica.

%f Coma flotante

%s Cadena de caracteres

54 printf(...) int stdio.h int printf(const char *formato[,argumento,...]);

%x Hexadecimal sin signo

printf("producto %d y %d es %d\n", x, y, x*y);

55 putc(c, f) int stdio.h int putc(int c, FILE *f); Escribe un caracter en el archivo f putc('*',demo);


16




56 putchar(c) int stdio.h int putchar(int c); Escribe un caracter en el dispositivo de salida estándar.

putchar('B');

57 puts(s) int stdio.h int puts(const char *cad)

Escribe una cadena de caracteres en el dispositivo de salida estándar.

puts("Desea continuar:s/n,”);

for( i=0; i<10; i++ )

printf("%6d\",rand());

58 rand( ) int stdlib.h int rand(void); Devuelve un entero positivo aleatorio.

59 rewind(f) void stdio.h void rewind(FILE *f); Mueve el puntero del archivo al inicio del mismo f

rewind( fx );

Lee datos en dispositivo de entrada estándar

Código Formato

%c Caracter

%d Entero Decimal

%x Hexadecimal

%i Entero Decimal

%f Número Real %o Octal %p Puntero

60 scanf(...) int stdio.h int scanf(const char *formato {,direccion,...]);

%s Cadena

scanf(“%d %f %c %s”,&i,&fp, &c, s);

double x, y; 61 sin(d) double math.h double sin(double d); Devuelve el seno de d x=0.52;


17




printf(“x=%f radianes\n",x);

y=cos(x);

printf("el coseno de x =%f\n",y);

62 sinh(d) double math.h double sinh(double d); Devuelve el seno hiperbólico de d y=sinh(x);

63 sqrt(d) double math.h double sqrt(double d); Devuelve la raíz cuadrada de d printf("%lf",sqrt(25.0));

64 sprintf(s, …) int stdio.h

int sprintf(char *s, const char *formato[,argumento,...])

Envía la salida formateada a la cadena s. El formato se especifica igual que en printf()

sprintf(cadena, "%s %d", nombre, edad); printf("\n%s", cadena);

65 srand(u) void stdlib.h void srand(unsigned u); Inicializa el generador de números aleatorios.

srand(semilla);

i = strcmp("MNP", "mnp"); // resultado < 0

i = strcmp("abc", "abc"); // resultado = 0

i = strcmp("xy", "abc"); // resultado > 0

char s1[80]="Mayo";

char s2[80]="Octubre";

int j;

j = strcmp(s1,s2);

66 strcmp(s1, s2) int string.h int strcmp(const char*s1, const char *s2);

Compara dos cadenas de caracteres léxico gráficamente. Devuelve un valor <0 si s1 < s2 ; =0 si s1 y s2 son idénticas y un valor >0 si s1 > s2

67 sscanf(s, …) int stdio.h int sscanf(const char *s, const char *formato [,direccion,...]);

Lee datos desde la cadena s y los almacena de acuerdo con el formato y los almacena en las ubicaciones indicadas por la direccion . formato , se especifica igual que en scanf()

sscanf ("Osvaldo tiene 12 anios","%s %*s %d",str,&i);


18




68 strcmpi(s1, s2) int string.h int strcmpi(const char*s1, const char *s2);

Compara dos cadenas de caracteres léxico gráficamente, sin diferenciar mayúsculas de minúsculas . Devuelve un valor <0 si s1 < s2 ; =0 si s1 y s2 son idénticas y un valor >0 si s1 > s2

v = strcmpi(s1,s2);

69 strcat(s1, s2) char * string.h char *strcat(char *s1, const char *s2)

Concatena la cadena s2 a la cadena s1. Retorna un puntero a la cadena s1

strcat(dest, a_concatenar); printf("Concat: %s", dest);

char *s1="Pepe Luis";

char b[12];

strcpy(s2,s1);

70 strcpy(s1, s2) char string.h char *strcpy(char s1, const char s2);

Copia la cadena de caracteres s2 en la cadena s1

71 strchr(s, c) char * String.h char *strchr(const char *s, int c)

Busca en la cadena s la primera ocurrencia del carácter c y devuelve un puntero a la posición encontrada o NULL si no lo encuentra.

char cadena[55]="Cadena de prueba"; char *p; p = strchr(cadena,'e');

72 strrchr(s, c) char * string.g char *strrchr(const char *s, int c)

Busca en la cadena s la última ocurrencia del carácter c y devuelve un puntero a la posición encontrada o NULL si no lo encuentra.

char cadena[55]="Cadena de prueba"; char *p; p = strchr(cadena,'e');

longitud = strlen(nombre);

char s[81]= “Cadena demo”; 73 strlen(s) int string.h size_t strlen(const char *s);

Devuelve el número de caracteres de una cadena.

printf(“La longitud de s es: %d\n”, strlen(s));

char *cad = “----”;

74 strset(c, s) char * string.h char *strset(char *cad, int c);

Pone todos los caracteres de s a c (excluyendo el caracter nulo del final \0)

strset(cad,'x'); // cad es ahora xxxx


19




75 strstr(s1, s2) char * string.h char *strstr(const char *s1, const char *s2);

Busca cierta subcadena s2 dentro de una cadena de texto s1. Devuelve un puntero a la primera ocurrencia de la secuencia entera de s2 o NULL si no es encontrada.

if(!strstr(ciudad,"mendoza")) puts("Ciudad incorrecta");

76 strtok(s, delim) char * string.h char *strtok(char *s, const char *delim)

Divide la cadena s en función del delimitador delim . Devuelve un puntero al primer elemento dividido de la cadena (no al delimitador) o NULL si no encuentra el dilimitador.

char cadena[50] ="Prueba,cad1,Prueba,cad2:Prueba:cad3"; char *p; p = strtok (cadena,",:");

77 system(s) int string.h int system(char *cmd);

Pasa la orden al sistema operativo. Devuelve cero si la orden se ejecuta correctamente; en otro caso devuelve un valor distinto de cero, típicamente -1 .

system(“dir”);

78 tan(d) double math.h double tan(double d); Devuelve la tangente de d y=tan(x);

79 tanh(d) double math.h double tanh(double d); Devuelve la tangente hiperbólica de d a=tanh(x);

80 time(p) long int time.h time_t time(time_t *h); Devuelve el número de segundos transcurridos después de un tiempo base designado.

time(&hora);

81 toascii int ctype.h int toascii(int c); Convierte el valor del argumento a ASCII

c=toascii(entero);

82 tolower int ctype.h o stdlib.h

int tolower(int c); Convierte una letra a minúscula c=tolower('S'); // c se convierte en 's'

82 toupper int ctype.h o stdlib.h

int toupper(int c); Convierte una letra a mayúscula c=toupper('s'); // c se convierte en 'S'

apéndicesdea.unsj.edu.ar/informatica2/recursos/apuntes/apendices.pdf · dentro de una cadena...

Documents