Foro de elhacker.net

Hola....

Alguien sabe cual es la dimensión que soporta un arreglo en C??

Me dijeron que intentara hacer un programa para probrarlo pero no se me ocurre nada, alguien me podria ayudar, porfa??

¿Has leido algo de arreglos en C?

Si, pero soy nuevo en esto de programar...

Lei algo que soportaba a lo mas doce, debido a la memoria del compilador o algo asi, pero no se me ocurre como hacwr el programa....

Leìste muy mal.

En verdad lei eso y hasta el profe dijo que tenia entendido algo asi, por ello dejo el programa pero no entiendo como hacerlo, ya que yo tenia entendido desde antes que soportaba "n", no lo sé por ello pido ayuda, por fa!!

No sé la longitud, pero sí sé que son muchisimos los elementos que puede tener...

int arreglo[10000];
unsigned i;
for(i = 0; i < 10000; i++)
arreglo[i] = i;

O puedes crear los elementos dinámicamente...

Y dile a tu profesor que no sabe absolutamente nada. Mi recomendación es que vayas al post con chincheta sobre papers y libros, los bajes y leas sobre arreglos.

2ª vez que doy este mismo link, en pocos días:

http://www.elrincondelc.com/cursoc/cursoc10.html

Gracias, te entiendo por que yo también me quede de ¬¬...
pero que me recomiendan hacer, necesito un programa que me de la dimension exacta... y no se que hacer, se me hace un poco absurdo también.

En caso de la información que me das, la tengo presente por ello es que se me ocurrio pedir ayuda, ya que como dije hace rato se me hace un poco absurdo

Para hacer la práctica que tu quieres hacer no es necesario saber NADA de arrays, pero si que tienes que leer mucho sobre ellos, porque no tienes demasiado idea...
para saber la dimension de un array basta con hacer:

sizeof(array)/sizeof(tipo_array)

Te recomiendo que te metas en está web: http://c.conclase.net (http://c.conclase.net)

El_Java, su codigo no és correcto para cualquier arreglo que fue recibido como argumento de una función.

El arreglo decae para un puntero para su primer elemento.

Gracias por responder... pero la verdad sigo en las mismas... y ya me desepere... :-(

no a problema, hace un bucle que debe crear un arreglo en cada iterácion con tamaño 'i'. Cuando el 'malloc' devuelven NULL, esto és su limite.

Buena Suerte.

Me lo podrias explicar mejor... es que la verdad que no entiendo muy bien... pero con iteración??

Entiendo que tu quieres saber cuál és el tamaño máximo de un arreglo:


Yo no puede testar eso ahora.

agradezco tu ayuda.. en verdad... ahora tratare de entender que me dijiste  jijij... porque siento que esas son palabras mayores para el nivel  que tengo, pero gracias

El tamaño de un char siempre es 1. No hay necesidad del sizeof

No me gusta de números mágicos.
Muchas personas consideran usar "sizeof" una buena práctica.
Otros, creen que es confuso.

Leo Gutiérrez se refiere al uso de sizeof en esta linea:

char * arreglo = malloc(sizeof(char) * i);

Todo compilador que cumpla con el estándar de C debe evaluar "sizeof(char)" resultando en 1 y la multiplicación por este no tiene sentido ya que no afecta el resultado. Por ello se puede abreviar a:

char * arreglo = malloc(i);

En cuanto al tamaño máximo que puede tener un array este depende del compilador utilizado. Ello porque el estándar del lenguaje permite indicar el numero de elementos en un array mediante una expresión constante de tipo entero (cualquier tipo, por ejemplo "int" o "unsigned long") mayor que cero.

Lo que debe hacer el OP (el usuario Principios en C) es revisar la documentación de su compilador.

Un saludo

rir3760, lo sé, pero, en mi opinión es mas claro y más uniforme usar sizeof().

Ejemplo:

ya que sizeof(type) es una expresión completa en tiempo de compilación no afectas el tiempo de ejecucíon.

Muchas personas no gustam Java no tener "sizeof" por eso. C# tienes.


Aun teniendo en cuenta sus tipos tienen tamaño fijo (No estoy seguro si he escrito bien)

La verdad no se cual es el tamaño pero puedes hacer esto como te dijo LearningSpanishProgrammer hacer un while hasta que malloc() te devuelva NULL:

#include <stdio.h>
#include <stdlib.h>
 
int main(){
	char * arreglo;
	unsigned long long i = 1;
	do{
		arreglo = (char*)malloc(i);
		free(arreglo);
		i++;
	}while(arreglo != NULL);
 
	printf("breakpoint\n");  // Hacer breakpoint aqui
 
	return 0;
}
 

Yo probé esto y la verdad nunca salio del ciclo así que el tamaño debe ser MUY grande.

Nunca sale del ciclo por que siempre liberas la memoria.

Calcular el tamaño maximo de un array es medio estupido, nunca va a ser el mismo por una razon principal, el sistema rara vez va a tener la misma cantidad exacta de bytes libres, en todo caso en windows x86 (ni idea de linux) cuando llegues al limite de 2GB (>2GB si usas LAA (http://msdn.microsoft.com/en-us/library/wz223b1z%28v=VS.100%29.aspx)) por proceso te empezara a retornar NULL malloc.

En resumen, el tamaño maximo de un array/arreglo en C/C++ y diria que la gran mayoria de lenguajes de programacion esta limitado por la cantidad de memoria que tienes libre en el PC.

*ignore I made a mistake*

No. La variable "arreglo" contiene la ultima direccion retornada por malloc, la liberacion de memoria en la siguiente sentencia no afecta la condicion del bucle.

Si piensan ejecutar un bucle asi seria mejor cambiar el incremento a 1 KB o 1 MB.

Un saludo

Si que afecta, fijate mejor xD

El bucle acabara cuando el sistema se quede sin memoria y retorne NULL, eso nunca pasara por que hace free a la memoria que reserva.

No. Las llamadas anteriores no importan porque la intención no es realizar un proceso acumulativo.

Si se llama a "malloc" y esta falla su valor (NULL) se almacenara en la variable "arreglo" y eso causara la salida del bucle.

Un saludo

La intencion ES hacer un proceso acumulativo, ese es el objetivo del programa, calcular cual es el tamaño maximo de un array antes de que el sistema se quede sin memoria, el tema es que la intencion se ve inutilizada por el hecho de que desues del malloc hace un free, lo cual hace que nunca salga del bucle, descomenta el free y veras como esa accion si afecta al bucle, no instantaneamente, pero si cuando el sistema se quede sin memoria y en la siguiente iteracion malloc retorne NULL

Por lo visto tenemos una confusión, a ver si ahora me explico mejor.

Cuando indique que el proceso no es acumulativo me refería a la llamada a "malloc", no al incremento del contador "i".

Cuando se reserva memoria la variable "arreglo" sirve como bandera para saber si la reserva fue exitosa o no. Después de ello se libera pero eso no importa porque basta con revisar el valor de esa variable para conocer si funciono (diferente de NULL) o no (NULL).

Si por curiosidad se desea conocer si es posible realizar la máxima (en teoría) reserva de memoria basta con:

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{
   size_t max = -1;
   char *p;
 
   p = malloc(max);
   free(p);
 
   if (p)
      puts("OK");
   else
      puts("Error");
 
   return EXIT_SUCCESS;
}

El programa anterior de naderST realiza (poco mas o poco menos) lo mismo: acercarse al punto donde la reserva de memoria falle.

Un saludo

Cierto, my bad, no se por que veia un 1 en donde es una i (malloc), no dormir hace estragos XD