Apéndice C: Bibliotecas estándar

Todos los compiladores C y C++ disponen de ciertas bibliotecas de funciones estándar que facilitan el acceso a la pantalla, al teclado, a los discos, la manipulación de cadenas, y muchas otras cosas, de uso corriente.

Hay que decir que todas estas funciones no son imprescindibles, y de hecho no forman parte del C. Pueden estar escritas en C, de hecho en su mayor parte lo están, y muchos compiladores incluyen el código fuente de estas bibliotecas. Nos hacen la vida más fácil, y no tendría sentido pasarlas por alto.

Existen muchas de estas bibliotecas, algunas tienen sus características definidas según diferentes estándar, como ANSI C o C++, otras son específicas del compilador, otras del sistema operativo, también las hay para plataformas Windows. En el presente curso nos limitaremos a las bibliotecas ANSI C y C++.

Veremos ahora algunas de las funciones más útiles de algunas de estas bibliotecas, las más imprescindibles.

Biblioteca de entrada y salida fluidas "iostream"

En el contexto de C++ todo lo referente a "streams" puede visualizarse mejor si usamos un símil como un río o canal de agua.

Imagina un canal por el que circula agua, si echamos al canal objetos que floten, estos se moverán hasta el final de canal, siguiendo el flujo del agua. Esta es la idea que se quiere transmitir cuando se llama "stream" a algo en C++. Por ejemplo, en C++ el canal de salida es cout, los objetos flotantes serán los argumentos que queremos extraer del ordenador o del programa, la salida del canal es la pantalla. Sintaxis:

cout << <variable/constante> [<< <variable/constante>...];

Completando el símil, en la orden:

cout << "hola" << " " << endl;

Los operadores "<<" representarían el agua, y la dirección en que se mueve. Cualquier cosa que soltemos en el agua: "hola", " " o endl, seguirá flotando hasta llegar a la pantalla, y además mantendrán su orden.

En esta biblioteca se definen algunas de las funciones aplicables a los "streams", pero aún no estamos en disposición de acceder a ellas. Baste decir de momento que existen cuatro "streams" predeterminados:

  • cin, canal de entrada estándar.
  • cout, canal de salida estándar.
  • cerr, canal de salida de errores.
  • clog, canal de salida de diario o anotaciones.

Sobre el uso de cin, que es el único canal de entrada predefinido, tenemos que aclarar cómo se usa, aunque a lo mejor ya lo has adivinado.

cin >> <variable> [>> <variable>...];

Donde cada variable irá tomando el valor introducido mediante el teclado. Los espacios y los retornos de línea actúan como separadores.

Ejemplo:

Escribir un programa que lea el nombre, la edad y el número de teléfono de un usuario y los muestre en pantalla.

#include <iostream>
using namespace std;

int main() {
  char Nombre[30];  // Usaremos una cadena para almacenar
                    // el nombre (29 caracteres)
  int Edad;         // Un entero para la edad
  char Telefono[8]; // Y otra cadena para el número de
                    // teléfono (7 dígitos)

  // Mensaje para el usuario
  cout << "Introduce tu nombre, edad y número de teléfono" << endl;
  // Lectura de las variables
  cin >> Nombre >> Edad >> Telefono;
  // Visualización de los datos leídos
  cout << "Nombre:" << Nombre << endl;
  cout << "Edad:" << Edad << endl;
  cout << "Teléfono:" << Telefono << endl;

  return 0;
}

Biblioteca C de entrada y salida estándar "stdio.h"

En esta biblioteca están las funciones de entrada y salida, tanto de la pantalla y teclado como de ficheros. "stdio" puede y suele leerse como estándar Input/Output. De hecho la pantalla y el teclado son considerados como ficheros, aunque de un tipo algo peculiar. La pantalla es un fichero sólo de escritura llamado stdout, o salida estándar y el teclado sólo de lectura llamado stdin, o entrada estándar.

