miércoles, 25 de septiembre de 2019

MANEJO DE FUNCIONES DE CADENA

Nombres               
Propósito
ejemplo
copia n bytes entre dos áreas de memoria que no deben solaparse
/* memcpy example */
#include <stdio.h>
#include <string.h>
struct {
  char name[40];
  int age;
} person, person_copy;
int main ()
{
  char myname[] = "Pierre de Fermat";
  /* using memcpy to copy string: */
  memcpy ( person.name, myname, strlen(myname)+1 );
  person.age = 46;
  /* using memcpy to copy structure: */
  memcpy ( &person_copy, &person, sizeof(person) );
  printf ("person_copy: %s, %d \n", person_copy.name, person_copy.age );
  return 0;
}
copia n bytes entre dos áreas de memoria; al contrario que memcpy las áreas pueden solaparse
/* memmove example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char str[] = "memmove can be very useful......";
  memmove (str+20,str+15,11);
  puts (str);
  return 0;
}
busca un valor a partir de una dirección de memoria dada y devuelve un puntero a la primera ocurrencia del valor buscado o NULL si no se encuentra
/* memchr example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char * pch;
  char str[] = "Example string";
  pch = (char*) memchr (str, 'p', strlen(str));
  if (pch!=NULL)
    printf ("'p' found at position %d.\n", pch-str+1);
  else
    printf ("'p' not found.\n");
  return 0;
}
compara los n primeros caracteres de dos áreas de memoria
/* memcmp example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char buffer1[] = "DWgaOtP12df0";
  char buffer2[] = "DWGAOTP12DF0";
 
  int n;
 
  n=memcmp ( buffer1, buffer2, sizeof(buffer1) );
 
  if (n>0) printf ("'%s' is greater than '%s'.\n",buffer1,buffer2);
  else if (n<0) printf ("'%s' is less than '%s'.\n",buffer1,buffer2);
  else printf ("'%s' is the same as '%s'.\n",buffer1,buffer2);
 
  return 0;
}
sobre escribe un área de memoria con un patrón de bytes dado
/* memset example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char str[] = "almost every programmer should know memset!";
  memset (str,'-',6);
  puts (str);
  return 0;
}
añade una cadena al final de otra
/* strcat example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char str[80];
  strcpy (str,"these ");
  strcat (str,"strings ");
  strcat (str,"are ");
  strcat (str,"concatenated.");
  puts (str);
  return 0;
}
añade los n primeros caracteres de una cadena al final de otra
/* strncat example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char str1[20];
  char str2[20];
  strcpy (str1,"To be ");
  strcpy (str2,"or not to be");
  strncat (str1, str2, 6);
  puts (str1);
  return 0;
}
localiza un carácter en una cadena, buscando desde el principio
/* strchr example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char str[] = "This is a sample string";
  char * pch;
  printf ("Looking for the 's' character in \"%s\"...\n",str);
  pch=strchr(str,'s');
  while (pch!=NULL)
  {
    printf ("found at %d\n",pch-str+1);
    pch=strchr(pch+1,'s');
  }
  return 0;
}
localiza un carácter en una cadena, buscando desde el final
/* strrchr example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char str[] = "This is a sample string";
  char * pch;
  pch=strrchr(str,'s');
  printf ("Last occurence of 's' found at %d \n",pch-str+1);
  return 0;
}
compara dos cadenas alfabéticamente ('a'!='A')
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char key[] = "apple";
  char buffer[80];
  do {
     printf ("Guess my favorite fruit? ");
     fflush (stdout);
     scanf ("%79s",buffer);
  } while (strcmp (key,buffer) != 0);
  puts ("Correct answer!");
  return 0;
}
compara los n primeros caracteres de dos cadenas numéricamente ('a'!='A')
/* strncmp example */
#include <stdio.h>
#include <string.h>
 
