Es preferible usar memoria dinámica si no sabes a prior la cantidad de datos que vas a manejar, asi solo reservas memoria para los datos que realmente se usan.


Claro ejemplo si no sabes cuantos datos vana meter es preferible reservar memoria dinamicamente.

Si por el contrario usas, un numero fijo, no hay problema de usar un array estatico

Saludos!

Hola, gracias a ambos por las respuestas, muy esclarecedoras por cierto. -
Una cosita más, la memoria asignada a la pila y el montón es monitoreada por el SO, hay alguna manera con C saber cuanta memoria se le asigna a estas 2 areas de memoria de un determinado programa(cuantos bytes). -


No hay contradicciones en esta descripción, digo.



Saludos.

Lo que sucede es que usar encontrar un espacio en HEAP del tamaño indicado para evitar fragmentacion implica esfuerzo para el SO.

Pero eso no es el codigo generado.



Repito: eso es dependiente de la plataforma. Comparar el acceso a un elemento de un array para hablar de optimizacion no me parece lo mas idoneo ... pero igual como vemos no hay instrucciones especiales para acceder a la pila, son simples mov.


No, lo que se puede ver no es eso sino el codigo que genero un compilador A con una configuracion B para una plataforma C. Y obviamente ese codigo estaba muy poco optimizado, dudo muchisimo que un compilador moderno no pueda llegar a esto e incluso a algo mas veloz:

mov QWORD PTR [rbp-8], rax ;guardamos en la variable local array el resultado de malloc
mov DWORD PTR [rax + 0Ch], 3 ;escribimos en array[3]
mov eax, DWORD PTR [rax + 0Ch] ;leemos de array[3]

Igual no es una buena idea equiparar el numero de instrucciones a su velocidad de ejecucion, las instrucciones de 128 bits son mas largas para codificar y a la misma vez son mas rapidas para ejecutar.

PD. No se puede comparar el codigo optimizado ya que este codigo es tan trivial que al hacerlo el compilador directamente pone el numero 3 donde corresponda como parametro de printf.

---

Este si se puede comparar optimizado aunque sigue siendo trivial:

    #include <stdio.h>
 
    int main( void ){
        int array[5];
 
for (int x = 0; x < 5; ++x)
        array[x] = 5 - x;  
        printf("%i", array[3]);
 
        return 0;
    }

    #include <stdio.h>
    #include <stdlib.h>
 
    int main( void ){
        int *array = malloc(sizeof(int) * 5);
 
for (int x = 0; x < 5; ++x)
        array[x] = 5 - x;    
 
        printf("%i", array[3]);
 
        return 0;
    }

Compilador VC++ con configuracion para optimizar tamaño /O1 (y GS- para el ejemplo de la pila) en x64.

main:
  0000000000000000: 48 83 EC 48        sub         rsp,48h
  0000000000000004: 33 C0              xor         eax,eax
  0000000000000006: 8D 48 05           lea         ecx,[rax+5]
  0000000000000009: 89 4C 84 20        mov         dword ptr [rsp+rax*4+20h],ecx
  000000000000000D: 48 FF C0           inc         rax
  0000000000000010: FF C9              dec         ecx
  0000000000000012: 48 83 F8 05        cmp         rax,5
  0000000000000016: 7C F1              jl          0000000000000009
  0000000000000018: 8B 54 24 2C        mov         edx,dword ptr [rsp+2Ch]
  000000000000001C: 48 8D 0D 00 00 00 00 lea         rcx,[??_C@_02IKAHHCAI@?$CFi?$AA@]
  0000000000000023: E8 00 00 00 00     call        printf
  0000000000000028: 33 C0              xor         eax,eax
  000000000000002A: 48 83 C4 48        add         rsp,48h
  000000000000002E: C3                 ret

main:
  0000000000000000: 48 83 EC 28        sub         rsp,28h
  0000000000000004: B9 14 00 00 00     mov         ecx,14h
  0000000000000009: E8 00 00 00 00     call        malloc
  000000000000000E: 33 C9              xor         ecx,ecx
  0000000000000010: 8D 51 05           lea         edx,[rcx+5]
  0000000000000013: 89 14 88           mov         dword ptr [rax+rcx*4],edx
  0000000000000016: 48 FF C1           inc         rcx
  0000000000000019: FF CA              dec         edx
  000000000000001B: 48 83 F9 05        cmp         rcx,5
  000000000000001F: 7C F2              jl          0000000000000013
  0000000000000021: 8B 50 0C           mov         edx,dword ptr [rax+0Ch]
  0000000000000024: 48 8D 0D 00 00 00  00 lea         rcx,[??_C@_02IKAHHCAI@?$CFi?$AA@]
  000000000000002B: E8 00 00 00 00     call        printf
  0000000000000030: 33 C0              xor         eax,eax
  0000000000000032: 48 83 C4 28        add         rsp,28h
  0000000000000036: C3                 ret

Como podemos ver las instrucciones mov de la pila usan 4 bytes y las del monticulo 3

tienen diferentes propositos...

no puedes comparar

slds