SoloCodigo

estoy teniendo problemas con las funciones recursivas.

en especial con este ejercicio:

Escribid una función que reciba una cadena de caracteres terminados en un punto , leídos uno a uno con la función getche() y la devuelva de forma inversa:
Ejemplo: ‘hola’
Salida:   ‘aloh’

lo complicado es que no se puede tratar como una cadena de caracteres sino que hay que introducir uno a uno y no se como acerlo
si alguien me puede ayudar lo agradezco

muxas gracias moskito pero ando muy perdido en este tema y no se que tengo que acer en el modulo principal, si me puedes ayudar te lo agradeceria muxisimo

Buenas.

Si no me equivoco la funcion getche() es de conio. Y no lee del buffer de entrada sino del teclado.

La idea es hace una funcion que capture un caracter con getche(), si este es '.' entonces retorna, sino se llama a si misma, imprime el caracter y retorna.

De esa forma cuando se ingrese el . se va a ir saliendo de las funciones e imprimiendo los caracteres en el orden inverso al que se ingresaron.

En el main simplemente tendrias que llamar a esa funcion.

Eso es lo que entendi por lo menos, espero que sirva.

Saludos

la cosa es algo asi

Personalmente, no usaría conio.h, pero eso ya es decisión de cada uno.

Totalmente de acuerdo, sin embargo, hacerlo sin esa funcion seria bastante tedioso, ya que habria que leer desde el buffer de stdio. Ya que (que yo sepa) no hay ninguna funcion standard que lea el caracter antes de que se apriente enter.

ya lo e resuelto es asi:

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
void inversa(char car);
main()
{
   char car;
   printf("nt     PROGRAMA QUE LEE UNA PALABRA Y LA IMPRIME AL REVESn");
   printf("_____________________________________________________________________________n");

   printf("nIntroducir palabra : ");
   inversa(car);
   printf("nn");
   system("pause");
}
void inversa(char car)
{
   car=getche();

   if(car!='.')

   inversa(car);
   printf("%c",car);
}

¡Hola a todos!

A míme corrio con unos cambios, uso geany  y no me reconoció la librería conio.h, ni tampoco la función getche sino getchar.

#include <stdio.h>
#include <stdlib.h>

void inversa (char car);

main()
{
   char car;
   printf("nPalabra regresada al revés: ");
   inversa (car);
   printf("nn");
   /*system("pause");*/
}

void inversa (char car)
{
   car=getchar();
   
   if (car != '.')
   inversa (car);
   printf("%c",car);
}

solo una duda, si char solo tiene límite de un 1byte, ¿por qué me recibe una cadena larga de hasta 20 caracteres? y por cierto el system("pause") tampoco me jaló, para que la pusiste cuate?


saludos al foro!

no me reconoció la librería conio.h, ni tampoco la función getche sino getchar

por cierto el system("pause") tampoco me jaló

solo una duda, si char solo tiene límite de un 1byte, ¿por qué me recibe una cadena larga de hasta 20 caracteres?

Él usa Windows y tú al parecer no. Esas funciones no son estándar, de ahí mi comentario anterior:

Personalmente, no usaría conio.h, pero eso ya es decisión de cada uno.

solo una duda, si char solo tiene límite de un 1byte, ¿por qué me recibe una cadena larga de hasta 20 caracteres?

Es un char local a cada llamda de función. Mientras la función no retorne, ese valor sigue almacenado en la pila temporal de la función. Si quieres entenderlo más en profundidad, tendría que explicarte cómo se implementan las funciones C en ensamblador, pero para ello tienes que saber un poco de arquitectura de computadores. Si te interesa me dices y te lo cuento.

¿Lo que te refieres es qué el valor se guarda en el espacio almacenado para la función?

Algo parecido. En realidad es un espacio que comparten la función que llama y la función llamada.

¿ ese espacio tiene límite?

Por supuesto, la memoria no es infinita.

por que está definido como void (sin retorno) y no como un tipo de dato del C?

No está definido como void

void inversa (char car)

Claro que también aceptaría unas clasesitas de como se implementan las funciones C en padre ensamblador..

En IA32 (comúnmente llamada x86), el paso de argumentos a funciones se realiza a través de la pila. Esto es, se ponen en la pila los argumentos de la función en orden inverso a los declarados en C, usando la instrucción PUSH. En este caso, se pasa el char en la pila a inversa(). La función lo recupera con la instrucción POP. Acto seguido, inversa se llama a sí misma, con lo que inserta otro char en la pila usando igualmente PUSH, y la segunda llamada lo recupera igualmente con POP (ya que es el mismo código). Así se van acumulando los caracteres en la pila. Al volver, se leen los caracteres en orden inverso, y se libera el espacio en la pila al finalizar las funciones. Algunas veces el compilador también usa el registro EBP para indicar el comienzo de los argumentos para la función, evitando así acceder usando ESP (el puntero de pila). Las instrucciones PUSH y POP modifican ESP automáticamente.

Para más detalles, mira el fichero ensamblador que genera el compilador para este ejemplo, así lo verás más claro. Cualquier duda te la intento aclarar.

Saludos.

Gracias, espero que tú también compartas con nosotros tus conocimientos    

Tienes toda la razón, pero sólo era un ejemplo. En MIPS se pasan por los registros $aX y se devuelve el valor de la función en $v0 (y también soportaba 2 valores de retorno, en $v1), pero también se podrían pasar por pila. De todas formas, esas son meras convenciones, uno lo puede hacer como prefiera.