int main ()
{
  char str[][5] = { "R2D2" , "C3PO" , "R2A6" };
  int n;
  puts ("Looking for R2 astromech droids...");
  for (n=0 ; n<3 ; n++)
    if (strncmp (str[n],"R2xx",2) == 0)
    {
      printf ("found %s\n",str[n]);
    }
  return 0;
}
compara dos cadenas según la colación actual ('a'=='A')
#include <stdio.h>
#include <string.h>
 
int main()
{
   char s1[5] = "Abeja";
   char s2[5] = "abeja";
   int i;
 
   printf( "s1=%s\t", s1 );
   printf( "s2=%s\n", s2 );
 
   i = strcoll( s1, s2 );
   printf( "s1 es " );
   if( i < 0 )  printf( "menor que" );
   else if( i > 0 )  printf( "mayor que" );
   else  printf( "igual a" );
   printf( " s2\n" );
 
   return 0;
}
copia una cadena en otra
/* strcpy example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str1[]="Sample string";
  char str2[40];
  char str3[40];
  strcpy (str2,str1);
  strcpy (str3,"copy successful");
  printf ("str1: %s\nstr2: %s\nstr3: %s\n",str1,str2,str3);
  return 0;
}
copia los n primeros caracteres de una cadena en otra
/* strncpy example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str1[]= "To be or not to be";
  char str2[40];
  char str3[40];
  /* copy to sized buffer (overflow safe): */
  strncpy ( str2, str1, sizeof(str2) );
  /* partial copy (only 5 chars): */
  strncpy ( str3, str2, 5 );
  str3[5] = '\0';   /* null character manually added */
  puts (str1);
  puts (str2);
  puts (str3);
  return 0;
}
devuelve la cadena con el mensaje de error correspondiente al número de error dado
/* strerror example : error list */
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main ()
{
  FILE * pFile;
  pFile = fopen ("unexist.ent","r");
  if (pFile == NULL)
    printf ("Error opening file unexist.ent: %s\n",strerror(errno));
  return 0;
}
devuelve la longitud de una cadena
/* strlen example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char szInput[256];
  printf ("Enter a sentence: ");
  gets (szInput);
  printf ("The sentence entered is %u characters long.\n",(unsigned)strlen(szInput));
  return 0;
}
devuelve la posición del primer carácter de una cadena que no coincide con ninguno de los caracteres de otra cadena dada
/* strspn example */
#include <stdio.h>
#include <string.h>
int main ()
{
  int i;
  char strtext[] = "129th";
  char cset[] = "1234567890";
  i = strspn (strtext,cset);
  printf ("The initial number has %d digits.\n",i);
  return 0;
}
devuelve la posición del primer carácter que coincide con alguno de los caracteres de otra cadena dada
/* strcspn example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] = "fcba73";
  char keys[] = "1234567890";
  int i;
  i = strcspn (str,keys);
  printf ("The first number in str is at position %d.\n",i+1);
  return 0;
}
encuentra la primera ocurrencia de alguno de los caracteres de una cadena dada en otra
/* strpbrk example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] = "This is a sample string";
  char key[] = "aeiou";
  char * pch;
  printf ("Vowels in '%s': ",str);
  pch = strpbrk (str, key);
  while (pch != NULL)
  {
    printf ("%c " , *pch);
    pch = strpbrk (pch+1,key);
  }
  printf ("\n");
  return 0;
}
busca una cadena dentro de otra
/* strstr example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] ="This is a simple string";
  char * pch;
  pch = strstr (str,"simple");
  strncpy (pch,"sample",6);
  puts (str);
  return 0;
}
parte una cadena en una secuencia de tokens
/* strtok example */
#include <stdio.h>
#include <string.h>
int main ()
{
  char str[] ="- This, a sample string.";
  char * pch;
  printf ("Splitting string \"%s\" into tokens:\n",str);
  pch = strtok (str," ,.-");
  while (pch != NULL)
  {
    printf ("%s\n",pch);
    pch = strtok (NULL, " ,.-");
  }
  return 0;
}
transforma una cadena en su forma de colación (??)
#include <stdio.h>
#include <string.h>
 
