User: alciro    User
 

Programación en C++ Builder

Share |
 Arrays (matrices)
 Punteros
3. Ejemplo de clase en c++
8. Métodos de la clase AnsiString
 Proyectos en C++
 Packages, distribuir una aplicación sin instalación
 Ordenación por intercambio o burbuja
 Funciones de cadenas de caracteres string.h

Funciones de cadenas de caracteres string.h

char * stpcpy (char * dest, const char * src);
wchar * _wcspcpy (WCHAR * dest, const WCHAR * src);

Copia una cadena en otra.

_stpcpy copia la cadena src a dest, parando después de alcanzar el carácter nulo de la terminación src.

stpcpy devuelve un puntero al carácter nulo de terminación de dest.

Si se define UNICODE, _wcspcpy devuelve un puntero a la terminación de carácter nulo de la cadena wchar_t dest.

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

int main(void)
{
   char string[10];
   char *str1 = "abcdefghi";

   stpcpy(string, str1);
   printf("%s\n", string);
   return 0;
}


char * strcat (char * dest, const char * src);
wchar_t * wcscat (wchar_t * dest, const wchar_t * src);
unsigned char * _mbscat (unsigned char * dest, const unsigned char * src);

Agrega una cadena a otra.

strcat añade una copia de src al final de dest. La longitud de la cadena resultante es strlen (dest) + strlen (src).

strcat devuelve un puntero a las cadenas concatenadas.

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

int main(void)
{
   char destination[25];
   char *blank = " ", *c = "C++", *Borland = "Borland";

   strcpy(destination, Borland);
   strcat(destination, blank);
   strcat(destination, c);

   printf("%s\n", destination);
   return 0;
}

 

char * strchr (const char * s, int c); / * C sólo * /
const char * strchr (const char * s, int c); / / C + + sólo
char * strchr (char * s, int c); / / C + + sólo
wchar_t * wcschr (const wchar_t * s, int c);
unsigned char * _mbschr (const unsigned char * s, unsigned int c);

Analiza una cadena en busca de la primera aparición de un carácter determinado.

strchr analiza una cadena en la dirección de avance, en busca de un determinado carácter. strchr encuentra la primera aparición del carácter c en la cadena s. El terminador nulo es considerado como parte de la cadena.

Por ejemplo:

strchr (RTS, 0)

devuelve un puntero al carácter nulo de terminación de la cadena de transacciones sospechosas.

strchr devuelve un puntero a la primera ocurrencia del carácter c en s, si c no ocurre en s, strchr devuelve un valor nulo.

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

int main(void)
{
   char string[15];
   char *ptr, c = 'r';

   strcpy(string, "This is a string");
   ptr = strchr(string, c);
   if (ptr)
      printf("The character %c is at position: %d\n", c, ptr-string);
   else
      printf("The character was not found\n");
   return 0;
}

 

int strcmp (const char * s1, const char * s2);
int wcscmp (const wchar_t * s1, const wchar_t * s2);
int _mbscmp (const unsigned char * s1, const unsigned char * s2);

Compara una cadena con otra.

strcmp realiza una comparación del contenido de s1 con s2, a partir de el primer carácter de cada cadena y continua con los siguientes caracteres hasta que los caracteres correspondientes difieren o hasta alcanzar el final de la cadenas.

Valor de Retorno

Si s1 es ...valor de retorno es ...
menor que s2 <0
el mismo que s2 == 0
mayor que s2 > 0
#include <string.h>
#include <stdio.h>

int main(void)
{
	char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";
	int ptr;

	ptr = strcmp(buf2, buf1);
	if (ptr > 0)
		printf("buffer 2 is greater than buffer 1\n");
	else
      		printf("buffer 2 is less than buffer 1\n");

   ptr = strcmp(buf2, buf3);
   if (ptr > 0)
	printf("buffer 2 is greater than buffer 3\n");
   else
	printf("buffer 2 is less than buffer 3\n");

   return 0;
}

 

