Funciones de cadenas en C

Hola,

una de las cosas que más echaba de menos al programar en C eran las funciones que se disponían en otros lenguajes para el tratamiento de cadenas (como un Left, Right, …..) así que al final programé mis propias funciones que dejo aquí para que os puedan ser útiles.

Debido a las limitaciónes de wordpress para marcar el caracter ascii 0 de limitador de cadena tengo que usar barra_cero. Hay que tenerlo en cuenta al copiar las funciones.

/*
 @file utils.c
 @brief Libreria de funciones varias
 */
#include 
#include "utils.h"

/*
 @brief Copia N caracteres de S1 en S2 hasta que encuentra un retorno de carro
 @param *s1 Cadena a copiar
 @param *s2 Cadena resultado
 */
void br_clean(char *s1, char *s2)
{
	while ( *s1++ != 'r'){
		*s2++=*s1;
	}
}

/*
 @brief Sustituye el caracter 'n' por 'barra_cero'
 @param *s1 Cadena a tratar
 */
void bn_bc(char *s1)
{
	int sizeS=strlen(s1);
    if(s1[sizeS-1]=='n'){
		s1[sizeS-1]='barra_cero'; // sustituir n por barra_cero}
}

/*
 @brief Copia N caracteres por la derecha de la  cadena apuntada por s1 a s2
 @param *s1 Cadena a tratar
 @param *s2 Cadena resultado
 @param sizeS Cantidad de caracteres a copiar
 */
void sRight(char *s1, char *s2, int sizeS){
	int pos;
	int i;

	pos=strlen(s1)-sizeS;
	for (i=0;i<=(sizeS-1);i++){
		s2[i]=s1[pos];
		pos++;
	}
	s2[sizeS]='barra_cero';
}

/*
 @brief Copia los primeros N caracteres por la
 izquierda de la cadena apuntada por s1 a s2
 @param *s1 Cadena a tratar
 @param *s2 Cadena resultado
 @param sizeS Cantidad de caracteres a copiar
 */
void sLeft(char *s1, char *s2, int sizeS){
	int i;

	for (i=0;i<=(sizeS-1);i++){
		s2[i]=s1[i];
	}
	s2[sizeS]='barra_cero';
}

/*
 @brief Copia N caracteres por la izquierda a partir de una posición de la cadena apuntada por s1 a s2
 @param *s1 Cadena a tratar
 @param *s2 Cadena resultado
 @param sizeS Cantidad de caracteres a copiar
 @param pos Posición del caracter en la cadena a partir de la cual hay que copiar N caracteres
 */
void sMid(char *s1, char *s2, int sizeS, int pos){
	int i;

	for (i=0;i<=(sizeS-1);i++){
		s2[i]=s1[pos];
		pos++;
	}
	s2[sizeS]='barra_cero';
}

/*
 @brief Da la vuelta a las posiciones de los caracteres en un array
 @param *s1 Cadena a girar
 @param *s2 Cadena resultado
 */
void sGir(char *s1, char *s2){
	int i;

	for(i=0;i<strlen(s1);i++){
		s2[strlen(s1)-i-1]=s1[i];
	}

}

/*
@file utils.h
@brief Libreria de funciones varias
*/
extern void sRight(char *s1, char *s2, int size_n);
extern void sLeft(char *s1, char *s2, int size_n);
extern void sMid(char *s1, char *s2, int size_n, int pos);
extern void bn_bc(char *s1);
extern void br_clean(char *s1, char *s2);
extern void sGir(char *s1, char *s2);

Anuncios
  1. cristhian
    Martes, 5 enero 2010 en 8:25 am

    hola soy nuevo estudiante y me pidieron un trabajo en funciones en cadena me pueden dar algunos ejemplos para verlos y estudiarlos. gracias

  2. Adriana
    Martes, 8 diciembre 2009 en 1:21 pm

    Oye me dejaron un programa que tiene que hacer lo siguiente

    Elaborar un programa que lea N caracteres, cada uno de los cuales NO esta entre K y L.
    Conforme se lee cada carácter, se imprimirá solo si no se ha leído previamente.
    El valor de K,L,N serán definidos por el usuario. Usa el arreglo lo más pequeño que sea posible.
    Incluye todas las validaciones pertinentes

    lo que llevo es lo siguiente

    #include
    #include
    int main()
    {
    struct almacen
    {
    struct almacen *atras;
    int dato;
    struct almacen *adelante;
    };
    struct almacen *estructura, *auxiliar;
    int numero,k, l, i;
    int valor;
    printf(“nEstablesca la cantidad de caracteres a leer: “);
    scanf(“%d”,&numero);
    while((numero20))
    {
    printf(“nEl valor digitado es invalido. El valor a introducir debe ser numerico y no ser mayor que 20.nn”);
    system(“PAUSE”);
    exit(1);
    }
    printf(“nnnIndique de el rango de caracteres que no se evaluaran.”);
    printf(“nnRango inicial: “);
    scanf(“%s”,&k);
    printf(“nRango final: “);
    scanf(“%s”,&l);
    printf(“nn”);
    if((estructura=(struct almacen *)malloc(sizeof(struct almacen)))==NULL)
    {
    printf(“Error. No se ha podido asignar la memoria requerida.nn”);
    system(“PAUSE”);
    exit(1);
    }
    estructura->atras=NULL;
    estructura->dato=65;
    estructura->adelante=NULL;
    for(i=1;iatras=auxiliar;
    estructura->dato=auxiliar->dato=valor;
    auxiliar->adelante=estructura;
    estructura->adelante=NULL;
    }
    while(estructura->atras!=NULL)
    {
    estructura=estructura->atras;
    }
    printf(“nnResultados:nn”);
    while(estructura->adelante!=NULL)
    {
    printf(“Es Impar?: %cnn”,estructura->dato);
    estructura=estructura->adelante;
    }
    free(estructura);
    free(auxiliar);
    printf(“n”);
    system(“PAUSE”);
    }
    pero no hace lo que me pide, me podrias ayudar con el codigo? ya de plano me bloque y lo necesito entregar el jueves

  3. syd
    Lunes, 10 agosto 2009 en 6:42 am

    no entendi ni mergas la neta tengo examen y necesito un milagro gracias

    • tolgalen
      Miércoles, 12 agosto 2009 en 6:02 pm

      Como no hayas estudiado antes los milagros no existen.

  4. joe
    Domingo, 7 junio 2009 en 1:05 am

    aclaracion: en el codigo 1 es: diagonal invertida y cero en el while

    //——-codigo 1
    char*ruta=”/home/josoviedo/miniSQL/”;
    char *rutaux;
    while(ruta[i] !=”)
    {
    rutaux[i] = ruta[i];
    }

  5. joe
    Domingo, 7 junio 2009 en 1:01 am

    oye una duda tenia originalmente estas lineas de codigo:

    //——-codigo 1
    char*ruta=”/home/josoviedo/miniSQL/”;
    char *rutaux;
    while(ruta[i] != ”)
    {
    rutaux[i] = ruta[i];
    }
    pero me marcaba “violacion de segmento”
    despues lo modifique a esto ya que me entere que linux maneja el salto ” como ‘r’, ademas le agregue al final este valor a la cadena inicial y a la final

    //——-codigo 2
    char*ruta=”/home/josoviedo/miniSQL/r”;
    char *rutaux;
    while(ruta[i] != ‘r’)
    {
    rutaux[i] = ruta[i];
    }
    ruta[i]=’r’
    y que crees.. “violacion de segmento”

    entonces vi tu funcion y la copie y quedo asi:

    //—codigo 3 char*ruta=”/home/josoviedo/miniSQL/r”;
    char *rutaux;
    while(*ruta++ != ‘r’)
    {
    *rutaux++ = *ruta;
    printf(“%c”,*rutaux);
    }
    *rutaux++ = ‘r’;

    y que crees … “violacion de segmento” entonces me dije: “estoy muy piedra” y desesperadamente intente lo siguiente:

    void eliminarBase(char *nombreBase)
    {
    struct stat datosFichero;
    char *ruta=”/home/josoviedo/miniSQL/r”;
    char *rutaux;
    br_clean(ruta,rutaux);
    }

    void br_clean(char *s1, char *s2)
    {
    while ( *s1++ != ‘r’)
    {
    *s2++=*s1;
    }
    }

    y nada “violacion de seg” le quite el r a ruta y nada estoy desesperadado la funcio strcpy me marca lo mismo y no se como realizar esta funcion, se lo basico de linux uso fedora 8 espero me puedas ayudar

    de antemano gracias

    • tolgalen
      Martes, 9 junio 2009 en 9:23 am

      char ruta[24]=”/home/josoviedo/minisql”;
      char ruta_aux[24];

      strcpy (ruta_aux, ruta);

      Esto funciona perfectamente en linux, me da que tienes un problema con los limites del la cadena.

  6. tolgalen
    Sábado, 28 marzo 2009 en 10:13 pm

    Me alegro que te sean útiles.

  7. Carlos
    Jueves, 26 marzo 2009 en 10:00 pm

    Espectacular!!

  1. No trackbacks yet.
Los comentarios están cerrados.
A %d blogueros les gusta esto: