Mensajes

Haz informática y telecos al mismo tiempo. Problem  ?

El interrogante no parece importante. Tal vez, '\?' sea el símbolo por defecto que se muestra para un "carácter no imprimible" (que en tu caso es un interrogante mondo y lirondo). Pero vamos, no creo que sea algo crítico (tu aprendizaje no se va a ver drásticamente influenciado por esta tontería). Los que si son importantes son los otros que citas:

"\\" Sirve para imprimir una barra inclinadad normal (\). Si pusieras "\" a secas, le estarías indicando al compilador que el siguiente carácter lo interprete como secuencia de escape (y al tratarse en este caso de las comillas, no estarías cerrando correctamente el string).

"\"" Sirve para imprimir unas comillas ("). Si pusieras """ estarías abriendo el string, cerrandolo y volviéndolo a abrir.

'\'' Idem que en el caso anterior, pero con comillas simples. En un string más largo se puede poner la comilla simple perfectamente, sin necesidad del \ (por ejemplo: " 'Hola' y 'adios' ").

Repito, no te agobies por lo del interrogante. ¡Hay cosas más divertidas  !

Saludos

Edito: Vale, me doy cuenta de que faltaría modificar el matiz para un exponente negativo, voy a ver como sería y comento.

Edito 2: Corregido, si el exponente es negativo basta con dividir 1 entre el resultado.

Y te faltaría también el caso general de un exponente real. Lo cierto es que no me voy a currar una explicación muy detallada si no tengo la seguridad de que de verdad te interesa el caso general del exponente real (en mi solución entrarían polinomios de Taylor, por ejemplo, y no es algo sobre lo que me apetezca escribir después de medianoche sin la certeza de que no se lo van a pasar por el forro, xD). Si te interesa (y por alguna razón sigues queriendo reinventar la rueda), ya nos lo dirás. Por otro lado, el caso particular de los exponentes enteros es una chorrada (tanto iterativa como recursivamente). Con lo cual no trato de decirte nada malo, sino que encontrarás muchos ejemplos, tanto en este foro como en cualquier otro sitio web. Además, ya que quieres que no haya bucles en tu programa, has de saber que es muy fácil y muy mecánico convertir una función iterativa (que seguramente ya sabes como se haría para este caso) en una recursiva. Un ejemplo con el factorial:

Código (cpp) [Seleccionar] Expandir

int factorial1(int n) { // Version iterativa
int result = 1;
for (int i = 2; i <= n; ++i) result *= i;
return result;
}

int factorial2(int n) { // Version recursiva
if (n < 2) return 1;
else return n*factorial2(n-1);
}

Sólo tienes que aplicar lo mismo en tu caso (si sólo contemplas potencias enteras).

¡Saludos!

Si no quieres ver punteros se puede hacer paso por referencia puro:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using namespace std;

void funcion (int &sobrenombreVariable) /* Esto se vuelve un "sobrenombre" de la variable, todas las modificiaciones
que hagas en "sobrenombreVariable" se harán en "variable" */
{
sobrenombreVariable = 10;
}

int main ()
{
int variable = 0;
funcion (variable); //Le pasamos la variable a la que queremos que afecte el sobrenombre

return 0;
}

Busca "paso por referencia" y encontrarás más información. Saludos.

Correcto. Pero es lo mismo que dijo satu, xD. Se te adelantaron 

¡Saludos!

@Xandrete... :
Al declarar variables dentro de funciones no* se pueden retornar porque las variables son
locales la memoria asignada en ese momento es liberada, despues puede tener otros valores
pd: debe ser un tipo de dato como char, int

¿Eh? Lo que dices no se aplica al código que yo he propuesto. Esto es algo que he hecho millones de veces, de hecho.

Retornas una copia de esa variable, no un puntero a la variable declarada dentro de la función. Pruébalo y verás que funciona perfectamente (y si compilas con -Wall y -Werror, el compilador no se quejará ni un poquito).

Saludos.

EDITO: Acabo de leer tu PD2. Es totalmente legal, te lo aseguro. ¿Lento? Bueno, en un caso es lento el paso de parámetros, y en otro es lento el retorno de la función. Me explico. Pon que quieres devolver/asignar 100 datos en una función, y que tratas de hacerlo mediante la primera alternativa (la de paso de parámetros por referencia). En ese caso es "lento" el paso de parámetros porque se han de guardar 100 punteros en pila (más parámetros adicionales que hicieran falta en la función). Sin embargo, el retorno es rápido porque no hay nada que devolver. En mi propuesta (usando struct) es rápido el paso de parámetros (porque seguramente no hay que usar ni la pila) pero lento el retorno de la función (porque es ahí cuando hay que recurrir a ella).

EDITO OTRA VEZ: Si tienes algo que replicarme, dale a responder otra vez, no sigas editanto el tuyo, xD (yo lo hago para no poner dos posts seguidos  )

¡¡¡NOOOOOOOO (grito desvaneciéndose en la inmensidad  ) !!!

Fíjate:

Código (cpp) [Seleccionar] Expandir

int f;
int* num = new int[f];

Dos cosas: new es un operador. Es decir, es como el +, o como el -, o como el =. ¿Y qué es un operador? Un operador, en el fondo, es una función (de hecho, la suma de dos enteros a,b, se puede efectuar haciento tanto a+b como operator+(a,b)). Por tanto, el new int[f] no puede estar "en el aire", lo tiene que ejecutar alguien (el main o alguna función referenciada por el main). La otra cosa es... si se pudiera hacer lo que pretendes... ¿que espacio se reservaría en memoria si a f no se le ha dado aún ningún valor explícitamente ? f contiene lo que se viene a llamar, entre amigos, basura. Esta basura puede ser desde un 0 hasta un 7515 (por poner un número, puede ser cualquier valor que entre en el rango de representación de un entero).

También puedes hacer que tu función devuelva una tupla.

Código (cpp) [Seleccionar] Expandir

struct Result {
int result1;
char result2;
double result3;
};

Result foo(int param) {
Result r;
// GENERIC CODE
return r;
}

Saludos

10 / 2 = 5... y ¿Resto 0? Eso es lo que no comprendo.

Sí, a ver. En la división de toda la vida identificas al dividendo, al divisor, al cociente y al resto. Si el dividendo es 10 y el divisor es 5, el cociente es 2 y el resto es 0. ¿Con manzanas? Mamá cerdita quiere repartir 5 manzanas entre sus 2 cerditos. Le da 2 a cada hijito y le sobra 1 manzana (el resto). Se come ella esa última manzanita ^^

Si el dividendo es 15 y el divisor 4, el cociente es 3 y el resto es 3 (15 = 4*3 + 3). El resto es lo que te sobra de una división entera.

Xandrete, gracias por la aclaración. Aunque el compilador nunca se quejó de eso, voy a tener cuidado con lo que me dices. Y supongo que puedo prescindir de la palabra new al crear el array ¿O no?

No, el operador new no es prescindible. Es, de hecho, lo más importante. Sirve para reservar espacio en la memoria dinámica. Ha de estar ahí (si no lo has visto aun, te dejo un link).

Por cierto, DickGumshoe, ya veo que eres el sheriff más rápido del oeste. Ya vi tu mensaje, pero como ya tenía escrito el mío, lo mando igualmente, xD.

Saludos  

EDITO: quiero decir, el operador new es imprescindible si quieres que el tamaño del array se pueda decidir en tiempo de ejecución. Si no, siempre puedes hacer el truco del almendruco, que es fijar un tamaño máximo. Haces el array de ese tamaño y le preguntas al usuario el número de elementos que va a necesitar.

Estoy viendo otra cosa muy horrorosa...

Código (cpp) [Seleccionar] Expandir

int n, i, num[f] // es la parte de int num[f] la que esta mal

No, no y no. Tal vez el compilador no se haya quejado, pero eso no quiere decir que sea correcto (rotundamente, NO lo es). ¿Por qué? Porque un array se ha de inicializar con un tamaño no decidido en tiempo de ejecución (el compilador tiene que saber el tamaño). ¿La forma correcta de hacerlo? Reservando memoria dinámica.

Código (cpp) [Seleccionar] Expandir

int* num = new int[f];

O, alternativamente:

Código (cpp) [Seleccionar] Expandir

int* num = malloc(f); // hay que incluir cstdlib primero

Por otro lado... ¡estás en C++! ¡Aquí tienes vectores! Tienes esta otra opción:

Código (cpp) [Seleccionar] Expandir

vector<int> num(f); // hay que incluir vector primero

Respecto a la pregunta "¿Debe ser float?", que nadie te ha contestado aun.

¿Debe? Hombre, deber, deber... ¿Poder? Claro, puedes usar float. O int, o char, o double. Depende de tus necesidades. ¿Quieres precisión decimal normalita? Usa float. ¿Sólo te interesa la parte entera de la división? Usa int. ¿Gran precisión decimal? Usa double. Como he dicho. no debe ser ni una cosa ni otra. Depende de qué es lo que te hace falta.

Saludos

P.S. Por curiosidad, ¿a qué universidad piensas ir :-) ?

¿Y que dicen ustedes de un microondas con axesso a internet? ¿Podria un hacker tostar nuestra pizza?

Hombre, un microondas con acceso a Internet me parece igual de útil que un inodoro con acceso a Internet (bueno, esto último me parece más útil, incluso... no hay nada como estar en el trono navegando por la web al mismo tiempo  )

¡Saludos!