int strcmpi (const char * s1, const char * s2);
int _wcscmpi (const wchar_t * s1, const wchar_t * s2);

Compara una cadena con otra, sin distinción entre mayúsculas y minúsculas.

strcmpi realiza una comparación del contenido de s1 con s2, sin distinción entre mayúsculas y minúsculas (al igual que stricmp - implementado como una macro).

Valor de Retorno

Si s1 es ...strcmpi devuelve un valor que es ...
menor que s2<0
el mismo que s2== 0
mayor que s2> 0
/* strncmpi example */ 

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

int main(void)
{
   char *buf1 = "BBB", *buf2 = "bbb";
   int ptr;

   ptr = strcmpi(buf2, buf1);

   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1\n");

   if (ptr < 0)
      printf("buffer 2 is less than buffer 1\n");

   if (ptr == 0)
      printf("buffer 2 equals buffer 1\n");

   return 0;
}

 

int strcmp (const char * s1, const char * s2);
int wcscmp (const wchar_t * s1, const wchar_t * s2);
int _mbscmp (const unsigned char * s1, const unsigned char * s2);

Compara una cadena con otra.

strcmp realiza una comparación del contenido de s1 con s2, a partir de el primer carácter de cada cadena y continua con los siguientes caracteres hasta que los caracteres correspondientes difieren o hasta alcanzar el final de la cadenas.

Valor de Retorno

Si s1 es ...valor de retorno es ...
menor que s2 <0
el mismo que s2 == 0
mayor que s2 > 0
#include <string.h>
#include <stdio.h>

int main(void)
{
	char *buf1 = "aaa", *buf2 = "bbb", *buf3 = "ccc";
	int ptr;

	ptr = strcmp(buf2, buf1);
	if (ptr > 0)
		printf("buffer 2 is greater than buffer 1\n");
	else
      		printf("buffer 2 is less than buffer 1\n");

   ptr = strcmp(buf2, buf3);
   if (ptr > 0)
	printf("buffer 2 is greater than buffer 3\n");
   else
	printf("buffer 2 is less than buffer 3\n");

   return 0;
}

 

char * strcpy (char * dest, const char * src);
wchar_t * wcscpy (wchar_t * dest, const wchar_t * src);
unsigned char * _mbscpy (unsigned char * dest, const unsigned char * src);

Copia una cadena en otra.

Copias cadena src a dest, parando después de mover el carácter nulo de la terminación.

strcpy devuelve dest.

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

int main(void)
{
   char string[10];
   char *str1 = "abcdefghi";

   strcpy(string, str1);
   printf("%s\n", string);
   return 0;
}

 

size_t strlen (const char * s);
size_t wcslen (const wchar_t * s);
size_t _mbslen (const unsigned char * s);
size_t _mbstrlen (const char * s)

Calcula la longitud de una cadena.

strlen calcula la longitud de s.

strlen devuelve el número de caracteres s, sin contar el nulo terminación de carácter.

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

int main(void)
{
   char *string = "Borland International";

   printf("%d\n", strlen(string));
   return 0;
}

 

char * strlwr (char * s);
wchar_t * _wcslwr (wchar_t * s);
unsigned char * _mbslwr (unsigned char * s);

Convierte las letras mayúsculas de una cadena en minúsculas.

strlwr convierte las letras en mayúsculas en la cadena s en minúsculas de acuerdo con categoría local LC_CTYPE . Para la configuración regional, C realiza la conversión es a partir de las letras mayúsculas (A a la Z) a las letras minúsculas (a a la z).

strlwr devuelve un puntero a la cadena s.

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

int main(void)
{
   char *string = "Borland International";

   printf("string prior to strlwr: %s\n", string);
   strlwr(string);
   printf("string after strlwr:    %s\n", string);
   return 0;
}

 