Se trata de una biblioteca ANSI C, por lo que está heredada de C, y ha perdido la mayor parte de su utilidad al ser desplazada por "iostream". Pero aún puede ser muy útil, es usada por muchos programadores, y la encontrarás en la mayor parte de los programas C y C++.

Veamos ahora algunas funciones.

Función getchar()

Sintaxis:

int getchar(void); 

Lee un carácter desde stdin.

getchar es una macro que devuelve el siguiente carácter del canal de entrada stdin. Esta macro está definida como getc(stdin)".

Valor de retorno:

Si todo va bien, getchar devuelve el carácter leído, después de convertirlo a un int sin signo. Si lee un Fin-de-fichero o hay un error, devuelve EOF.

Ejemplo:

do {
   a = getchar();
} while (a != 'q');

En este ejemplo, el programa permanecerá leyendo el teclado mientras no pulsemos la tecla 'q'.

Función putchar()

Sintaxis:

int putchar(int c);

Envía un carácter a la salida stdout.

putchar(c) es una macro definida como putc(c, stdout).

Valor de retorno:

Si tiene éxito, putchar devuelve el carácter c. Si hay un error, putchar devuelve EOF.

Ejemplo:

while(a = getchar()) putchar(a);

En este ejemplo, el programa permanecerá leyendo el teclado y escribirá cada tecla que pulsemos, mientras no pulsemos '^C', (CONTROL+C). Observa que la condición en el while no es a == getchar(), sino una asignación. Aquí se aplican, como siempre, las normas en el orden de evaluación en expresiones, primero se llama a la función getchar(), el resultado se asigna a la variable "a", y finalmente se comprueba si el valor de "a" es o no distinto de cero. Si "a" es cero, el bucle termina, si no es así continúa.

Función gets()

Sintaxis:

char *gets(char *s);

Lee una cadena desde stdin.

gets lee una cadena de caracteres terminada con un retorno de línea desde la entrada estándar y la almacena en s. El carácter de retorno de línea es reemplazado con el carácter nulo en s.

Observa que la manera en que hacemos referencia a una cadena dentro de la función es char *, el operador * indica que debemos pasar como argumento la dirección de memoria donde estará almacenada la cadena a leer. Veremos la explicación en el capítulo de punteros, baste decir que a nivel del compilador char *cad y char cad[], son equivalentes, o casi.

gets permite la entrada de caracteres que indican huecos, como los espacios y los tabuladores. gets deja de leer después de haber leído un carácter de retorno de línea; todo aquello leído será copiado en s, incluido en carácter de retorno de línea.

Esta función no comprueba la longitud de la cadena leída. Si la cadena de entrada no es lo suficientemente larga, los datos pueden ser sobrescritos o corrompidos. Más adelante veremos que la función fgets proporciona mayor control sobre las cadenas de entrada.

Valor de retorno:

Si tiene éxito, gets devuelve la cadena s, si se encuentra el fin_de_fichero o se produce un error, devuelve NULL. Ejemplo:

char cad[80];
do {
   gets(cad);
} while (cad[0] != '\000');

En este ejemplo, el programa permanecerá leyendo cadenas desde el teclado mientras no introduzcamos una cadena vacía. Para comprobar que una cadena está vacía basta con verificar que el primer carácter de la cadena es un carácter nulo.

Función puts()

Sintaxis:

int puts(const char *s);

Envía una cadena a stdout.

puts envía la cadena s terminada con nulo a la salida estándar stdout y le añade el carácter de retorno de línea.

Valor de retorno:

Si tiene éxito, puts devuelve un valor mayor o igual a cero. En caso contrario devolverá el valor EOF.

Ejemplo:

char cad[80];
int i;
do {
   gets(cad);
   for(i = 0; cad[i]; i++)
      if(cad[i] == ' ') cad[i] = '_';
   puts(cad);
} while (cad[0] != '\000');

