Mensajes

[encapsulamiento]

¿donde se aloja el código de las funciones que se van creando?

Antes o después del código del progama.

Cuando se llama a una función, lo que se hace es guardar la dirreción actual y dar un "salto" hacia la dirreción donde está el código de la función, cuando termina vuelve a dar otro salto hacia la dirreción anterior.

Otro tema aparte, son las funciones inline de C++. Son funciones muy cortas y que van precedidas con el modificador "inline", lo que hace el compilador ahí es copiar y pegar el código en todas las llamadas que haya. Así gana un poquito de eficiencia ya que no hay que hacer ningún salto ni nada.

En C++ 11, ¿las funciones lambda se alojan en algún sitio distinto de las funciones normales?

Normalmente es una función normal y corriente.

Investigando por ahí, he leído que hay que intentar declarar static todas las funciones locales. ¿Se refiere a las funciones que están en el main? ¿Quá pasa con las funciones static, van a zona de memoria distinta de las no static?

Static sirve para que esa función no sea accesible desde fuera de ese fichero. Se usa en programas multi-archivo.

Más que optimización será por encapsulamiento, aunque no descarto que el compilador pueda hacer alguna optimización (más restricciones, significa mayor libertad para optimizar).

En las funciones que se encuentran en una clase, el static tiene una función totalmente diferente. No confundir

PD. Me interesa mucho saber directrices para optimizar al máximo el rendimiento del programa, como saber que hay que hacer las mínimas comparaciones posibles.
Agradeceré cualquier link con información, y como siempre, si es en español, mas todavía.

Saludos.

Los compiladores de hoy en día son muy buenos, y algunas cosas ya las hace si activas el "modo optimización" en las opciones del compilador.

Lo que más se nota es en usar un algoritmo eficiente o poco eficiente.

Una busqueda secuencial en una lista de 1.000.000 elementos, necesitas hacer 1.000.000 iteraciones (como máximo) para encontrar un determinado.

Una busqueda binaria no pasa de 20 iteraciones. Y en el caso de ser palabras de un diccionario, podrías usar un algoritmo de prefijo y encontrar una palabra de 4 letras en 4 iteraciones.

Pasar de 1.000.000 de iteraciones a 4 teraciones es una brutalidad.

Por si sirve, dejo algunas explicaciones que ya hize en el pasado:
http://foro.elhacker.net/programacion_cc/duda_memoria_dinamica_en_c-t391783.0.html
http://foro.elhacker.net/programacion_cc/se_puede_hacer_esto_porque-t389950.0.html (quinto mensaje)

En cuanto a la velocidad, lo más rápido son las variables register. La diferencia entre stack y heap es inapreciable para cualquiera, hay miles de cosas que podrías optimizar antes de eso (las comparaciones, cuantas menos mejor).

Puedes crear una cabecera para cada registro donde te indique el tamaño real del registro, es decir, que sea una estructura con un campo donde te de el tamaño en bytes del registro real y así puedes ir leyendo hasta almacenar todos los registros en un arreglo dinámico.

Creo que es de las soluciones más eficientes.

[modificando]

El problema que veo ahí es:

Código (cpp) [Seleccionar] Expandir

x = (i+0.5)*step;
factores[i] = 4.0/(1.0+x*x);

Mientras un hilo está modificando la variable x, mientras otros hilos lo están usando. Si tienes suerte y se sincronizan bien pues te sale, pero como modifiques esa variable x mientras lo está usando el otro hilo... O te sale mal el resultado o en algún caso extremo tu progama podría hacer un abort.

Puedes ponerte un mutex para un acceso sincronizado pero, creo que sería más eficiente evitar variables globales que puedan dar colisión. He aquí mi propuesta:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <pthread.h>

double factores [1000],step;

void *calcularsum (void *argument)
{
   int i = *((int*) argument);
   double x = (i+0.5)*step;
   factores[i] = 4.0/(1.0+x*x);
   free(argument);
}

int main (int argc, char *argv[])
{
   int* P;
   int N,i;
   double totalsum,pi;

   if (argc != 2)
   {
       printf("Se ha de introducir un valor. Ejemplo: ./pi 10\n");
   }
   else
   {
       N=atoi(argv[1]);
       step = 1.0/N;
       pthread_t h[N];

       for (i=0; i<N; i++)
       {
           P = (int*)malloc(sizeof(int));
           *P = i;
           pthread_create(&h[i] , NULL , calcularsum ,P);

       }
       for (i=0; i<N; i++)
       {
           pthread_join(h[i], NULL);
           totalsum = factores[i] + totalsum;
           printf("%f\n",totalsum);
       }
       pi = totalsum * step;
       printf("%.10f\n", pi);
   }
   return 0;
}

No tengo linux a mano ahora, pero debería funcionar.

A mi esa página me suena, creo que ya se posteó en el foro y es una doble cuenta

Ahora, si yo fuera el profesor no pondría un ejercicio así. Creo que es mejor que hagan todo eso desde cero, les da más autosuficiencia y con su propio código es más fácil que se orienten.

Me he levantado, muy de madrugada, y estoy "pijito".

Esta vez te sobra en la frase lo de "pero menor que 3 mil millones". Es suficiente que sea mayor de 2.247.483.647, y digo bien mayor que no igual, para que se produzca desbordamiento.

La única forma de detectar el desbordamiento es ver si sale negativo (ya que vuelve al valor mínimo). Si le ponemos un número muy grande, es posible que el número llege a los positivos de nuevo.

[no cabe]

Efectivamente, era no cabe

Qué pasa si el número ingresado es 2.247.483.648 tampoco cabe.-

Eso ya lo tengo verificado, mira el último punto.

Si es mayor de 2.247.483.648 pero menor que 3 mil millones, entonces al pasarlo a entero desbordará y se quedará negativo.

Los enteros (con signo) tiene el valor máximo de 2.147.483.648

Por lo que el algoritmo sería:

- Si el numero tiene mas de 10 cifras, entonces no cabe.
- Si el numero tiene menos de 10 cifras, entonces cabe.
- Si el número tiene 10 cifras y la primera cifra es 3 o más, entonces cabe.
- Transforma el número, si es negativo entonces no cabe.

Por cierto para quepa un entero el array de char debe ser de 11 caracteres al menos.

¿Y porque vas a tener más cuidado? El compilador tarda menos de 1 segundo en revisar sintácticamente un archivo xD. El mismo Codeblocks te manda directamente a la línea donde esté el error (y hasta te la marca en rojo si no mal recuerdo).

Puedes hacerlo incluso más rápido activando la opción de "dejar de compilar tras el primer error".

Lo primero no está.

Lo segundo si se puede como ha dicho vangodp, también puedes crearte plantillas de proyecto.