char * strncat (char * dest, const char * src, size_t maxlen);
wchar_t * wcsncat (wchar_t * dest, const wchar_t * src, size_t maxlen);
unsigned char * _mbsncat (unsigned char * dest, const unsigned char * src, size_t maxlen);
unsigned char * _mbsnbcat (unsigned char * __dest, const unsigned char * __src, _SIZE_T __maxlen);

Agrega una porción de una cadena a otra.

strncat copias los caracteres indicados maxlen de src al final de dest, y luego añade un carácter nulo. La longitud máxima de la resultante cadena es strlen (dest) + maxlen.

Para _mbsnbcat, si el segundo byte del carácter de 2 bytes es nulo, el primer byte de este personaje es considerado como nulo.

Estas cuatro funciones se comportan de forma idéntica y sólo se diferencian con respecto a la el tipo de argumentos y tipos devueltos.

strncat devuelve dest.

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

int main(void)
{
   char destination[25];
   char *source = " States";

   strcpy(destination, "United");
   strncat(destination, source, 7);
   printf("%s\n", destination);
   return 0;
}

 

int strncmp (const char * s1, const char * s2, size_t maxlen);
int wcsncmp (const wchar_t * s1, const wchar_t * maxlen s2, size_t);
int _mbsncmp (const char * s1 sin firmar, sin firmar const char * s2, size_t maxlen);
#define _mbccmp (__s1, __s2) _mbsncmp ((__s1 ),(__ s2), 1)

Compara una parte de una cadena a una parte de otra.

strncmp hace la misma comparación que strcmp, pero se sobrepasa el número de caracteres indicado en maxlen. Se inicia con el primer carácter de cada cadena y continúa con los siguientes caracteres hasta que se encuentra una diferencia o hasta que se ha examinado maxlen caracteres.

strncmp devuelve un valor entero en función del resultado de la comparación de s1 (o parte de ella) a s2 (o parte de ella):

<0si s1 es menor que s2
== 0si s1 es igual a s2
> 0si s1 es mayor que s2

 

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

int  main(void)

{
   char *buf1 = "aaabbb", *buf2 = "bbbccc", *buf3 = "ccc";
   int ptr;

   ptr = strncmp(buf2,buf1,3);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1\n");
   else
      printf("buffer 2 is less than buffer 1\n");

   ptr = strncmp(buf2,buf3,3);
   if (ptr > 0)
      printf("buffer 2 is greater than buffer 3\n");
   else
      printf("buffer 2 is less than buffer 3\n");

   return(0);

}

 

int strncmpi (const char * s1, const char * s2, size_t n);
int wcsncmpi (const wchar_t * s1, const wchar_t * s2, size_t n);

Compara una parte de una cadena a una parte de otro, sin distinción entre mayúsculas y minúsculas  .

strncmpi realiza una comparación de s1 a s2, para una longitud máxima de n bytes, comenzando con el primer carácter de cada cadena y continuar con los siguientes caracteres hasta que los caracteres correspondientes difieren o hasta que se han examinado n caracteres. La comparación hace distinción entre mayúsculas y minúsculas. (Strncmpi es el mismo que strnicmp - Implementado como una macro). Devuelve un valor (<0, 0, o> 0) sobre la base de el resultado de comparar s1 (o parte de ella) a s2 (o parte de ella).

Si s1 es ... strncmpi devuelve un valor que es ...

menor que s2<0
el mismo que s2== 0
mayor que s2> 0

 

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

int main(void)
{
   char *buf1 = "BBBccc", *buf2 = "bbbccc";
   int ptr;

   ptr = strncmpi(buf2,buf1,3);

   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1\n");

   if (ptr < 0)
      printf("buffer 2 is less than buffer 1\n");

   if (ptr == 0)
      printf("buffer 2 equals buffer 1\n");

   return 0;
}

 

char * strncpy (char * dest, const char * src, size_t maxlen);
wchar_t * wcsncpy (wchar_t * dest, const wchar_t * src, size_t maxlen);
unsigned char * _mbsncpy (unsigned char * dest, const unsigned char * src, size_t maxlen);

Copia un determinado número de bytes de una cadena en otra, truncando o relleno según sea necesario.

strncpy copia hasta personajes maxlen de src en dest, truncando dest con la inserción de null. La cadena de destino, dest, no puede ser terminada en nulo si la longitud de orig es maxlen o más.

strncpy devuelve dest.

 

#include 
#include 

int main(void)
{
   char string[10];
   char *str1 = "abcdefghi";

   strncpy(string, str1, 3);
   string[3] = '\0';
   printf("%s\n", string);
   return 0;
}

 

int strnicmp (const char * s1, const char * s2, size_t maxlen);
int _wcsnicmp (const wchar_t * s1, const wchar_t * maxlen s2, size_t);
int _mbsnicmp (const char * s1 sin firmar, sin firmar const char * s2, size_t maxlen);

Compara una parte de una cadena a una parte de otro, sin distinción entre mayúsculas y minúsculas.

strnicmp realiza una comparación de s1 a s2, para una longitud máxima de bytes maxlen, comenzando con el primer carácter de cada cadena y continuar con los siguientes caracteres hasta que los caracteres correspondientes difieren o hasta que se alcanza el final de las cuerdas. La comparación no hace distinción entre mayúsculas y minúsculas.

Devuelve un valor (<0, 0, o >0) en función del resultado de la comparación de s1 (o parte de ella) a s2 (o parte de ella).

Si s1 es ...strnicmp devuelve un valor que es ...
menor que s2<0
el mismo que s2== 0
mayor que s2> 0

 

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

int main(void)
{
   char *buf1 = "BBBccc", *buf2 = "bbbccc";
   int ptr;

   ptr = strnicmp(buf2, buf1, 3);

   if (ptr > 0)
      printf("buffer 2 is greater than buffer 1\n");

   if (ptr < 0)
      printf("buffer 2 is less than buffer 1\n");

   if (ptr == 0)
      printf("buffer 2 equals buffer 1\n");

   return 0;
}

 

char * strnset (char * s, int ch, size_t n);
wchar_t * _wcsnset (wchar_t * s, wchar_t ch, size_t n);
unsigned char * _mbsnset (unsigned char * s, unsigned int ch, size_t n);

Establece un número n determinado de caracteres ch de una cadena.

strnset copia el carácter ch en los primeros n bytes de la cadena s.

Si n> strlen (s), a continuación, strlen (s) sustituye n. Se detiene cuando se han establecido n caracteres, o cuando un carácter nulo se encuentra.

Cada una de estas funciones devuelven s.

 

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

int main(void)
{
   char *string = "abcdefghijklmnopqrstuvwxyz";
   char letter = 'x';

   printf("string before strnset: %s\n", string);
   strnset(string, letter, 13);
   printf("string after  strnset: %s\n", string);

   return 0;
}

 

char * strpbrk (const char * s1, const char * s2); / * C sólo * /
const char * strpbrk (const char * s1, const char * s2); / / C + + sólo
char * strpbrk (char * s1, const char * s2); / / C + + sólo
wchar_t * wcspbrk (const wchar_t * s1, const wchar_t * s2);
unsigned char * _mbspbrk (const unsigned char * s1, const char sin signo * S2);

Analiza una cadena en busca de la primera aparición de cualquier carácter de un determinado conjunto.

strpbrk analiza una cadena, s1, para la primera aparición de cualquier carácter que aparecen en s2.

strpbrk devuelve un puntero a la primera aparición de cualquiera de los caracteres en s2. Si no se encuentra ninguna coincidencia en s2 en s1, strpbrk devuelve un valor nulo.

#include 
#include 

int main(void)
{
   char *string1 = "abcdefghijklmnopqrstuvwxyz";
   char *string2 = "onm";
   char *ptr;

   ptr = strpbrk(string1, string2);

   if (ptr)
      printf("strpbrk found first character: %c\n", *ptr);
   else
      printf("strpbrk didn't find character in set\n");

   return 0;
}

 