Empezamos a llegar a ejemplos más elaborados. Este ejemplo leerá cadenas en "cad", mientras no introduzcamos una cadena vacía. Cada cadena será recorrida carácter a carácter y los espacios de sustituirán por caracteres '_'. Finalmente se visualizará la cadena resultante.

Llamo tu atención ahora sobre la condición en el bucle for, comparándola con la del bucle do while. Efectivamente son equivalentes, al menos para i == 0, la condición del bucle do while podría haberse escrito simplemente como while (cad[0]). De hecho, a partir de ahora intentaremos usar expresiones más simples.

Función printf()

Sintaxis:

int fprintf(const char *formato[, argumento, ...]);

Escribe una cadena con formato a la salida estándar stdout.

Esta es probablemente una de las funciones más complejas de C. No es necesario que la estudies en profundidad, limítate a leer este capítulo, y considéralo como una fuente para la consulta. Descubrirás que poco a poco la conoces y dominas.

Esta función acepta listas de parámetros con un número indefinido de elementos. Entendamos que el número está indefinido en la declaración de la función, pero no en su uso, el número de argumentos dependerá de la cadena de formato, y conociendo ésta, podrá precisarse el número y tipo de los argumentos. Si no se respeta esta regla, el resultado es impredecible, y normalmente desastroso, sobre todo cuando faltan argumentos. En general, los sobrantes serán simplemente ignorados.

Cada argumento se aplicará a la cadena de formato y la cadena resultante se enviará a la pantalla.

Valor de retorno:

Si todo va bien el valor de retorno será el número de bytes de la cadena de salida. Si hay error se retornará con EOF.

Veremos ahora las cadenas de formato. Estas cadenas controlan cómo se tratará cada uno de los argumentos, realizando la conversión adecuada, dependiendo de su tipo. Cada cadena de formato tiene dos tipos de objetos:

  • Caracteres simples, que serán copiados literalmente a la salida.
  • Descriptores de conversión que tomarán los argumentos de la lista y les aplicarán el formato adecuado.

A su vez, los descriptores de formato tienen la siguiente estructura:

%[opciones][anchura][.precisión] [F|N|h|l|L] carácter_de_tipo 

Cada descriptor de formato empieza siempre con el carácter '%', después de él siguen algunos componentes opcionales y finalmente un carácter que indica el tipo de conversión a realizar.

Componente Opcional/Obligatorio Tipo de control
[opciones] Opcional Tipo de justificación, signos de números, puntos decimales, ceros iniciales, prefijos octales y hexadecimales.
[anchura] Opcional Anchura, mínimo número de caracteres a imprimir, se completa con espacios o ceros.
[precisión] Opcional Precisión, máximo número de caracteres. Para enteros, mínimo número de caracteres a imprimir.
[F|N|h|l|L] Opcional

Modificador de tamaño de la entrada. Ignora el tamaño por defecto para los parámetros de entrada.

F = punteros lejanos (far pointer)
N = punteros cercanos (near pointer)
h = short int
l = long
L = long double
Carácter_de_tipo Obligatorio Carácter de conversión de tipos.

Opciones

Pueden aparecer en cualquier orden y combinación:

Opción Significado
- Justifica el resultado a la izquierda, rellena a la derecha con espacios, si no se da se asume justificación a la derecha, se rellena con ceros o espacios a la izquierda.
+ El número se mostrará siempre con signo (+) o (-), según corresponda.
Espacio Igual que el anterior, salvo que cuando el signo sea positivo se mostrará un espacio.
# Especifica que el número se convertirá usando un formato alternativo

