REPUBLICA BOLIVARIANA DE VENEZUELA

MINISTERIO DEL PODER POPULAR PARA LA EDUCACIÓN

INSTITUTO UNIVERSITARIO DE TECNOLOGIA INDUSTRIAL
“RODOLFO LOERO ARISMENDI”

CATEDRA DE LOGICA DE PROGRAMACION

Profesora: Alumno:

Arredondo, Esmirna Morales, Carlos

26.455.780

Ciudad Bolívar, Noviembre del 2016

 INDICE
Pag.
INTRODUCCION.......................................................................................................... 1
Cadena de caracteres.................................................................................................. 2
Operación con cadena de caracteres.......................................................................2
Representación.............................................................................................................. 3
Cadenas dinámicas y estáticas...................................................................................3
Ejemplos de operaciones comunes............................................................................4
Asignación................................................................................................................... 4
Concatenación............................................................................................................ 4
Número de caracteres de una cadena..................................................................4
Comparación............................................................................................................... 4
Multiplicar una cadena.............................................................................................5
Cadenas (Guía de programación de C#)...................................................................6
Declarar e inicializar cadenas................................................................................6
Inmutabilidad de los objetos de cadena..............................................................7
Literales de cadena regulares y textuales.........................................................8
Secuencias de escape de cadena...........................................................................9
Cadenas de formato................................................................................................ 10
Subcadenas................................................................................................................ 11
Tener acceso a los caracteres individuales.......................................................11
Cadenas nulas y cadenas vacías............................................................................12
Utilizar StringBuilder para crear cadenas de forma rápida.........................14
CONCLUSION............................................................................................................. 15

ii
 INTRODUCCION

Una cadena de caracteres (string) es un conjunto de caracteres (incluido el

blanco) que se almacenan en localidades contiguas de memoria. Se representa
como un vector de caracteres donde cada elemento del vector representa un
carácter de la cadena.
Al considerar las cadenas como un tipo de datos, hay que definir cuáles son las
operaciones que es posible hacer con ellas. En principio, podrían ser muchas y
llegar a ser muy sofisticadas entre las que tenemos, asignación, concatenación,
búsqueda, extracción y comparación.
Una cadena puede estar formada por combinaciones finitas de los caracteres
disponibles, entre las letras de la 'a' a la 'z' y de la 'A' a la 'Z', los números
del '0' al '9', el espacio en blanco ' ', símbolos diversos '!', '@', '%', etcétera.

2
Cadena de caracteres
En programación, una cadena de caracteres, palabras, ristra de caracteres o
frase (string, en inglés) es una secuencia ordenada (de longitud arbitraria,
aunque finita) de elementos que pertenecen a un cierto lenguaje formal o
alfabeto análogas a una fórmula o a una oración. En general, una cadena de
caracteres es una sucesión de caracteres (letras, números u otros signos o
símbolos). Si no se ponen restricciones al alfabeto, una cadena podrá estar
formada por cualquier combinación finita de los caracteres disponibles (las
letras de la 'a' a la 'z' y de la 'A' a la 'Z', los números del '0' al '9', el espacio
en blanco ' ', símbolos diversos '!', '@', '%', etcétera).
En este mismo ámbito, se utilizan habitualmente como un tipo de dato
predefinido, para palabras, frases o cualquier otra sucesión de caracteres. En
este caso, se almacenan en un vector de datos, o matriz de datos de una sola
fila (array, en inglés). Las cadenas se pueden almacenar de manera física:
 seguidas;
 enlazadas letras a letra.
Generalmente los caracteres se guardan uno a continuación de otro para fines
de eficiencia en el acceso.
Un caso especial de cadena es la que contiene cero caracteres. A esta cadena
se la llama cadena vacía; en teoría de autómatas, es común representarla por

medio de la letra griega .

Operación con cadena de caracteres

Al considerar las cadenas como un tipo de datos, hay que definir cuáles son las
operaciones que es posible hacer con ellas. En principio, podrían ser muchas y
llegar a ser muy sofisticadas. Las siguientes son algunas de ellas:
 Asignación: Consiste en asignar una cadena a otra.
 Concatenación: Consiste en unir dos cadenas o más (o una cadena con un
carácter) para formar una cadena de mayor tamaño.
 Búsqueda: Consiste en localizar dentro de una cadena una subcadena más
pequeña o un carácter.
 Extracción: Se trata de sacar fuera de una cadena una porción de la
misma según su posición dentro de ella.

2
  Comparación: Se utiliza para comparar dos cadenas.

Representación
Una cadena suele ser representada entre comillas dobles superiores
("palabra"), mientras que un carácter de esa cadena (un char en inglés) suele
ser representado entre comillas simples ('p'). Por ejemplo, en C:
charAt c = 'a';
char str[5] = "hola";
Generalmente para acceder a un carácter en una posición determinada se suele
usar la forma variable [posición] como cuando se accede a un vector.
Para poder mostrar una comilla (") dentro de la cadena y no tener problemas
con las comillas que la delimitan, se usan secuencias de escape. Esto se aplica a
otros caracteres reservados o no imprimibles como el retorno de carro. No
obstante, las expresiones para producir estas secuencias de escape dependen
del lenguaje de programación que se esté usando. Una forma común, en muchos
lenguajes, de escapar un carácter es anteponiéndole un «\» (sin comillas), p. e.:
«\"» (sin comillas).

Cadenas dinámicas y estáticas

Las cadenas pueden ser de naturaleza dinámica (pueden alterar su longitud
durante el tiempo de ejecución) o de naturaleza estática (su longitud es fija a
lo largo del tiempo de ejecución). En este segundo caso, el programador debe
prever que al recorrer la cadena los índices no se vayan de los límites previstos
(C no permite que las cadenas crezcan automáticamente de forma explícita,
mientras que C# sí).
El final de la cadena se delimita de diferente manera en uno u otro caso:
 mediante un carácter de fin de cadena ("\0" en C) para las cadenas de
tipo dinámico;
 mediante una propiedad de la cadena que delimite su longitud (Length en
C#) para las de tipo estático.

2
Ejemplos de operaciones comunes
Asignación
Asignar una cadena a otra.
char *strcpy(char [], const char[]); # en C
cadena1=cadena2; # en C++
cadena1 := cadena2 # en Smalltalk

Concatenación
Unir dos cadenas de caracteres.
pareja = "Joshua" + " y " + "Marina" # en Python
$pareja = "Joshua"." y "."Marina" # en Perl y PHP
pareja = "Luisa" & " y " & "Carmen" # en Visual Basic
pareja = "Luisa" + " y " + "Carmen"; # en C++ y Java con la clase String
pareja := 'Luisa' , ' y ' , 'Carmen'. # en Smalltalk
strcat(cadena1,cadena2); strcat(cadena1, cadena3); # en C (Debe haber
suficiente espacio en la primera.)

Número de caracteres de una cadena

int strlen(const char[]); # en C Devuelve el nº de caracteres sin contar el '\0'
cadena.length(); # en C++
cadena size. # en Smalltalk
len(cadena) # en Python

Comparación
Comparar dos cadenas en orden lexicográfico.
int strcmp(const char[], const char[]); # en C Devuelve <0 si la 1ª es menor, > 0
si es mayor y 0 si son iguales.

2
cadena1 == cadena2; cadena1>cadena2; etc. # en C++ Devuelve un valor de
verdad.
cadena1 = cadena2 # en Smalltalk Devuelve true o false.
Multiplicar una cadena
Repetir varias veces una cadena.
$puntos ="." x 5 # pone 5 puntos en Perl.
puntos := Generator generateJoin: '.' repeat: 5. # Genera una cadena de 5
puntos en Smalltalk.
puntos = "." * 5 # Genera una cadena de 5 puntos en Python.

2
Cadenas (Guía de programación de C#)

Declarar e inicializar cadenas

Puede declarar e inicializar cadenas de varias maneras, como se muestra en el
ejemplo siguiente:
C#
// Declare without initializing.
string message1;

// Initialize to null.
string message2 = null;

// Initialize as an empty string.

// Use the Empty constant instead of the literal "".
string message3 = System.String.Empty;

//Initialize with a regular string literal.

string oldPath = "c:\\Program Files\\Microsoft Visual Studio 8.0";

// Initialize with a verbatim string literal.

string newPath = @"c:\Program Files\Microsoft Visual Studio 9.0";

// Use System.String if you prefer.

System.String greeting = "Hello World!";

// In local variables (i.e. within a method body)

// you can use implicit typing.
var temp = "I'm still a strongly-typed System.String!";

// Use a const string to prevent 'message4' from

// being used to store another string value.
const string message4 = "You can't get rid of me!";

// Use the String constructor only when creating

// a string from a char*, char[], or sbyte*. See
// System.String documentation for details.
char[] letters = { 'A', 'B', 'C' };
string alphabet = new string(letters);

2
Tenga en cuenta que el operador new no se utiliza para crear un objeto de
cadena, salvo cuando se inicialice la cadena con una matriz de caracteres.
Inicialice una cadena con el valor constante Empty para crear un nuevo objeto
String cuya cadena tiene una longitud cero. La representación literal de cadena
de una cadena de longitud cero es "". Mediante la inicialización de cadenas con
el valor Empty en lugar de null, puede reducir las posibilidades de que se
produzca una excepción NullReferenceException. Utilice el método estático
IsNullOrEmpty(String) para comprobar el valor de una cadena antes de
intentar tener acceso a ésta.

Inmutabilidad de los objetos de cadena

Los objetos de cadena son inmutables, es decir, no pueden modificarse una vez
creados. Todos los métodos String y los operadores de C# que parecen
modificar una cadena, en realidad devuelven los resultados en un nuevo objeto
de cadena. En el ejemplo siguiente, cuando el contenido de s1 y s2 se concatena
para formar una sola cadena, las dos cadenas originales no se modifican. El
operador += crea una nueva cadena que contiene el contenido combinado. Ese
nuevo objeto se asigna a la variable s1 y el objeto original asignado a s1 se
libera para la recolección de elementos no utilizados, ya que ninguna otra
variable contiene una referencia a él.
C#
string s1 = "A string is more ";
string s2 = "than the sum of its chars.";

// Concatenate s1 and s2. This actually creates a new

// string object and stores it in s1, releasing the
// reference to the original object.
s1 += s2;

System.Console.WriteLine(s1);
// Output: A string is more than the sum of its chars.
Dado que "modificar" una cadena consiste en realidad en crear una cadena
nueva, debe actuar con precaución al crear referencias a las cadenas. Si crea
una referencia a una cadena y después "modifica" la cadena original, la
referencia seguirá señalando al objeto original en lugar de al nuevo objeto que
se creó cuando se modificó la cadena. En el siguiente código se muestra este
comportamiento:

2
C#
string s1 = "Hello ";
string s2 = s1;
s1 += "World";

System.Console.WriteLine(s2);
//Output: Hello

Literales de cadena regulares y textuales

Utilice literales de cadenas regulares cuando tenga que incrustar caracteres
de escape proporcionados por C#, como se muestra en el ejemplo siguiente:
C#
string columns = "Column 1\tColumn 2\tColumn 3";
//Output: Column 1 Column 2 Column 3
string rows = "Row 1\r\nRow 2\r\nRow 3";
/* Output:
Row 1
Row 2
Row 3
*/
string title = "\"The \u00C6olean Harp\", by Samuel Taylor Coleridge";
//Output: "The Æolean Harp", by Samuel Taylor Coleridge

Utilice cadenas textuales para mayor comodidad y una mejor legibilidad cuando
el texto de la cadena contiene caracteres de barra diagonal inversa, por
ejemplo en rutas de acceso de archivo. Dado que las cadenas textuales
conservan los caracteres de nueva línea como parte del texto de la cadena,
pueden utilizarse para inicializar cadenas de múltiples líneas. Utilice las
comillas dobles para incrustar comillas en una cadena textual. En el ejemplo
siguiente se muestran algunos usos habituales de las cadenas textuales:

2
C#
string filePath = @"C:\Users\scoleridge\Documents\";
//Output: C:\Users\scoleridge\Documents\
string text = @"My pensive SARA ! thy soft cheek reclined
Thus on mine arm, most soothing sweet it is
To sit beside our Cot,...";
/* Output:
My pensive SARA ! thy soft cheek reclined
Thus on mine arm, most soothing sweet it is
To sit beside our Cot,...
*/
string quote = @"Her name was ""Sara.""";
//Output: Her name was "Sara."

Secuencias de escape de cadena

Secuencia Codificación
Nombre del carácter
de escape Unicode
\' Comilla simple 0x0027
\" Comilla doble 0x0022
\\ Barra diagonal inversa 0x005C
\0 Null 0x0000
\a Alerta 0x0007
\b Retroceso 0x0008
\f Avance de página 0x000C
\n Nueva línea 0x000A
\r Retorno de carro 0x000D
\t Tabulación horizontal 0x0009
Secuencia de escape Unicode para pares
\U \Unnnnnnnn
suplentes.
\u Secuencia de escape Unicode \u0041 = "A"
\v Tabulación vertical 0x000B
Secuencia de escape Unicode similar a "\u" a
\x \x0041 = "A"
excepción de la longitud variable.

Cadenas de formato

2
Una cadena de formato es una cadena cuyo contenido puede determinarse
dinámicamente en tiempo de ejecución. Para crear una cadena de formato se
utiliza el método estático Format y se incrustan marcadores de posición entre
llaves que se reemplazarán por otros valores en tiempo de ejecución. En el
ejemplo siguiente se utiliza una cadena de formato para generar el resultado
de cada iteración de un bucle:
C#
class FormatString
{
static void Main()
{
// Get user input.
System.Console.WriteLine("Enter a number");
string input = System.Console.ReadLine();

// Convert the input string to an int.

int j;
System.Int32.TryParse(input, out j);

// Write a different string each iteration.

string s;
for (int i = 0; i < 10; i++)
{
// A simple format string with no alignment formatting.
s = System.String.Format("{0} times {1} = {2}", i, j, (i * j));
System.Console.WriteLine(s);
}
//Keep the console window open in debug mode.
System.Console.ReadKey();
}
}

Subcadenas

2
Una subcadena es cualquier secuencia de caracteres incluida en una cadena.
Utilice el método Substring para crear una nueva cadena a partir de un
segmento de la cadena original. Puede buscar una o más apariciones de una
subcadena con el método IndexOf. Utilice el método Replace para reemplazar
todas las apariciones de una subcadena especificada por una cadena nueva. Al
igual que el método Substring, Replace devuelve en realidad una cadena nueva y
no modifica la cadena original.
C#
string s3 = "Visual C# Express";
System.Console.WriteLine(s3.Substring(7, 2));
// Output: "C#"

System.Console.WriteLine(s3.Replace("C#", "Basic"));
// Output: "Visual Basic Express"

// Index values are zero-based

int index = s3.IndexOf("C");
// index = 7

Tener acceso a los caracteres individuales

Puede utilizar la notación de matrices con un valor de índice para obtener
acceso de sólo lectura a caracteres individuales, como en el ejemplo siguiente:
C#
string s5 = "Printing backwards";

for (int i = 0; i < s5.Length; i++)

{
System.Console.Write(s5[s5.Length - i - 1]);
}
// Output: "sdrawkcab gnitnirP"

Si los métodos String no proporcionan la funcionalidad necesaria para

modificar caracteres individuales en una cadena, puede utilizar un objeto

2
StringBuilder para modificar los caracteres individuales "en contexto" y crear
a continuación una nueva cadena para almacenar los resultados mediante los
métodos StringBuilder. En el ejemplo siguiente, suponga que debe modificar la
cadena original de una forma determinada y almacenar a continuación los
resultados para su uso futuro:
C#
string question = "hOW DOES mICROSOFT wORD DEAL WITH THE cAPS
lOCK KEY?";
System.Text.StringBuilder sb = new System.Text.StringBuilder(question);

for (int j = 0; j < sb.Length; j++)

{
if (System.Char.IsLower(sb[j]) == true)
sb[j] = System.Char.ToUpper(sb[j]);
else if (System.Char.IsUpper(sb[j]) == true)
sb[j] = System.Char.ToLower(sb[j]);
}
// Store the new string.
string corrected = sb.ToString();
System.Console.WriteLine(corrected);
// Output: How does Microsoft Word deal with the Caps Lock key?

Cadenas nulas y cadenas vacías

Una cadena vacía es una instancia de un objeto System.String que contiene
cero caracteres. Las cadenas vacías se utilizan habitualmente en distintos
escenarios de programación para representar un campo de texto en blanco.
Puede realizar llamadas a métodos en cadenas vacías porque son objetos
System.String válidos. Las cadenas vacías se inicializan tal y como se indica a
continuación:
string s = String.Empty;
Por el contrario, una cadena nula no hace referencia a una instancia de un
objeto System.String y cualquier intento de llamar a un método en una cadena
nula provoca una excepción NullReferenceException. Sin embargo, puede
utilizar cadenas nulas en operaciones de concatenación y comparación con otras
cadenas. Los ejemplos siguientes muestran algunos casos en los que se hace
referencia a una cadena nula y no se produce una excepción:
C#

2
static void Main()
{
string str = "hello";
string nullStr = null;
string emptyStr = String.Empty;

string tempStr = str + nullStr;

// Output of the following line: hello
Console.WriteLine(tempStr);

bool b = (emptyStr == nullStr);

// Output of the following line: False
Console.WriteLine(b);

// The following line creates a new empty string.

string newStr = emptyStr + nullStr;

// Null strings and empty strings behave differently. The following

// two lines display 0.
Console.WriteLine(emptyStr.Length);
Console.WriteLine(newStr.Length);
// The following line raises a NullReferenceException.
//Console.WriteLine(nullStr.Length);

// The null character can be displayed and counted, like other chars.
string s1 = "\x0" + "abc";
string s2 = "abc" + "\x0";
// Output of the following line: * abc*
Console.WriteLine("*" + s1 + "*");
// Output of the following line: *abc *
Console.WriteLine("*" + s2 + "*");
// Output of the following line: 4
Console.WriteLine(s2.Length);
}

Utilizar StringBuilder para crear cadenas de forma rápida

Las operaciones de cadena en .NET están muy optimizadas y, en la mayoría de
los casos, no tienen un impacto significativo en el rendimiento. Sin embargo, en

2
algunos escenarios, como en bucles de pequeñas dimensiones que se ejecutan
cientos o miles de veces, las operaciones de cadena pueden afectar al
rendimiento. La clase StringBuilder crea un búfer de cadena que proporciona
un mayor rendimiento si el programa realiza muchas manipulaciones de cadenas.
La cadena StringBuilder también permite reasignar los caracteres individuales,
algo que el tipo de datos String integrado no admite. Por ejemplo, este código
cambia el contenido de una cadena sin crear una nueva cadena:
C#
System.Text.StringBuilder sb = new System.Text.StringBuilder("Rat: the ideal
pet");
sb[0] = 'C';
System.Console.WriteLine(sb.ToString());
System.Console.ReadLine();
//Outputs Cat: the ideal pet
En este ejemplo, se utiliza un objeto StringBuilder para crear una cadena a
partir de un conjunto de tipos numéricos:
C#
class TestStringBuilder
{
static void Main()
{
System.Text.StringBuilder sb = new System.Text.StringBuilder();
// Create a string composed of numbers 0 - 9
for (int i = 0; i < 10; i++)
{
sb.Append(i.ToString());
}
System.Console.WriteLine(sb); // displays 0123456789
// Copy one character of the string (not possible with a System.String)
sb[0] = sb[9];
System.Console.WriteLine(sb); // displays 9123456789
}
}

CONCLUSION

2
Las operaciones de cadena en .NET están muy optimizadas y, en la mayoría de
los casos, no tienen un impacto significativo en el rendimiento.
Una cadena vacía es una instancia de un objeto System.String que contiene
cero caracteres.
Las cadenas vacías se utilizan habitualmente en distintos escenarios de
programación para representar un campo de texto en blanco.
Puede utilizar la notación de matrices con un valor de índice para obtener
acceso de sólo lectura a caracteres individuales.
Una subcadena es cualquier secuencia de caracteres incluida en una cadena.
Utilice el método Substring para crear una nueva cadena a partir de un
segmento de la cadena original.
Una cadena de formato es una cadena cuyo contenido puede determinarse
dinámicamente en tiempo de ejecución.
Los objetos de cadena son inmutables, es decir, no pueden modificarse una vez
creados.