Foro de elhacker.net

Hola! ¿Alguien me puede explicar, línea por línea, lo que hace este programa de ejemplo del libro de Ritchie y Kernighan?

#include <stdio.h>

int power(int m, int n);

/* prueba la función power */
main()
{
   int i;
   
   for (i = 0; i < 10; ++i)
      printf ("%d %d %d\n", i, power(2,i), power (-3,i);
   return 0;
}

/* power: eleva la base a la enésima potencia; n > = 0 */

int power(int base, int n)
{
   int i, p;
   
   p = 1
   for ( i = 1; i < = n; + + i)
      p = p * base
   return p;
}

Coloca tus códigos entre etiquetas de código GeSHi (puedes seleccionar el lenguaje apropiado en el desplegable que hay encima del cuadro de texto)... :rolleyes:

// incluyes la libreria <stdio.h> para poder usar las funciones que contiene (printf() en este caso)
#include <stdio.h> 
 
int power(int m, int n); // prototipo de una funcion <power()> que recibe dos enteros <int> como parametros y devuelve otro entero <int>
 
/* prueba la funcion power */
main() // funcion principal (lo que realmente se ejecuta. PD: Aunque funciona asi es recomendable poner <int main()> ya que devuelve un <int>
{
   int i; // declaras una variable <i> de tipo entero <int>
   for (i = 0; i < 10; ++i) // bucle que empieza asignando 0 a <i>, se ejecuta mientras (i < 10) y en cada vuelta se suma 1 a <i> [(++i) es igual que (i = i+1) y que (i += 1)]
      printf ("%d %d %d\n", i, power(2,i), power (-3,i); // muestra por pantalla 3 enteros, primero <i>, luego 2 elevado a <i> y luego -3 elevado a <i>
   return 0; // devuelve 0, es lo que suele indicar que el programa se ha ejecutado correctamente hasta el final
}
/* power: eleva la base a la enesima potencia; n > = 0 */
int power(int base, int n) // implementas la funcion cuyo prototipo has puesto al principio
{
   int i, p; // declaras dos variables enteras <int> que son <i> y <p>
   p = 1 // asignas a p el valor 1. PD: Has olvidado el ;
   for ( i = 1; i < = n; + + i) // bucle empezando en 1,  e incrementando de 1 en 1 mientras (i <= n)
      p = p * base // asignas a <p> el producto de <p> por la variable <base> (primer parametro de la funcion. Se puede abreviar como p *= base
   return p; // devuelve el valor que tiene <p> al terminar la funcion
}

No funcionará. El operador de incremento es ++, no + +. No puede tener espacios en medio.

No entiendo. ¿Cuál es el resultado de printf? Cuando en printf dice "power(2,i)" ¿llama a la fución power?

La función <printf()> tiene unos parámetros que cuesta ver si no se conocen. Te dejo  AQUÍ  (http://www.cplusplus.com/reference/cstdio/printf/) un enlace a una página donde puedes ver todo lo relacionado con esa función.

El primer parámetro siempre es una cadena de <char> que puede:

• Ser literal: Muestra tal cual lo que le pones.

printf("Hello World"); // Salida: Hello World 

• Usar especificadores de formato: Permite mostrar el valor de variables o funciones que devuelven algo.

int a = 3, b = 2;
printf("La suma de %d + %d es %d", a, b, a+b); // Salida: La suma de 3 + 2 es 5 

Puedes encontrar todos los especificadores de formato que hay en el enlace que te he dejado antes. Según el tipo de variable que quieres mostrar o literales (como en este caso) tienes que usar un especificador u otro.

Lo que yo no entendía era que "power" en printf llama a la función "power" y está regresa el valor. Ahora lo entiendo.
Tengo una duda: ¿Cómo sabe el compilador que se trata de una función y no simplemente de una variable?

Para que lo entiendas es como que el compilador coge lo que devuelve cada parámetro. Si es una variable simple coge el propio valor, si es una función coge el valor de retorno de la función o si es una operación coge su resultado.

Si entiendo bien cuando el programa llega a printf y encuentra "power" se ejecuta la función "power". ¿No podría pasar que lo tome cómo una variable?

Al estar escrito con unos paréntesis, el compilador sabe que es una función.

int power; // variable power de tipo entero
int power(); // funcion power que retorna un entero 

Más que el compilador, el ensamblador, cuando traduce el programa de C a ensamblador ya traduce las instrucciones correspondientes para llamar a la función correspondiente. Eso puedes verlo si te adentras un poco más en las fases de compilación que sufre un código fuente y los ficheros que se generan en cada fase.

Mi duda es cómo se sabe en printf que power no es una variable, que es una función.

Porque así se ha traducido en la compilación del programa. He editado mi mensaje anterior con otra explicación un poco más concreta pero sin entrar demasiado en materia.

Si no existiera
   int power()
 
al estar
   int power;

¿printf tomaría "power" como una variable?


 

Existan las que existan <printf()> toma cada parámetros como lo que es:

int power = 2;
int power(){return 5;};
printf("%d - %d", power, power()); // Salida: 2 - 5 

int power = 2;
printf("%d", power()); // ERROR printf() espera una funcion llamada power() que no existe 

int power(){return 5;}
printf("%d", power); // ERROR printf() espera una variable power que no existe 

No sé si con esto ya queda más claro

Ahora entiendo. El hecho de que tenga () lo hace una función y si no tiene es una variable. Perdón por mi ignorancia.