Mensajes

Gracias por las respuestas.

Gracias de nuevo por la respuesta, lo tengo mucho mas claro. Aunque estoy un poco decepcionado porque pensaba que se podía mejorar el rendimiento del programa usando stack o heap según convenga.

Ahora me asalta otra duda, ¿donde se aloja el código de las funciones que se van creando? En C++ 11, ¿las funciones lambda se alojan en algún sitio distinto de las funciones normales?
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?

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.

Muchas gracias a todos por la info.

Si encuentro algo más de interés lo añadiré a este mismo post.

Hola de nuevo, gracias por la respuesta.

Por mi parte he encontrado esta info en español:

link (tiene espacios al final, pero aun asi copiar todo seguido en el navegador):
http://www.zator.com/Cpp/E1_3_2.htm#La pila o stack

Particularmente esta parte:
Los movimientos en el stack son generalmente rápidos, a veces basta una simple instrucción del procesador para almacenar o borrar algo en la pila.  Los objetos colocados en ella se asocian a una duración automática .  El término se refiere a que es el compilador el que determina cuando se destruyen.  El lenguaje C++ se caracteriza por hacer un uso extensivo de la pila (muchos objetos son "automáticos" por defecto) y el mecanismo de invocación de funciones se basa en su utilización.  Decimos que C++ es un lenguaje orientado a la pila.

La verdad es que me gustaría mucho tener MUY claro las diferencias entre heap y stack, y como sacarles provecho.
Si alguien lo puede explicar se lo agradeceré enormemente.
Aún así, cualquier link, info etc. la agradeceré también (si es en españo, más)

Muchas gracias.

Hola a todos.

He estado leyendo acerca del modelo de memoria de C++, para saber bien como funciona el lenguaje y sacarle mas rendimiento a los programas.
http://www.zator.com/Cpp/E5_1_5.htm

Lo mas importante que he entendido hasta ahora, es que las variables locales automáticas van a la pila(stack) y el resto al montón(heap). La pila es manejada directamente por la UCP, ¿ésto implica mas velocidad? ¿Son realmente los movimientos en la pila considerablemente mas rápidos que en el montón?

Dicho esto, he leído que al declarar variables automáticas estas son creadas en la pila o en un "registro". ¿Ese "registro" es un registro de procesador?

Si tengo una clase "A" creada por mí con un constructor sin params., si hago:

Código [Seleccionar] Expandir


A a();
A *b=new A();
...


¿Los accesos al objeto 'a' serán mas rápidos que los accesos al objeto 'b'?

Muchas gracias.

He creado un fragmento de código de ejemplo con lo que me gustaría hacer

Código [Seleccionar] Expandir


public static void main(String[] args) {
final Scanner sc=new Scanner(System.in);
Thread th1=new Thread(new Runnable(){
private Scanner sct=sc;
public void run(){
try {
String s="a";
while(! s.equals("")){
System.out.println("escribe: ");
s=sct.nextLine();
System.out.println(s);
}
} catch (Exception e) {
// TODO Auto-generated catch block
}
}
});
th1.start();

try {
System.out.println("duermo para dar tiempo al hilo hijo a hacer el"
+ "sc.nextLine()");
Thread.currentThread().sleep(2000);
//terminar ejecución del hilo B !!!¿¿¿Como?????¡¡¡¡
} catch (InterruptedException e) {
e.printStackTrace();
}
}


Como véis le he intentado pasar el Scanner desde el main del hilo A al hilo B , para cerrarlo posteriormente, pero tampoco eso se puede.

Hola a todos, planteo mi problema.

Tengo un hilo A. Desde éste creo otro hilo B (hijo de A por tanto).
El hilo B lee datos de teclado, por tanto está bloqueado esperando a que alguien teclee algo. (*1)
Entonces el hilo A quiere terminar la ejecución del hilo B (estando este bloqueado, esperando a que alguien teclee)

¿Como puede A terminar la ejecución de B?

Muchas gracias.

(*1) Es decir, está en el punto "String s=sc.nestLine()" con sc=new Scanner(System.in)

Solución:

En la parte en la que se especifica sizeof() en memcpy, hay que multiplicarlo por la cantidad de chars (en este caso) que se quieren copiar.

Esto es porque si tienes un vector de 20 caracteres 'char c[20]', sizeof(c) devuelve 4 (tamaño del puntero a char, que es lo que es en realidad el vector) no devuelve los 20 chars que contiene.

Saludos.

He estado haciendo mas pruebas y sustituyendo la parte del memcpy() por un bucle for todo funciona bien.

Código [Seleccionar] Expandir


//Antes:
            //vuelvo a leer
            ifs.getline(line, BUFFER_S,'\n');
            //salvo la direcc. de memoria de dev
            aux=dev;
            //redimensiono dev
            dev=new char*[i+2];
            //le paso los datos que tenia hasta ahora
            memcpy(dev,aux,sizeof(aux));
            //le asigno la nueva linea
            dev[i]=new char[BUFFER_S];
            strcpy(dev[i],line);
            //libero la memoria a la que apuntaba aux
            delete[] aux;

//Después:
            //vuelvo a leer
            ifs.getline(line, BUFFER_S,'\n');
            //salvo la direcc. de memoria de dev
            aux=dev;
            //redimensiono dev
            dev=new char*[i+2];
            //le paso los datos que tenia hasta ahora
            for(int j=0;j<i;j++){
                dev[j]=aux[j];
            }
            //le asigno la nueva linea
            dev[i]=new char[BUFFER_S];
            strcpy(dev[i],line);
            //libero la memoria a la que apuntaba aux
            delete[] aux;


Algo pasa con el memcpy(), ¿Qué es?

Saludos

Cuando utilizas el operador new este reserva un bloque de memoria del tamaño apropiado, nada mas. El problema es que tu esperas que copie el contenido del bloque anterior y eso no lo hará el operador. Debes hacerlo manualmente reservando un nuevo bloque de memoria, copiando en el las direcciones de memoria y finalmente liberando el bloque original (y utilizando a partir de ese momento el nuevo bloque).

Sí, lo sé, de hecho en el código que he escrito lo hago explicitamente con una variable auxiliar y memcpy(), por eso no entiendo que pasa.

Ya que el lenguaje es C++ es mejor utilizar un vector de objetos de tipo string para almacenar todas las lineas del archivo, con ello te liberas del manejo de memoria.

Cierto, pero esto no me lo permiten hacer usando la STL, tengo que manejar la memoria directamente. Además es algo que quiero entender como funciona.