PDF de programación - Cadenas en C#

Una cadena de C# es una matriz de caracteres que se declara utilizando la palabra clave string. Un literal de
cadena se declara utilizando las comillas, como se muestra en el siguiente ejemplo:
string s = "Hello, World!";

Puede extraer subcadenas y concatenar cadenas de la siguiente manera:
string s1 = "orange";
string s2 = "red";

s1 += s2;
System.Console.WriteLine(s1); // outputs "orangered"

s1 = s1.Substring(2, 5);
System.Console.WriteLine(s1); // outputs "anger"

Los objetos de cadena son inmutables, lo que significa que no se pueden cambiar una vez creados. Los
métodos que actúan sobre las cadenas, devuelven los nuevos objetos de cadena. En el ejemplo anterior,
cuando el contenido de s1 y s2 se concatenan para formar una sola cadena, las dos cadenas que contienen
"orange" y "red" no se modifican. El operador += crea una nueva cadena que contiene el contenido
combinado. Como resultado, s1 ahora hace referencia a una cadena totalmente diferente. Todavía existe una
cadena que sólo contiene "orange" , pero deja de hacerse referencia a ella cuando se concatena s1.

Tenga cuidado cuando cree referencias a cadenas. Si crea una referencia a una cadena y después "modifica"
la cadena, la referencia seguirá señalando al objeto original y no al nuevo objeto que se creó cuando se
modificó la cadena. Esta situación peligrosa se ilustra en el código siguiente:

string s1 = "Hello";
string s2 = s1;
s1 += " and goodbye.";
Console.WriteLine(s2); //outputs "Hello"

Carácter de escape
Los caracteres de escape como "\n" y (nueva línea) y "\t" (tabulador) se pueden incluir en cadenas. La línea:
string hello = "Hello\nWorld!";
equivale a:
Hello
World!

ToString()
Al igual que todos los objetos derivados de Object, las cadenas proporcionan el método ToString, que
convierte un valor en una cadena. Este método se puede utilizar para convertir valores numéricos en cadenas
de la siguiente manera:
int year = 1999;
string msg = "Eve was born in " + year.ToString();
System.Console.WriteLine(msg); // outputs "Eve was born in 1999"

Tener acceso a los caracteres individuales
Se obtiene acceso a los caracteres individuales contenidos en una cadena utilizando métodos como
SubString(),

Replace(),, Split() y Trim().
string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2)); // outputs "C#"
System.Console.WriteLine(s3.Replace("C#", "Basic")); // outputs "Visual Basic Express"

También es posible copiar los caracteres en una matriz de caracteres, tal como se muestra a continuación:
string s4 = "Hello, World";

1




char[] arr = s4.ToCharArray(0, s4.Length);
foreach (char c in arr)
{
System.Console.Write(c); // outputs "Hello, World"
}

Puede obtener acceso a los caracteres individuales de una cadena con un índice: string s5 = "Printing
backwards";
for (int i = 0; i < s5.Length; i++)
{
System.Console.Write(s5[s5.Length - i - 1]); // outputs "sdrawkcab gnitnirP"
}

Cambiar mayúsculas y minúsculas
Para cambiar las letras en una cadena a mayúsculas o minúsculas, se utiliza ToUpper() o ToLower(), de la
siguiente forma:
string s6 = "Battle of Hastings, 1066";
System.Console.WriteLine(s6.ToUpper()); // outputs "BATTLE OF HASTINGS 1066"
System.Console.WriteLine(s6.ToLower()); // outputs "battle of hastings 1066"

Comparaciones
La manera más simple de comparar dos cadenas es utilizar los operadores == y !=, que realizan una
comparación con distinción entre mayúsculas y minúsculas.
string color1 = "red";
string color2 = "green";
string color3 = "red";
if (color1 == color3)
{
System.Console.WriteLine("Equal");
}
if (color1 != color2)
{
System.Console.WriteLine("Not equal");
}

Los objetos String también tienen un método CompareTo() que devuelve un valor entero, basado en si una
cadena es menor que (<) o mayor que (>) otra. Al comparar las cadenas, se utiliza el valor Unicode, y las
minúsculas tienen un valor menor que las mayúsculas.
string s7 = "ABC";
string s8 = "abc";
if (s7.CompareTo(s8) > 0)
{
System.Console.WriteLine("Greater-than");
}
else
{
System.Console.WriteLine("Less-than");
}

Para buscar una cadena dentro de otra, utilice IndexOf(). IndexOf() devuelve -1 si la cadena de búsqueda no
se encuentra; en caso contrario devuelve el índice de la primera posición de la cadena, con base cero.
string s9 = "Battle of Hastings, 1066";
System.Console.WriteLine(s9.IndexOf("Hastings")); // outputs 10
System.Console.WriteLine(s9.IndexOf("1967")); // outputs -1

Dividir una cadena en subcadenas

2




Dividir una cadena en subcadenas (al igual que dividir una frase en palabras) es una tarea común de
programación. El método Split() toma una matriz de char de delimitadores (por ejemplo, un carácter de
espacio) y devuelve una matriz de subcadenas. Para obtener acceso a esta matriz con foreach:
char[] delimit = new char[] { ' ' };
string s10 = "The cat sat on the mat.";
foreach (string substr in s10.Split(delimit))
{
System.Console.WriteLine(substr);
}