La opción (#) tiene diferentes efectos según el carácter de tipo especificado en el descriptor de formato, si es:

Carácter de tipo Efecto
c s d i u No tiene ningún efecto.
x X Se añadirá 0x (o 0X) al principio del argumento.
e E f g G En el resultado siempre mostrará el punto decimal, aunque ningún dígito le siga. Normalmente, el punto decimal sólo se muestra si le sigue algún dígito.

Anchura:

Define el número mínimo de caracteres que se usarán para mostrar el valor de salida.

Puede ser especificado directamente mediante un número decimal, o indirectamente mediante un asterisco (*). Si se usa un asterisco como descriptor de anchura, el siguiente argumento de la lista, que debe ser un entero, que especificará la anchura mínima de la salida. Aunque no se especifique o sea más pequeño de lo necesario, el resultado nunca se truncará, sino que se expandirá lo necesario para contener el valor de salida.

Descriptor Efecto
n Al menos n caracteres serán impresos, si la salida requiere menos de n caracteres se rellenará con blancos.
0n Lo mismo, pero se rellenará a la izquierda con ceros.
* El número se tomará de la lista de argumentos

Precisión:

Especifica el número máximo de caracteres o el mínimo de dígitos enteros a imprimir.

La especificación de precisión siempre empieza con un punto (.) para separarlo del descriptor de anchura.

Al igual que el descriptor de anchura, el de precisión admite la especificación directa, con un número; o indirecta, con un asterisco (*).

Si usas un asterisco como descriptor de anchura, el siguiente argumento de la lista, que debe ser un entero, especificará la anchura mínima de la salida. Si usas el asterisco para el descriptor de precisión, el de anchura, o para ambos, el orden será, descriptor de anchura, de precisión y el dato a convertir.

Descriptor Efecto
(nada) Precisión por defecto
.0 ó .

Para los tipos d, i, o, u, x, precisión por defecto.

Para e, E, f, no se imprimirá el punto decimal, ni ningún decimal.

.n Se imprimirán n caracteres o n decimales. Si el valor tiene más de n caracteres se truncará o se redondeará, según el caso.
.* El descriptor de precisión se tomará de la lista de argumentos.

Valores de precisión por defecto:

1 para los tipos: d,i,o,u,x,X

6 para los tipos: e,E,f

Todos los dígitos significativos para los tipos; g, G

Hasta el primer nulo para el tipo s

Sin efecto en el tipo c

Si se dan las siguientes condiciones no se imprimirán caracteres para este campo:

  • Se especifica explícitamente una precisión de 0.
  • El campo es un entero (d, i, o, u, óx),
  • El valor a imprimir es cero.

Cómo afecta [.precisión] a la conversión:

Carácter de tipo Efecto de (.n)
d i o u x X Al menos n dígitos serán impresos. Si el argumento de entrada tiene menos de n dígitos se rellenará a la izquierda, para x/X con ceros. Si el argumento de entrada tiene menos de n dígitos el valor no será truncado.
e E f Al menos n caracteres se imprimirán después del punto decimal, el último de ellos será redondeado.
g G Como máximo, n dígitos significativos serán impresos.
c Ningún efecto.
s No más de n caracteres serán impresos.

Modificador de tamaño [F|N|h|l|L]:

Indican cómo printf debe interpretar el siguiente argumento de entrada.

Modificador Tipo de argumento Interpretación
F Puntero p s n Un puntero far
N Puntero p s n Un puntero near
h d i o u x X short int
L d i o u x X long int
l e E f g G double
L e E f g G long double

Caracteres de conversión de tipo

La información de la siguiente tabla asume que no se han especificado opciones, ni descriptores de ancho ni precisión, ni modificadores de tamaño.

Carácter de tipo Entrada esperada Formato de salida
Números    
d Entero con signo Entero decimal
i Entero con signo Entero decimal
o Entero con signo Entero octal
u Entero sin signo Entero decimal
x Entero sin signo Entero hexadecimal (con a, b, c, d, e, f)
X Entero sin signo Entero hexadecimal (con A, B, C, D, E, F)
f Coma flotante Valor con signo: [-]dddd.dddd
e Coma flotante Valor con signo: [-]d.dddd...e[+/-]ddd
g Coma flotante Valor con signo, dependiendo del valor de la precisión. Se rellenará con ceros y se añadirá el punto decimal si es necesario.
E Coma flotante Valor con signo: [-]d.dddd...E[+/-]ddd
G Coma flotante Como en g, pero se usa E para los exponentes.
Caracteres    
c Carácter Un carácter.
s Puntero a cadena Caracteres hasta que se encuentre un nulo o se alcance la precisión especificada.
Especial    
% Nada El carácter '%'
Punteros    
n Puntero a int Almacena la cuenta de los caracteres escritos.
p Puntero Imprime el argumento de entrada en formato de puntero: XXXX:YYYY ó YYYY

Veamos algunos ejemplos que nos aclaren este galimatías, en los comentarios a la derecha de cada fprintf se muestra la salida prevista:

#include <cstdio>
using namespace std;

int main() {
   int i = 123;
   int j = -124;
   float x = 123.456;
   float y = -321.12;
   char Saludo[5] = "hola";

   printf("|%6d|\n", i); // | 123|
   printf("|%-6d|\n", i); // |123 |
   printf("|%06d|\n", i); // |000123|
   printf("|%+6d|\n", i); // | +123|
   printf("|%+6d|\n", j); // | -124|
   printf("|%+06d|\n", i); // |+00123|
   printf("|% 06d|\n", i); // | 00123|
   printf("|%6o|\n", i); // | 173|
   printf("|%#6o|\n", i); // | 0173|
   printf("|%06o|\n", i); // |000173|
   printf("|%-#6o|\n", i); // |0173 |
   printf("|%6x|\n", i); // | 7b|
   printf("|%#6X|\n", i); // | 0X7B|
   printf("|%#06X|\n", i); // |0X007B|
   printf("|%-#6x|\n", i); // |0x7b |
   printf("|%10.2f|\n", x); // | 123.46|
   printf("|%10.4f|\n", x); // |  123.4560|
   printf("|%010.2f|\n", x); // |0000123.46|
   printf("|%-10.2f|\n", x); // |123.46 |
   printf("|%10.2e|\n", x); // | 1.23e+02|
   printf("|%-+10.2e|\n", y);// |-3.21e+02 |
   printf("|%*.*f|\n", 14, 4, x); // | 123.4560|
   printf("%.2f  es el 10%% de %.2f\n", .10*x, x); // 12.35 es el 10% de 123.46
   printf("%s es un saludo y %c una letra\n", Saludo, Saludo[2]); // hola es un saludo y l una letra
   printf("%.2s es parte de un saludo\n", Saludo); // ho es parte de un saludo
}

Observa el funcionamiento de este ejemplo, modifícalo y experimenta. Intenta predecir los resultados.

Biblioteca de rutinas de conversión estándar stdlib.h

En esta biblioteca se incluyen rutinas de conversión entre tipos. Nos permiten convertir cadenas de caracteres a números, números a cadenas de caracteres, números con decimales a números enteros, etc.

Función atoi()

Convierte una cadena de caracteres a un entero. Puede leerse como conversión de "ASCII to Integer".

Sintaxis:

int atoi(const char *s);

La cadena puede tener los siguientes elementos:

  • Opcionalmente un conjunto de tabuladores o espacios.
  • Opcionalmente un carácter de signo.
  • Una cadena de dígitos.

El formato de la cadena de entrada sería: [ws] [sn] [ddd]

El primer carácter no reconocido finaliza el proceso de conversión, no se comprueba el desbordamiento, es decir si el número cabe en un int. Si no cabe, el resultado queda indefinido.

Valor de retorno:

atoi devuelve el valor convertido de la cadena de entrada. Si la cadena no puede ser convertida a un número int, atoi vuelve con 0.

Al mismo grupo pertenecen las funciones atol y atof, que devuelven valores long int y float. Se verán en detalle en otros capítulos.

Función system()

Ejecuta un comando del sistema o un programa externo almacenado en disco. Esta función nos será muy útil para detener el programa antes de que termine.

Si compilas los ejemplos, ejercicios o tus propios programas usando un compilador de Windows para consola, como Dev-C++, habrás notado que la consola se cierra cuando el programa termina, antes de que puedas ver los resultados del programa, para evitar eso podemos añadir una llamada a la función system para ejecutar el comando del sistema "pause", que detiene la ejecución hasta que se pulse una tecla. Por ejemplo:

#include <stdlib.h>
#include <iostream>
using namespace std;

int main()
{
   cout << "Hola, mundo." << endl;
   system("pause");
   return 0;
}

De este modo el programa se detiene antes de devolver el control y de que se cierre la consola.

Nota: en este capítulo se menciona el concepto macro.
Una macro es una fórmula definida para el preprocesador. Es un concepto que se estudia en los capítulos 13 y 23. Consiste, básicamente, en una fórmula que se sustituye por su valor antes de compilar un programa, de eso se encarga el preprocesador.
La diferencia principal es que las funciones se invocan, y la ejecución del programa continúa en la dirección de memoria de la función, cuando ésta termina, retorna y la ejecución continúa en el programa que invocó a la función. Con las macros no es así, el código de la macro se inserta por el preprocesador cada vez que es invocada y se compila junto con el resto del programa, eso elimina los saltos, y aumenta el código.
De todos modos, no te preocupes demasiado por estos conceptos, el curso está diseñado para tener una progresión más o menos lineal y estos temas se tratan con detalle más adelante.

Función abs()

Devuelve el valor absoluto de un entero.

Sintaxis:

int abs(int x);

abs devuelve el valor absoluto del valor entero de entrada, x. Si se llama a abs cuando se ha incluido la biblioteca "stdlib.h", se la trata como una macro que se expandirá. Si se quiere usar la función abs en lugar de su macro, hay que incluir la línea:

#undef abs

en el programa, después de la línea:

#include 

Esta función puede usarse con "bcd" y con "complejos".

Valor de retorno:

Esta función devuelve un valor entre 0 y el INT_MAX, salvo que el valor de entrada sea INT_MIN, en cuyo caso devolverá INT_MAX. Los valores de INT_MAX e INT_MIN están definidos en el fichero de cabecera "limit.h".

Función rand()

Generador de números aleatorios.

Sintaxis:

int rand(void); 

La función rand devuelve un número aleatorio entre 0 y RAND_MAX. La constante RAND_MAX está definida en stdlib.h.

Valor de retorno:

rand devuelve un número entre 0 y RAND_MAX.

Función srand()

Inicializa el generador de números aleatorios.

Sintaxis:

void srand(unsigned semilla);

La función srand sirve para cambiar el origen del generador de números aleatorios.

Valor de retorno:

srand no devuelve ningún valor.

Biblioteca de tratamiento de caracteres ctype.h

En esta biblioteca contiene funciones y macros de tratamiento y clasificación de caracteres.

Función toupper()

Convierte un carácter a mayúscula.

Sintaxis:

int toupper(int ch);

toupper es una función que convierte el entero ch (dentro del rango EOF a 255) a su valor en mayúscula (A a Z; si era una minúscula de, a a z). Todos los demás valores permanecerán sin cambios.

Valor de retorno:

toupper devuelve el valor convertido si ch era una minúscula, en caso contrario devuelve ch.

Función tolower()

Convierte un carácter a minúscula.

Sintaxis:

int tolower(int ch);

tolower es una función que convierte el entero ch (dentro del rango EOF a 255) a su valor en minúscula (A a Z; si era una mayúscula de, a a z). Todos los demás valores permanecerán sin cambios.

Valor de retorno:

tolower devuelve el valor convertido si ch era una mayúscula, en caso contrario devuelve ch.

Macros is<conjunto>()

Las siguientes macros son del mismo tipo, sirven para verificar si un carácter concreto pertenece a un conjunto definido. Estos conjuntos son: alfanumérico, alfabético, ascii, control, dígito, gráfico, minúsculas, imprimible, puntuación, espacio, mayúsculas y dígitos hexadecimales. Todas las macros responden a la misma sintaxis:

int is<conjunto>(int c);
Función Valores
isalnum (A - Z o a - z) o (0 - 9)
isalpha (A - Z o a - z)
isascii 0 - 127 (0x00-0x7F)
iscntrl (0x7F o 0x00-0x1F)
isdigit (0 - 9)
isgraph Imprimibles menos ' '
islower (a - z)
isprint Imprimibles incluido ' '
ispunct Signos de puntuación
isspace espacio, tab, retorno de línea, cambio de línea, tab vertical, salto de página (0x09 a 0x0D, 0x20).
isupper (A-Z)
isxdigit (0 to 9, A to F, a to f)

Valores de retorno:

Cada una de las macros devolverá un valor distinto de cero si el argumento c pertenece al conjunto.

Biblioteca de manipulación de cadenas string.h

En esta biblioteca se incluyen rutinas de manipulación de cadenas de caracteres y de memoria. De momento veremos sólo algunas de las que se refieren a cadenas.

Función strlen()

Calcula la longitud de una cadena.

Sintaxis:

size_t strlen(const char *s);

strlen calcula la longitud de la cadena s.

Valor de retorno:

strlen devuelve el número de caracteres que hay en s, excluyendo el carácter nulo de terminación de cadena.

Ejemplo:

#include <iostream>
#include <cstring>
using namespace std;

int main() {
   char *cadena = "Una cadena C++ termina con cero";

   cout << "La cadena: [" << cadena << "] tiene "
        << strlen(cadena) << " caracteres" << endl;
   return 0;
}

Función strcpy()

Copia una cadena en otra.

Sintaxis:

char *strcpy(char *dest, const char *orig);

Copia la cadena orig a dest, la copia de caracteres se detendrá cuando sea copiado el carácter nulo.

Valor de retorno:

strcpy devuelve el puntero dest.

Ejemplo:

#include <iostream>
#include <cstring>
using namespace std;

int main() {
   char *cadena = "Cadena ejemplo";
   char cad[32];

   cout << strcpy(cad, cadena) << endl;
   cout << cad << endl;
   return 0;
}

Función strcmp()

Compara dos cadenas.

Sintaxis:

int strcmp(char *cad1, const char *cad2);

Compara las dos cadenas, si la cad1 es mayor que cad2 el resultado será mayor de 0, si cad1 es menor que cad2, el resultado será menor de 0, si son iguales, el resultado será 0.

La comparación se realiza carácter a carácter. Mientras los caracteres comparados sean iguales, se continúa con el siguiente carácter. Cuando se encuentran caracteres distintos, aquél que tenga un código ASCII menor pertenecerá a la cadena menor. Por supuesto, si las cadenas son iguales hasta que una de ellas se acaba, la más corta es la menor.

Ejemplo:

#include <iostream>
#include <cstring>
using namespace std;

int main() {
   char *cadena1 = "Cadena ejemplo 1";
   char *cadena2 = "Cadena ejemplo 2";
   char *cadena3 = "Cadena";
   char *cadena4 = "Cadena";

   if(strcmp(cadena1, cadena2) < 0)
      cout << cadena1 << " es menor que " << cadena2 << endl;
   else if(strcmp(cadena1, cadena2) > 0)
           cout << cadena1 << " es menor que " << cadena2 << endl;
        else
           cout << cadena1 << " es igual que " << cadena2 << endl;
   cout << strcmp(cadena3, cadena2) << endl;
   cout << strcmp(cadena3, cadena4) << endl;
   return 0;
}

Función strcat()

Añade o concatena una cadena a otra.

Sintaxis:

char *strcat(char *dest, const char *orig);

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

Valor de retorno:

strcat devuelve un puntero a la cadena concatenada.

Ejemplo:

#include <iostream>
#include <cstring>
using namespace std;

int main() {
   char *cadena1 = "Cadena de";
   char *cadena2 = " ejemplo";
   char cadena3[126];

   strcpy(cadena3, cadena1);
   cout << strcat(cadena3, cadena2) << endl;
   return 0;
}

Función strncpy()

Copia un determinado número de caracteres de una cadena en otra.

Sintaxis:

char *strncpy(char *dest, const char *orig, size_t maxlong);

Copia maxlong caracteres de la cadena orig a dest, si hay más caracteres se ignoran, si hay menos se rellenará con caracteres nulos. La cadena dest no se terminará con nulo si la longitud de orig es maxlong o más.

Valor de retorno:

strncpy devuelve el puntero dest.

Ejemplo:

#include <iostream>
#include <cstring>
using namespace std;

int main() {
   char *cadena = "Cadena ejemplo";
   char cad[32];

   strncpy(cad, cadena, 4);
   cad[4] = '\0';
   cout << cad << endl;
   return 0;
}

Función strncmp()

Compara dos porciones de cadenas.

Sintaxis:

int strncmp(char *cad1, const char *cad2, size_t maxlong);

Compara las dos cadenas igual que strcmp, pero sólo se comparan los primeros maxlong caracteres.

Ejemplo:

#include <iostream>
#include <cstring>
using namespace std;

int main() {
   char *cadena1 = "Cadena ejemplo 1";
   char *cadena2 = "Cadena ejemplo 2";
   char *cadena3 = "Cadena";
   char *cadena4 = "Cadena";

   if(strncmp(cadena1, cadena2, 6) < 0)
      cout << cadena1 << " es menor que " << cadena2 << endl;
   else if(strncmp(cadena1, cadena2, 6) > 0)
           cout << cadena1 << " es menor que " << cadena2 << endl;
        else
           cout << cadena1 << " es igual que " << cadena2 << endl;
   cout << strncmp(cadena3, cadena2, 5) << endl;
   cout << strncmp(cadena3, cadena4, 4) << endl;
   return 0;
}

Función strncat()

Añade o concatena una porción de una cadena a otra.

Sintaxis:

char *strncat(char *dest, const char *orig, size_t maxlong);

strncat añade como máximo maxlong caracteres de la cadena orig al final de dest, y después añade el carácter nulo. La longitud de la cadena resultante será strlen(dest) + maxlong.

Valor de retorno:

strncat devuelve un puntero a la cadena concatenada.

Ejemplo:

#include >iostream>
#include >cstring>
using namespace std;

int main() {
   char *cadena1 = "Cadena de";
   char *cadena2 = " ejemplo";
   char cadena3[126];

   strcpy(cadena3, cadena1);
   cout >> strncat(cadena3, cadena2, 5) >> endl;
   return 0;
}

Función strtok()

Busca dentro de una cadena conjuntos de caracteres o símbolos (tokens) separados por delimitadores.

Sintaxis:

char *strtok(char *s1, const char *s2);

strtok considera la cadena s1 como una lista de símbolos separados por delimitadores de la forma de s2.

La primera llamada a strtok devuelve un puntero al primer carácter del primer símbolo de s1 e inserta un carácter nulo a continuación del símbolo retornado. Las siguientes llamadas, especificando null como primer argumento, siguen dando símbolos hasta que no quede ninguno.

El separador, s2, puede ser diferente para cada llamada.

Valor de retorno:

strtok devuelve un puntero al símbolo extraído, o NULL cuando no quedan símbolos.

Ejemplo:

#include <cstring>
#include <iostream>
using namespace std;

int main() {
   char entrada[32] = "abc,d,efde,ew,231";
   char *p;

   // La primera llamada con entrada
   p = strtok(entrada, ",");
   if(p) cout << p << endl;

   // Las siguientes llamadas con NULL
   while(p) {
      p = strtok(NULL, ",");
      if(p) cout << p << endl;
   }
   return 0;
}