Mensajes

Creo que skorpion no se refiere a la amistad entre clases, sino simplemente a usarla.

Si es así, tal y como lo haces y dices es correcto.

Es más facil, o más legible, hacerlo como condición del bucle, en vez de poner el break, o condicionales en vez del if. Pero bueno, igual hay algún caso en el que sea más intuitivo poner el break o el continue, aunque yo, que recuerde, aún no he encontrado ninguno xd.

Si, en la declaración tienes que poner [] o en su defecto *. En cuanto llegues a la parte de punteros lo comprenderas... Una cadena no deja de ser un puntero al primer elemento, asi que por eso funciona de ambas maneras.

En cuanto a lo de std::cout y tal, para buscar información, pon en google "espacio de nombres c++" o algo así. No es algo complejo ni mucho menos.

Respecto al prototipo de la función. Yo prefiero declarar arriba el prototipo como dices, y abajo realizarla, porque así sale todo más ordenado (desde mi punto de vista).

La diferencia entre int y unsigned int es eso que dices, que el unsigned no puede tomar valores negativos. Si vas a utilizar una variable que no puede usar valores negartivos (como la edad) está bien utilizarla como unsigned, pero bueno, por costumbre, porque en este caso no importaría demasiado. Básicamente se diferencian en su rango de representación.
unsigned int 32 bits 0 a 4,294,967,295
int 32 bits -2,147,483,648 a 2,147,483,647
Como ves el unsigned puede representar exactamente el doble de números positivos.

Y respecto al argc y argv[]... Eso se usa para pasarle datos al programa a la hora de ejecutarlo, me intentaré explicar.
Cuando ejecutas el programa desde el CMD o desde la consola, lo haces de la siguiente manera

Código [Seleccionar] Expandir


miprograma.exe           o            ./miprograma


Pero imagina que además, a la hora de llamarlo quieres indicarle algo más, como por ejemplo un número (podría ser lo que quieras, 2 ficheros, más números o lo que sea)

Código [Seleccionar] Expandir


./miprograma 10


Entonces aquí entra en funcionamiento el argc y argv.

Código (cpp) [Seleccionar] Expandir