int main()
{
   char s2[7] = "abcdefg";
   char s1[7];
   int i;
 
   i = strxfrm( s1, s2, 4 );
   printf( "s2=%s\n", s2 );
   printf( "s1=%s\tlonguitud=%d\n", s1, i );
 
   return 0;
}
invierte una cadena
#include<stdio.h>
#include<string.h>
  
int main()
{
   char str[50] = "geeksforgeeks";
  
   printf("The given string is =%s\n",str);
  
   printf("After reversing string is =%s",strrev(str));
  
   return 0;
}
¿QUE ES STRING.H?
string.h es un archivo de la Biblioteca estándar del lenguaje de programación C que contiene la definición de macros, constantes, funciones y tipos y algunas operaciones de manipulación de memoria.
Las funciones declaradas en string.h se han hecho muy populares, por lo que están garantizadas para cualquier plataforma que soporte C. Sin embargo, existen algunos problemas de seguridad con estas funciones, como el desbordamiento de buffer (buffer overflow), que hacen que algunos programadores prefieran opciones más seguras frente a la portabilidad que estas funciones ofrecen. Además, las funciones para cadenas de caracteres sólo trabajan con conjuntos de caracteres ASCII o extensiones ASCII compatibles.La biblioteca <string.h> contiene un conjunto de funciones para manipular cadenas: copiar, cambiar caracteres, comparar cadenas, etc.
Las funciones más elementales son:
strcpy ( c1, c2 ); Copia c2 en c1
strcat ( c1, c2 ); Añade c2 al final de c1
int strlen ( cadena ); Devuelve la longitud de la cadena
int strcmp ( c1, c2 ); Devuelve cero si c1 es igual a c2;
no-cero en caso contrario
Para trabajar con estas funciones, al comienzo del programa hay que escribir
 #include <string.h>

Ejemplo:

#include <stdio.h>
#include <string.h>

char completo [80];

char nombre[32] = "Pedro";
char apellidos [32] = "Medario Arenas";

main()
{
  /* Construye el nombre completo */

  strcpy ( completo, nombre ); /* completo <- "Pedro" */
  strcat ( completo, " ");    /* completo <- "Pedro " */
  strcat ( completo, apellidos ); /* completo <- "Pedro 
          Medario Arenas" */

  printf ( "El nombre completo es %s\n", completo );

}
¿QUE ES GOTOXY?
La función gotoxy es una función de las librerías de Borland ® que se encuentra en la librería conio.h .
gotoxy mueve el cursor de la ventana de texto a la posición según las coordenadas especificadas por los argumentos x e y. Si las coordenadas no son válidas entonces la llamada a la función gotoxy es ignorada. Los argumentos no pueden ser 0 y normalmente en los programas de consola las dimensiones de la pantalla son 80 caracteres horizontales por 25 líneas verticales. Se debe tener en cuenta que si se escribe en el último caracter de la línea 25 se provoca un salto de línea, por lo tanto desaparecerá la primera. Lo mismo ocurre si tras escribir algo en la línea 25 o estar situado en ella aparece un salto de línea ('\n').
EJEMPLO DE GOTOXY
#include
int main() {
clrscr();
cprintf( "Ejemplo de \"gotoxy\"\r\n\r\n" );
cprintf( "1ª línea" );
cprintf( "2ª línea" );
gotoxy( 5, 20 );
cprintf( "3ª línea" );
gotoxy( 20, 1 );
cprintf( "4ª línea" );
gotoxy( 1, 15 );
cprintf( "Pulsa una tecla para continuar...\r\n" );
getch();
return 0;
}
¿QUE ES PRINTF ? Mediante la función printf podemos escribir datos en el dispositivo de salida estandar (pantalla). Complementariamente a scanf, printf puede escribir cualquier combinación de valores numéricos, caracteres sueltos y cadenas de caracteres. La función printf transporta datos desde la memoria a la pantalla, a diferencia de scanf, que envía datos desde el teclado para almacenarlos en la memoria. La función printf devuelve el número de caracteres escritos. Si devuelve un valor negativo indica que se ha producido un error.
En general, una refencia a la función printf se escribe:  
 
