Manejo de cadenas en C

Colapsar
X
  • Filtrar
  • Tiempo
  • Mostrar
Limpiar todos
nuevos mensajes

  • Manejo de cadenas en C

    Como es que puedo ingresar una oracion(conjunto de cadenas), por medio del teclado, luego pedir al usuario que ingrese una palabra(cadena), para que dicho ingreso(o sea cadena), compare con la oracion ingresada anteriormente, y buscar si hay esa palabra o no y si hay esa palabra reemplazarla por otra que el usuario ingresara. Quisisera que me colaboren(ejemplos, ideas, consejos), por que creo en C no se puede usar el tipo de dato String, gracias por la atencion
    Última edición por slif33r; 12-09-2014, 01:13 AM.

  • #2
    Re: Manejo de cadenas en C

    Hola slif33r, tengo unas preguntas:
    ¿es posible que uses c# en lugar de C?
    En caso que la respuesta anterior sea negativa, entonces ¿qué compilador de C estás usando?
    Saludos.

    Comentario


    • #3
      Re: Manejo de cadenas en C

      mm ps uso el DevC o tb ocupo el ZinjaI/Codeblock
      Lo quiero hacer en C

      Comentario


      • #4
        Re: Manejo de cadenas en C

        Para el ingreso por teclado tenés que estudiar tu compilador y ver si podés usar scanf o cin, o alguno apropiado para captura de datos. Tenés que ver cuál te conviene.

        Lo ideal sería almacenar todas las oraciones en un string
        Luego, mediante un bucle for, habría que recorrer ese string, para buscar las coincidencias con la cadena que se busca. Tal vez sea necesario el uso de funciones como strcmp, strchr, strlen. Estúdialas para ver si puedes resolver por ese camino.
        Si hay coincidencia, entonces habría que reemplazar esa cadena, pero teniendo en cuenta que no sobrepase el límite de tamaño de la string oraciones.
        Otra idea que se me ocurre es usar un arreglo (vector) de strings, donde vayamos almacenando temporalmente los strings por partes. Es decir que si strchr nos devuelve 5 y hay coincidencia con la cadena que se busca, entonces en vector[0] se debería almacenar los primeros 5 chars de oraciones, luego en vector[1] almacenar la cadena reemplazante y así hasta agotar la búsqueda. Finalmente habría que unir las partes vector[0], vector[1], ..., vector[n] para obtener el texto completo con todas las sustituciones.
        Si me sale alguna de estas ideas que tengo en mente, te voy a poder ejemplificar con código. Mientras tanto espero que lo dicho hasta ahora te pueda orientar para que encuentres la solución.
        ¡Saludos!
        Saludos.

        Comentario


        • #5
          Re: Manejo de cadenas en C

          lo casa es que si uso C no me acepta el cin y si solo seria con el scanf, aparte en C no hat el tipo String, como se usaria si tuviera el C++

          Comentario


          • #6
            Re: Manejo de cadenas en C

            Utiliza un puntero a un array de tipo Char para almacenar la cadena, es la única forma de manejar algo parecido a un string en C puro.

            Lo que no entiendo es que no te hayas planteado usar C++ que si incluye la clase String, pero te la puedes fabricar en C.
            Un cordial saludo
            -Acalanto-

            Madrid - España

            Leer detalladamente las normas del foro es una buena forma de comenzar a participar en él. Te llevará unos pocos minutos y el colectivo de usuarios te lo agradecerá. <si no las has leído sigue este enlace>

            Comentario


            • #7
              Re: Manejo de cadenas en C

              Hola amigos, coincido con acalanto, me parece que manejar punteros sería lo mejor, por eso desistí de la idea de los vectores, y como verán en el siguiente código uso punteros a char. Hace mucho que me alejé del lenguaje C, así que espero las correcciones y sugerencias de los especialistas.
              Este código es sólo un ejemplo que realicé para mostrar una forma de hacer las sustituciones. Me pareció adecuado hacerla con una función que realice una sustitución por llamada, porque de esa forma podrías implementar algo parecido a las funciones que poseen los editores de texto que al pulsar F3 realiza la siguiente búsqueda.
              Traté de explicar exhaustivamente todo en el código:
              [highlight=c]
              /* javinet 2014
              * Ejemplo que muestra cómo reemplazar texto dentro de un string
              *
              */
              #include <stdio.h> // printf la necesita
              #include <string.h> // strcpy, strstr la necesitan
              #include <stdlib.h> // malloc la necesita

              // comienza el baile! jaja xDDD
              char* reemplazarUnaVez(char *origen, char *buscada, char *reemplazo, int *comienzo); // prototipo de nuestra función para reemplazar


              int main(void)
              {
              char *s1, *sB, *sR; // s1: cadena origen, sB: cadena buscada, sR: cadena reemplazante

              s1 = (char *) malloc (4096); // reservamos memoria para el origen
              sB = (char *) malloc (256); // reservamos memoria para la cadena a buscar
              sR = (char *) malloc (256); // reservamos memoria para la cadena reemplazante

              strcpy(s1, "Probando la busqueda de una string dentro de otra.");
              printf("%s\n",s1);

              strcpy(sB, "de");
              strcpy(sR, "<de>");

              char *s; // declaramos el string que contendrá la cadena origen modificada con todas las sustituciones

              int i = 0; // indica la posición a partir de la cual debe comenzar la búsqueda, ya que si lo hace desde el principio, luego de la primera sustitución, si dicha sustitución contiene la cadena buscada, entonces no se podría salir del bucle.
              do // este bucle se necesita para poder sustituir con sR todas las apariciones de sB dentro de s1
              {
              s = reemplazarUnaVez(s1, sB, sR, &i);
              if (s == NULL)
              break; // si no hubo reemplazo, entonces sale del bucle
              s1 = s; // para seguir sustituyendo, necesitamos actualizar la cadena origen con la cadena recién actualizada

              }while (1); // bucle infinito

              printf(s1); // mostramos la cadena con todos los reemplazos. Si no hubo reemplazos, entonces muestra la cadena original

              free(s1); // debemos devolver, al sistema operativo, la memoria que nos prestó para la variable s1
              free(sB); // debemos devolver, al sistema operativo, la memoria que nos prestó para la variable sB
              free(sR); // debemos devolver, al sistema operativo, la memoria que nos prestó para la variable sR

              return 0; // todo salió bien
              }

              // función que sirve para reemplazar, sólo en su primera aparición, una cadena (buscada) dentro de un cadena origen, por otra (reemplazo)
              char* reemplazarUnaVez(char *origen, char *buscada, char *reemplazo, int *comienzo)
              {
              char *temp, *e; // temp servirá para guardar el texto luego del reemplazo y e para apuntar hacia la primera coincidencia de la cadena buscada dentro de la cadena origen
              int p; // p es el índice dentro de la cadena origen donde comienza la primera aparición de la cadena buscada

              temp = (char *) malloc (4096); // reservamos memoria para 4095 caracteres char

              if ( !(strlen(origen) < 4096) ) // tratamos de evitar un posible error por acceso a memoria no permitida
              {
              free(temp); // debemos devolver, al sistema operativo, la memoria que nos prestó para la variable temp
              return NULL;
              }

              e = origen + *comienzo; // comenzamos a buscar desde la posición comienzo
              e = strstr(e, buscada); // strstr busca la cadena buscada dentro de la cadena origen y devuelve la cadena origen desde la posición en que comienza la cadena buscada
              // si no la encuentra, retorna NULL
              if (e != NULL) // si encontró la cadena buscada dentro de la cadena origen
              {
              p = e - origen; // calculamos el lugar donde comienza la primera aparición de la cadena buscada dentro de la cadena origen
              strncpy(temp, origen, p); // copiamos de origen sólo los primeros p caracteres
              temp[p] = '\0'; // indicamos la finalización de la cadena temp, para poder concatenarla con strcat
              strcat(temp, reemplazo); // concatenamos la cadena que va a reemplazar a la cadena buscada
              *comienzo = strlen(temp); // actualizamos el comienzo, para que la próxima búsqueda comienze desde esta posición

              e = origen + p + strlen(buscada); // ahora debemos eliminar la cadena buscada, para lo cual debemos actualizar el puntero e
              strcat(temp, e); // concatenamos el resto de caracteres del origen
              return temp; // devolvemos la cadena origen con la primera aparición de la cadena buscada reemplazada por la cadena reemplazo
              }else // si no encontró la cadena buscada dentro de la cadena origen
              return NULL; // retorna NULL
              }
              [/highlight]
              Fijate cómo paso por referencia la variable i dentro del bucle do..while, eso es fundamental para que pueda funcionar correctamente el programa.
              Si te das cuenta, verás que me olvidé un free antes del último return, así que tendrás que agregarlo.
              Una sugerencia, para manejo y manipulación de caracteres es indispensable que domines los punteros, direccionamiento de memoria y todos esos detalles técnicos que un programador en C no pude prescindir. Un libro que me impresionó al respecto fue "El Lenguaje de Programación C" de Kernighan y Ritchie, por su sencillez en el manejo de los punteros.
              Puede ser que haya una mejor solución ya sea manipulando directamente la memoria o bien con código ASM. Habría que ver si algún experto en C nos puede clarificar el tema.

              Sólo queda por ver un paso a paso cómo se reemplaza la string:
              Código:
              // comenzamos con la string
              
              Probando la busqueda de una string dentro de otra.
              
              // se copian los primeros caracteres hasta la aparición de la primera "de"
              
              Probando la busqueda 
              
              // Luego se le añade la cadena reemplazante:
              
              Probando la busqueda <de>
              
              // se guarda en la variable comienzo, el valor de la longitud de esta string
              
              comienzo = 25 //desde esta posición comenzará la búsqueda la próxima vez
              
              // a continuación se descarta la string buscada, y se añaden los demás caracteres del origen
              
              Probando la busqueda <de> una string dentro de otra.
              
              // si no se usara la variable comienzo, entonces la próxima búsqueda daría como resultado:
              
              Probando la busqueda <<de>> una string dentro de otra.
              
              // Lo cual es incorrecto ya que lo correcto sería:
              
              Probando la busqueda <de> una string <de>ntro de otra.
              Espero puedas entender el ejemplo y adaptarlo para tu proyecto.
              Una reflexión antes de terminar: cuánto nos ayuda .Net con las strings! y en este caso c# y además nos brinda la clase StringBuilder que acelera sustancialmente las operaciones con strings, para que no extrañemos el C.
              ¡Saludos cordiales!
              Saludos.

              Comentario

              Trabajando...
              X