Este código genera cada palabra en una línea separada de la siguiente forma:
The
cat
sat
on
the
mat.


Manejo de cadenas <string.h>

Recordando la presentación de arreglos hecha, en donde las cadenas están definidas como un arreglo de
caracteres o un apuntador a una porción de memoria conteniendo caracteres ASCII. Una cadena en C es una
secuencia de cero o más caracteres seguidas por un caracter NULL o \0:

Es importante preservar el caracter de terminación NULL, ya que con éste es como C define y maneja las
longitudes de las cadenas. Todas las funciones de la biblioteca estándar de C lo requieren para una
operación satisfactoria.
En general, aparte de algunas funciones restringidas en longitud (strncat(), strncmp() y strncpy()), al menos
que se creen cadenas a mano, no se deberán encontrar problemas. Se deberán usar las funciones para
manejo de cadenas y no tratar de manipular las cadenas en forma manual desmantelando y ensamblando
cadenas.

17.1 Funciones básicas para el manejo de cadenas

Todas las funciones para manejo de cadenas tienen su prototipo en:

#include <string.h>

Las funciones más comunes son descritas a continuación:

• char *strcpy(const char *dest, const char *orig) -- Copia la cadena de caracteres apuntada por orig

•

(incluyendo el carácter terminador '\0') al vector apuntado por dest. Las cadenas no deben solaparse,
y la de destino, debe ser suficientemente grande como para alojar la copia.
int strcmp(const char *s1, const char *s2) -- Compara las dos cadenas de caracteres s1 y s2. Devuelve
un entero menor, igual o mayor que cero si se encuentra que s1 es, respectivamente, menor que, igual
a, o mayor que s2.

int strlen(const char *s) -- Calcula la longitud de la cadena de caracteres.

• char *strerror(int errnum) -- Devuelve un mensaje de error que corresponde a un número de error.
•
• char *strncat(char *s1, const char *s2, size_t n) -- Agrega n caracteres de s2 a s1.
•
int strncmp(const char *s1, char *s2, size_t n) -- Compara los primeros n caracteres de dos cadenas.
• char *strncpy(const char *s1, const char *s2, size_t n) -- Copia los primeros n caracteres de s2 a s1.
• strcasecmp(const char *s1, const char *s2) -- versión que ignora si son mayúsculas o minúsculas de

strcmp().

• strncasecmp(const char *s1, const char *s2, size_t n) -- versión insensible a mayúsculas o minúsculas

de strncmp() que compara los primeros n caracteres de s1.

El uso de muchas funciones es directo, por ejemplo:

char *s1 = "Hola";
char *s2;
int longitud;

longitud = strlen("Hola");
(void) strcpy(s2,s1);

/* long = 4 */



3


Observar que tanto strcat() y strcopy() regresan una copia de su primer argumento, el cual es el arreglo
destino. Observar también que orden de los argumentos es arreglo destino seguido por arreglo fuente lo cual
a veces es una situación para hacerlo incorrectamente.
La función strcmp() compara lexicográficamente las dos cadenas y regresa:

• Menor que cero -- si s1 es léxicamente menor que s2;
• Cero -- si s1 y s2 son léxicamente iguales;
• Mayor que cero -- si s1 es léxicamente mayor que s2;

Las funciones de copiado strncat(), strncmp() y strncpy() son versiones más restringidas que sus
contrapartes más generales. Realizan una tarea similar, pero solamente para los primeros n caracteres.
Observar que el caracter de terminación NULL podría ser violado cuando se usa estas funciones, por
ejemplo:

char *s1 = "Hola";
char *s2 = 2;
int longitud = 2;

(void) strncpy(s2, s1, longitud); /* s2 = "Ho" */

donde s2 no tiene el terminador NULL.
17.1.1 Búsqueda en cadenas
La biblioteca también proporciona varias funciones de búsqueda en cadenas.

• char *strchr(const char *s, int c) -- Devuelve un puntero a la primera ocurrencia del carácter c en la

cadena de caracteres s.

• char *strrchr(const char *s, int c) -- Encuentra la última ocurrencia del caracter c en la cadena.
• char *strstr(const char *s1, const char *s2) -- Localiza la primera ocurrencia de la cadena s2 en la

cadena s1.

• char *strpbrk(const char *s1, const char *s2) -- Regresa un apuntador a la primera ocurrencia en la

cadena s1 de cualquier carácter de la cadena s2, o un apuntador nulo si no hay un caracter de s2 que
exista en s1.

• size_t strspn(const char *s1, const char *s2) -- Calcula la longitud del segmento inicial de s1 que

consta únicamente de caracteres en s2.

• size_t strcspn(const char *s1, const char *s2) -- Regresa el número de caracteres al principio de s1

que no coinciden con s2.

• char *strtok(char *s1, const char *s2) -- Divide la cadena apuntada a s1 en una secuencia de ``tokens'',

cada uno de ellos esta delimitado por uno o más caracteres de la cadena apuntada por s2.

Las funciones strchr() y strrchr() son las más simples de usar, por ejemplo:

char *s1 = "Ho