printf (cadena de control, lista de argumentos);
en donde cadena de control hace referencia a una cadena de caracteres que contiene información sobre el formato de la salida y la lista de argumentos son argumentos que representan los datos de salida.
A diferencia de la función scanf, los argumentos en la función printf no representan direcciones de memoria y por tanto no son precedidos por &. Además, dentro de los argumentos se pueden incluir referencias a funciones.
En la cadena de control se incluyen grupos individuales de caracteres cada uno de los cuales deben comenzar por %. Normalmente, un grupo de caracteres estará formado por el signo de porcentaje seguido de un carácter de conversión que indica el tipo del dato correspondiente (debe haber igual número de caracteres de conversión como de argumentos).
Pueden incluirse varios grupos de caracteres seguidos o separados por otros caracteres, caracteres éstos que serán enviados directamente a la pantalla, donde serán visualizados (es muy frecuente el uso de caracteres en blanco para separar grupos de caracteres).
Además, los caracteres de conversión pueden incluir los siguientes modificadores:
  • Longitud del campo: Un número entero entre % y el carácter de conversión.
  • Número de dígitos decimales: Un número entero, un punto y un segundo número entre % y el carácter de conversión indica el número de dígitos decimales, y la long. máx. para enteros o cadenas.
  • Justificación a la izquierda: Signo - después del signo %.
  • Veamos en una tabla los carácteres de conversión más frecuentes:
    (recordar que delante de estos carácteres va siempre %)    
     
     
    Carácter 
    Significado
    cEscribe un carácter simple
    dEscribe un entero decimal con signo
    iEscribe un entero decimal, octal o hexadecimal con signo
    eEscribe un número en punto flotante con exponente
    fEscribe un número en punto flotante sin exponente
    gUsa %e o %f, el más corto en longitud
    oEscribe un entero octal, sin el cero inicial
    sEscribe una cadena de caracteres
    uEscribe un entero decimal sin signo
    xEscribe un entero hexadecimal sin el prefijo 0x.
    ¿QUE ES STRNCAT? 
    En computación el lenguaje de programación C ofrece una llamada en la biblioteca estándar de C denominada strcat. Esta permite añadir un bloque de memoria a otro. Los dos bloques deben terminar con un carácter nulo. Como en C las cadenas de caracteres no son tipos de datos en sí mismos strcat añade una cadena a otra pasándole dos punteros a los bloques de memoria reservados. El nombre strcat es una abreviación de "string concatenate" (concatenación de cadena).
    Por ejemplo:
     char str1[100] = "¡ Hola,";    /* 100: se reserva espacio extra */
     strcat (str1, " mundo !\n");
     printf (str1);                 /* muestra "¡ Hola, mundo !" en la salida estándar */
    
    Esta es una posible implementación de strcat:
      char *strcat (char *dest, const char *src)
      {
        const char *p;
        char *q;
    
        for (q = dest; *q != '\0'; q++)
           ;
        
        for(p = src; *p != '\0'; p++, q++)
           *q = *p;
        
        *q = '\0';
    
        return dest;
      }
    
    También se puede definir usando otras funciones de la biblioteca de cadenas:
     char *strcat (char *dest, const char *src)
     {
         strcpy (dest + strlen (dest), src);
         return dest;
     }

    No hay comentarios:

    Publicar un comentario

    Examen 4

    #include <iostream> #include <stdio.h> #include <stdlib.h> using namespace std; void menu(); void captura(); void i...