entero largo como índice de matriz en C da error de segmentación

Question

El siguiente código C da un error de segmentación:

#include <stdio.h>
#include <stdint.h>

int main(){
        uint32_t *a;
        uint32_t idx=1233245613;
        a[idx]=1233;
        return 0;
}

¿Cómo puedo usar uint32_t como índice de una matriz en C? ¿O cómo puedo usar una estructura tipo matriz que puede obtener uint32_t y números de 12 dígitos como índice?

Agradecería cualquier tipo de ayuda.

Answer 1

• La variable " a " es solo un puntero varaible.
• Una variable de puntero contiene la dirección de una ubicación de memoria.
• Debe apuntar a una ubicación de memoria que tenga el espacio que necesita ya asignado.

También está intentando indexar bastante lejos en la matriz. Es posible que no tenga suficiente memoria disponible para esto, así que asegúrese de verificar NULL.

#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>

int main(void){

        uint32_t *a;
        uint32_t idx=1233245613;

        //This allows you to index from 0 to 1233245613
        // don't try to index past that number
        a = malloc((idx+1) * sizeof *a);
        if(a == NULL)
        {
           printf("not enough memory");
           return 1;
        }


        a[idx]=1233;
        free(a);
        return 0;
}

Answer 2

Si desea usar un " número de 12 dígitos " como índice, eso implica que quieres necesitar más de mil millones de artículos. Dado que cada elemento es un uint32_t, eso implica que cada uno ocupa cuatro bytes de memoria. Por lo tanto, está buscando alrededor de 4 GB en total de memoria para esta matriz. Las matrices generalmente no se hacen tan grandes, por rendimiento y otras razones.

Si realmente necesita cada uno de esos mil millones de artículos, busque algoritmos respaldados por disco, tal vez Rojo -Black Trees , que son adecuados para implementar este tipo de matriz gigante.

Answer 3

Bueno, para empezar, debes asignar espacio a a.

Cuando se ejecuta ese código, señala un espacio en la memoria que probablemente no poseas.
Cuando intentas acceder a él (en realidad cuando intentas acceder a un + 1233245613) vas a un espacio en la memoria que definitivamente no tienes, y eso es un no-no y provocará un bloqueo.

#include <stdio.h>
#include <stdint.h>

int main(){
        uint32_t *a;
        uint32_t idx=1233245613;
        a = malloc(sizeof(unit32_t) * (idx+1));//+1 cause remember, arrays are 0-based
        if(a == NULL) 
        {
           printf("Array could not be allocated"); 
           return 1;
        }
        a[idx]=1233;
        free(a);//good practice to avoid memory leaks
        return 0;
}

Pero incluso eso no resuelve el problema de que está utilizando una matriz GIGANTE. Su configuración estándar (computadora de escritorio o incluso la mayoría de los servidores) se ahogará al tratar de asignar 4,6 GB de memoria. Entonces, a menos que lo haya tenido en cuenta, es probable que deba retroceder y repensar lo que está tratando de hacer y cómo.

Answer 4

Necesitas dos cosas:

• asigna memoria para la matriz a , algo así como uint32_t a [2000000000];
• compilar en una arquitectura de 64 bits que puede abordar más de 4 Gb de memoria.

Answer 5

Whoa. Eso está en mal estado.

OK. Dos problemas aquí. El primer problema es que declaró un puntero a entero, nunca lo apuntó a nada y luego trató de usarlo. Esto es simplemente un error. Lo más probable es que el puntero apunte a un lugar que ni siquiera es una memoria válida para su proceso (o NULL). En ese caso, cualquier intento de usarlo le dará una falla predeterminada, tal como lo hizo.

El segundo problema es el valor por el que intenta indexarlo. Incluso si hubiera asignado memoria para su puntero, dudo seriamente que pueda haberle asignado 4.8 Gigabytes. La mayoría de las computadoras no tienen cerca de tanta RAM, y certianly no tienen tanto en una porción contigua. Si intenta indexar más allá de la memoria que ha asignado a una matriz, es posible que suceda casi cualquier cosa, pero si pasa camino , lo más probable es que obtenga una segfault.

Answer 6

a es un puntero que apunta a nada determinado. Quieres una matriz

uint32_t a[42];

que crea una matriz de 42 enteros. Sin embargo, su acceso a él todavía causará problemas (comportamiento indefinido para ser exactos) ya que está muy fuera de los límites de esta o cualquier otra matriz sensible.