¿Hay alguna limitación de longitud de matriz en C?

Estoy trabajando en un progtwig en C. Quiero inicializar una matriz que tiene una longitud de 1,000,000
Se comstack sin errores ni advertencias, pero en la ejecución, Windows envía una terminación de proceso.
Modifiqué mi código para que haya 4 matrices cada una con 500,000 enteros. Se comstack de nuevo sin error ni advertencia, pero el problema sigue existiendo.

Yo uso CodeBlox (comstackdor GCC, creo)

Aquí está mi código:

#include  #include  // Prototypes: int checkprime(int n); int main(){ int m=0; int A[500001]={2,2,0};//from k=1 to 500000 int B[500000]={0};//from k=500001 to 1000000 int C[500000]={0};//from k=1000001 to 1500000 int D[500000]={0};//from k=1500001 to 2000000 int n=3; int k=2; for(n=3;n<2000001;n +=2){ if(checkprime(n)){ if (k500000)&&(k1000000)&&(k1500000){ D[k-1500001]=n; k +=1;} }//end of if }//end for int i=0; for(i=1;i<500001;i++) { m=m+A[i]; } for(i=0;i<5000001;i++) { m=m+B[i]; } for(i=0;i<5000001;i++) { m=m+C[i]; } for(i=0;i<5000001;i++) { m=m+D[i]; } printf("answer is %d",m); return 0;//Successful end indicator }//end of main int checkprime(int n){ int m=sqrt(n); if (!(m%2)) { m=m+1; } int stop=0; int d=0; int isprime=1; while((m!=1)&&(stop==0)){ d=n%m; if (d==0){ stop=1; isprime=0; } m -=2; }//end of while return isprime; }//end of checkprime 

Limitar el tamaño máximo de stack controlado con el comando ulimit. El comstackdor puede (o no) establecer un límite más pequeño, pero no más grande que eso.
Para ver el límite actual (en kilobytes):

 ulimit -s 

Para eliminar el límite:

 ulimit -s unlimited 

Espero que tu enorme matriz inicializada sea estática o global. Si es una variable local, desbordaría la stack en tiempo de ejecución.

Creo que las versiones anteriores de GCC tenían un comportamiento subóptimo (quizás tiempo cuadrático) al inicializar una matriz.

También creo que el estándar C podría definir un tamaño de matriz mínimo (pequeño) que todos los comstackdores conformes deberían aceptar (hay un límite inferior para los tamaños de cadena, podría ser tan pequeño como 512).

IIRC, las versiones recientes de GCC mejoraron su comportamiento al inicializar matrices estáticas. Prueba con GCC 4.7

Con mi gcc-4.7.1 Debian / Sid puedo comstackr un archivo biga.c comenzando con

 int big[] = {2 , 3 , 5 , 7 , 11 , 13 , 

y terminando con

  399999937 , 399999947 , 399999949 , 399999959 , }; 

y conteniendo 23105402 líneas:

  % time gcc -c biga.c gcc -c biga.c 43.51s user 1.87s system 96% cpu 46.962 total % /usr/bin/time -v gcc -O2 -c biga.c Command being timed: "gcc -O2 -c biga.c" User time (seconds): 48.99 System time (seconds): 2.10 Percent of CPU this job got: 97% Elapsed (wall clock) time (h:mm:ss or m:ss): 0:52.59 Average shared text size (kbytes): 0 Average unshared data size (kbytes): 0 Average stack size (kbytes): 0 Average total size (kbytes): 0 Maximum resident set size (kbytes): 5157040 Average resident set size (kbytes): 0 Major (requiring I/O) page faults: 0 Minor (reclaiming a frame) page faults: 691666 Voluntary context switches: 25 Involuntary context switches: 5162 Swaps: 0 File system inputs: 32 File system outputs: 931512 Socket messages sent: 0 Socket messages received: 0 Signals delivered: 0 Page size (bytes): 4096 Exit status: 0 

Esto está en un escritorio i7 3770K con 16Gb de RAM.

Tener grandes arreglos como locales , incluso dentro de main es siempre una mala idea . O bien, asignarlos en un montón (por ejemplo, con calloc o malloc , luego free adecuadamente) o hacerlos globales o estáticos. El espacio para los datos locales en la stack de llamadas siempre es un recurso de miedo. Un marco de llamada típico (tamaño combinado de todas las variables locales) debe ser inferior a un kilobyte. Un marco de llamada más grande que un megabyte es casi siempre malo y no profesional.

Sí hay.

Las matrices locales se crean en la stack, y si su matriz es demasiado grande, la stack colisionará con otra cosa en la memoria y bloqueará el progtwig.