char * strrchr (const char * s, int c); / * C sólo * /
const char * strrchr (const char * s, int c); / / C + + sólo
char * strrchr (char * s, int c); / / C + + sólo
wchar_t * wcsrchr (const wchar_t * s, wchar_t c);
unsigned char * _mbsrchr (const unsigned char * s, unsigned int c);

Analiza una cadena en busca de la última aparición de un carácter determinado.

strrchr analiza una cadena en la dirección contraria, en busca de un determinado carácter. strrchr encuentra la última ocurrencia del carácter c en la cadena s. El terminador nulo es considerado como parte de la cadena.

strrchr devuelve un puntero a la última ocurrencia del carácter c Si c no ocurre en s, strrchr devuelve un valor nulo.

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

int main(void)
{
   char string[15];
   char *ptr, c = 'r';

   strcpy(string, "This is a string");
   ptr = strrchr(string, c);
   if (ptr)
      printf("The character %c is at position: %d\n", c, ptr-string);
   else
      printf("The character was not found\n");
   return 0;
}

 

char * strrev (char * s);
wchar_t * _wcsrev (wchar_t * s);
unsigned char * _mbsrev (unsigned char * s);

Invierte una cadena.

strrev cambia todos los caracteres de una cadena para invertir el orden, excepto el terminación de carácter nulo. (Por ejemplo, podría cambiar de string\0 a gnirts\0).

strrev devuelve un puntero a la cadena invertida.

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

int main(void)
{
   char *forward = "string";

   printf("Before strrev(): %s\n", forward);
   strrev(forward);
   printf("After strrev():  %s\n", forward);
   return 0;
}

 

char * strset (char * s, int ch);
wchar_t * _wcsset (wchar_t * s, wchar_t ch);
unsigned char * _mbsset (unsigned char * s, unsigned int ch);

Establece todos los caracteres de una cadena a un caracter determinado.

strset establece que todos los caracteres en la cadena s al carácter ch. Se deja cuando el carácter nulo de terminación se encuentra.

strset retorna s.

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

int main(void)
{
   char string[10] = "123456789";
   char symbol = 'c';

   printf("Before strset(): %s\n", string);
   strset(string, symbol);
   printf("After strset():  %s\n", string);
   return 0;
}

 

char * strstr (const char * s1, const char * s2); / * C sólo * /
const char * strstr (const char * s1, const char * s2); / / C + + sólo
char * strstr (const char * s1, const char * s2); / / C + + sólo
wchar_t * wcsstr (const wchar_t * s1, const wchar_t * s2);
unsigned char * _mbsstr (const unsigned char * s1, const char sin signo * S2);

Analiza una cadena en busca de la aparición de una subcadena dada.

strstr explora s1 hasta la primera aparición de la subcadena s2.

strstr devuelve un puntero al elemento de s1, s2, donde comienza (puntos de s2 en s1). Si no ocurre s2 en s1, strstr devuelve un valor nulo.

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

int main(void)
{
   char *str1 = "Borland International", *str2 = "nation", *ptr;

   ptr = strstr(str1, str2);
   printf("The substring is: %s\n", ptr);
   return 0;
}


char * strupr (char * s);
wchar_t * _wcsupr (wchar_t * s);
unsigned char * _mbsupr (unsigned char * s);

Convierte las letras minúsculas en una cadena en mayúsculas.

strupr convierte las letras minúsculas en la cadena s en mayúsculas de acuerdo con categoría LC_CTYPE del locale actual.  La conversión es de letras minúsculas (a - z) a las letras mayúsculas (A a Z). Otros caracteres no se modifican.

strupr retorna s.

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

int main(void)
{
   char *string = "abcdefghijklmnopqrstuvwxyz", *ptr;

   /* converts string to upper case characters */
   ptr = strupr(string);
   printf("%s\n", ptr);
   return 0;
}

 

Loading

copyright © 2007-2024  www.alciro.org  All rights reserved.         
Share |