int main (int argc, char* argv[]){
     if (argc!=2) return 0;    //argc indica el número de parámetros que le hemos
                                       //pasado a la hora de ejecutarse, en este caso
                                       //necesitamos comprobar que sean 2, pues queremos
                                       //leer también el número que le pasamos, si no le
                                       //pasamos el segundo parametro cerramos el programa
    int n=atoi(argv[1]);      //Copiamos el número recibido en la variable n.
                                      //tenemos que usar atoi, o un cast, porque si no recuerdo mal
                                     //, argv devuelve una cadena de caracteres, y tenemos
                                     //que convertirlo en un entero.


Recuerda que argv[0] contiene el nombre del programa, por eso empiezo por argv[1]

Delante de cada scanf y de cada getchar() pon lo siguiente.
while (getchar()!='\n');
esto limpiará el buffer de entrada, y ya no tendrás problemas de que se cierre justo después de darte el resultado.

Código (cpp) [Seleccionar] Expandir


int main (){
   int a,b,c,i;
   char cadena1[40]="milmasmil";
   char cadena2[50];
   char cadena3[40];
   printf("escriba la operacion:  ");
   fgets(cadena1,40,stdin);
   if (cadena1[strlen(cadena1)-1] == '\n')
   cadena1[strlen(cadena1)-1] = '\0';
   i= strcmp(cadena1,"milmasmil");
   if (i==0){
                                   printf("el resultado es 2000");
                                   }
   while (getchar()!='\n');
   getchar();
   return 0;
   }


Por cierto, también cambié el gets por fgets, que es más segura.

Pues a mi me parece más fácil C++, será para gustos xD

No voy a entrar a discutir.

Ya dijeron arriba que hacer recursión sobre el main() no es recomendable, además que en un largo uso sobrecarga la memoria...

Por supuesto que sé que eso compila, pero un programa no es perfecto por el mero hecho de compilar.

Un saludo...

Es que eso de return main() no tiene sentido.

Te dijeron varias veces que lo mejor es un bucle con un while, y no puedes decir que lo solucionaste con un goto, cuando tu pregunta era precisamente hacer eso sin usar goto xD

Sin leer lo que hace tu código exactamente, a la función Leer le pasas un objeto de tipo cabecera llamado "micabecera" y luego inmediatamente debajo declaras un objeto de tipo capecera con nombre "micabezera".
Estás declarando un objeto que es lo que le estás pasando a la función.

Un saludo.

EDIT: Vale, hemos escrito a la vez, veo que ya viste el error.

C sería el segundo enlace, y C++ el primero.

Un par de cosas.

Lo primero es que para medir el tiempo, no puedes realizar una vez el algoritmo y mirarlo, porque en un cálculo tan simple que tarda una fracción de tiempo minúscula en hacerla no tendrás ningún resultado.

Deberías repetir el algoritmo, por ejemplo, 100.000 veces, y luego ya dividir el resultado entre 10.000 para tener algo verdadero.

El problema, es que aún así, con ese algoritmo el resultado que te va a dar es siempre 0, es demasiado simple y no tarda "nada" en hacerlo. Te voy a poner unos ejemplos que tengo aquí de hace unos años en clase, con 3 funciones diferentes.


El primero, es una búsqueda secuencial

Código (cpp) [Seleccionar] Expandir


#include <vector>
#include <iostream>
#include <time.h>
using namespace std;

int Secuencial (vector <int> &A, int x, int n){
int i=0;
while (i<n&&A[i]!=x){
i++;
}
return i;
}


int main(){
vector <int> v(972000,0);
   float mejor, peor;
   
   float ini,fin,tiempo;
   
   cout << "Busqueda secuencial" << endl << endl;
   cout << "Talla" << "\t\tMejor caso" << "\t\tPeor caso" << endl;    
   cout << "-----\t\t----------\t\t---------"<<endl;
   int talla[6]={4000, 12000, 36000, 108000, 324000, 972000};
   int repeticiones=10000;
   int i, j;
   for (i=0;i<6;i++){
       v.resize (talla[i],0);
       ini=clock();
       for (j=0;j<=repeticiones-1;j++){
           Secuencial (v,0,talla[i]);
           }
           fin=clock();
       mejor=(fin-ini)*1000/CLOCKS_PER_SEC/repeticiones;
       ini=clock();
       for (j=0;j<=repeticiones-1;j++){
           Secuencial (v,1,talla[i]);
           }
           fin=clock();
       peor=(fin-ini)*1000/CLOCKS_PER_SEC/repeticiones;
       cout << talla[i] << "\t\t" << mejor << "ms\t\t\t" << peor<<"ms" <<endl;
       }
}

En este caso tienes el mejor y peor caso, los tiempos de mejor caso serían más o menos lo que tardaría tu algoritmo, que es encontrar el valor en el primer lugar del array.

Algoritmo de la sucesión de Fibonacci (lo llamo rayuela porque es un juego infantil, aunque es el mismo algoritmo).
En este algoritmo si se ven tiempos reales, al tratarse de una función recursiva MUY poco eficiente.

Código (cpp) [Seleccionar] Expandir


#include <time.h>
#include <iostream>

using namespace std;

int Rayuela_Recursiva(int);
int main(){
   
   int n=4, i, j, repeticiones=1;
   int talla[4]={10, 20, 30, 40};
   float ini, fin, tiempo;
   cout<<" Talla\t\t\tTiempo\n";
   cout<<" -----\t\t\t---------\n";
   for(i=0;i<n;i++){
           ini=clock();
           for(j=1;j<=repeticiones;j++)
                   Rayuela_Recursiva(talla[i]);
           fin=clock();
           tiempo=((fin-ini)/repeticiones)/CLOCKS_PER_SEC;
           cout<<"  "<<talla[i]<<"\t\t\t"<<"  "<<tiempo<<" s\n\n";
   }
return 0;
}

//Orden de complejidad O(2^n)
int Rayuela_Recursiva(int n){
   if(n==1||n==2) return n;
   else return Rayuela_Recursiva(n-1)+ Rayuela_Recursiva(n-2);
}


El mismo algoritmo, pero con un orden de complejidad lineal.

Código (cpp) [Seleccionar] Expandir


#include <time.h>
#include <iostream>

using namespace std;

//Orden de complejidad O(n)
int Rayuela_Iterativa (int n){
int a=1, b=2;
for (int i=0;i<n-2;i++){
b=a+b;
a=a-b;
}
return b;
}

int main(){
   
   int n=6, i, j, repeticiones=10000;
   int talla[6]={4000, 12000, 36000, 108000, 324000, 972000};
   float ini, fin, tiempo;
   cout<<" Talla\t\t\tTiempo\n";
   cout<<" -----\t\t\t---------\n";
   for(i=0;i<n;i++){
           ini=clock();
           for(j=1;j<=repeticiones;j++)
                   Rayuela_Iterativa(talla[i]);
           fin=clock();
           tiempo=(((fin-ini)*1000/repeticiones)/CLOCKS_PER_SEC);
           cout<<"  "<<talla[i]<<"\t\t\t"<<"  "<<tiempo<<" ms\n\n";
   }
return 0;
}


Espero que te sirva de algo este tocho xd