¿Es la asignación de memoria dinámica malloc? -- ampo con malloc campo con language-lawyer campo con dynamic-memory-allocation camp Relacionados El problema

Is malloc dynamic memory allocation?


5
vote

problema

Español

El instructor le dijo que p = (int*)malloc(5 * sizeof(int)) es no la asignación de memoria dinámica y que p=(int*)malloc(n * sizeof(int))6 es la asignación de memoria dinámica.

El instructor estaba hablando de estructuras de datos básicas y era enseñanza de matrices. Él nos había dicho la forma tradicional de crear matrices usando la sintaxis p=(int*)malloc(n * sizeof(int))7 , pero luego nos presentó con malloc.

Según él, ya que el tamaño de la memoria no cambia, no es dinámico, supongo.

De lo que pude reunir de Internet, malloc asigna memoria en tiempo de ejecución, y cuando la memoria se asigna en tiempo de ejecución, su asignación de memoria dinámica. Así que creo que ambas declaraciones p=(int*)malloc(n * sizeof(int))9 son asignaciones de memoria dinámica. ¿Hay algo malo con mi razonamiento?

Original en ingles

I was told by an instructor that p = (int*)malloc(5 * sizeof(int)) is NOT dynamic memory allocation and that p=(int*)malloc(n * sizeof(int)) is dynamic memory allocation.

The instructor was talking about basic data structures and was teaching arrays. He had told us the traditional way to create arrays using the int arr[100] syntax, but then he introduced us with malloc.

According to him as the memory size doesn't change it's not dynamic I guess.

From what I could gather from the internet, malloc assigns memory at runtime, and when memory is assigned at runtime its dynamic memory allocation. So I think both the malloc statements are dynamic memory allocations. Is there something wrong with my reasoning?

           
       
       

Lista de respuestas

7
 
vote
vote
La mejor respuesta
 

Por lo general, nos referimos a las llamadas a @JsonIgnore0 como Dynamic Asignación, irregaldless si está usando una variable o constante. Incluso el Página de hombre para @JsonIgnore1111 lo llama así:

MALLOC, GRATUITO, CALLOC, REALLOC - MAYOR Y MEMORIA DINÁMICA GRATUITA

para que sus instructores afirman:

El instructor estaba hablando de estructuras de datos básicas y era enseñanza de matrices. Nos había dicho la forma tradicional de crear matrices utilizando la sintaxis INTR [100], pero luego nos presentó con malloc.

Según él, ya que el tamaño de la memoria no cambia, no es dinámico, supongo.

Bueno, en cierto sentido, tiene un punto si se parece estrictamente a lo que significa "dinámico" de una manera más general. En este momento, tenemos una convención que llama a todos los @JsonIgnore2 asignación dinámica. Esta convención podría haber sido la forma en que su maestro afirma sin ningún problema. Pero no lo es.

Además, de acuerdo con su razonamiento de maestros, utilizando VLA: S (matriz de longitud variable) o @JsonIgnore3 con una variable se considerará una asignación dinámica, pero no lo es. A VLA se puede declarar así: @JsonIgnore4 , O ES @JsonIgnore5 EQUIVALENTE: @JsonIgnore66666666666666666666616

Así que incluso si usted podría argumentar que su maestro tiene un punto, solo causaría confusión ya que va en contra de la Convención.

Además, la cosa más dinámica de usar @JsonIgnore7 es que la asignación se puede cambiar de tamaño más adelante. No puedes hacer eso con matrices, ni siquiera Vla: s. Y no puede hacerlo a la memoria que ha asignado con @JsonIgnore8 .

Pero como sidenote, hago cuestionar la competencia de sus maestros si le enseñan a escribir

  @JsonIgnore9  

en lugar de

  @JsonView0 
  1. El reparto no es necesario y solo agrega el desorden
  2. usando @JsonView1
en lugar de @JsonView2 es más seguro

Relacionado: ¿Misé el resultado de malloc?

 

Usually, we do refer to calls to malloc as dynamic allocation, irregardless if you're using a variable or constant. Even the man page for malloc calls it like that:

malloc, free, calloc, realloc - allocate and free dynamic memory

So for your instructors claim:

The instructor was talking about basic data structures and was teaching arrays. He had told us the traditional way to create arrays using the int arr[100] syntax, but then he introduced us with malloc.

According to him as the memory size doesn't change it's not dynamic I guess.

Well, in some sense he has a point if you look strictly at what "dynamic" means in a more general way. Right now we have a convention that calls all malloc dynamic allocation. This convention could have been the way your teacher claims without any problems. But it is not.

Furthermore, according to your teachers reasoning, using VLA:s (variable length array) or alloca with a variable would be considered dynamic allocation, but it is not. A VLA can be declared like this: int arr[n], or it's alloca equivalent: int *arr = alloca(n*sizeof(*arr)).

So even if you could argue that your teacher has a point, it would only cause confusion since it goes against the convention.

Also, the most dynamic thing about using malloc is that the allocation can be resized later. You cannot do that with arrays, not even VLA:s. And you cannot do it to memory you have allocated with alloca.

But as a sidenote, I do question your teachers competence if they teach you to write

p = (int*)malloc(n * sizeof(int))  

instead of

p = malloc(n * sizeof(*p)) 
  1. The cast is not necessary and just adds clutter
  2. Using sizeof(*p) instead of sizeof(int) is safer

Related: Do I cast the result of malloc?

 
 
         
         
5
 
vote

El estándar C no define el término "asignación de memoria dinámica". Por lo tanto, no podemos tomar el estándar C y buscar qué es la asignación dinámica de la memoria.

La norma C conversa sobre "Funciones de administración de memoria" (es decir, alined_Alloc, Calloc, Malloc, RealLOC y GRATUITO). Cuando se usan estas funciones, se llama comúnmente la asignación de memoria dinámica pero, solo para repetir, no es un término de la norma.

Las conversaciones estándar sobre "Tiempo de vida de los objetos". Se dice que se dice un objeto creado usando una de las funciones de administración de memoria anterior que tiene "duración de almacenamiento asignada" (lo que significa que existe hasta que su código lo libera).

Las dos líneas de códigos en la pregunta hacen que p apunte a un objeto que tiene "Duración de almacenamiento asignada".

Mi conjetura es que usted ha malinterpretado a su maestro, es decir, incendió mal lo que se entiende por "dinámico". Tal vez su maestro habló sobre el tamaño del objeto asignado, es decir.:

  p = (int*)malloc(5 * sizeof(int));   // Here the size is static - always 5 ints  p = (int*)malloc(n * sizeof(int));   // Here the size is dynamic (aka depends on n)   

Nota: el elenco, es decir, (int*) , no se necesita en c.

 

The C standard does not define the term "dynamic memory allocation". So we can't take the C standard and lookup what dynamic memory allocation is.

The C standard talks about "Memory management functions" (i.e. aligned_alloc, calloc, malloc, realloc and free). When these functions are used it's commonly called dynamic memory allocation but - just to repeat - it's not a term from the standard.

The standard talks about "life time of objects". An objected created using one of the above memory management function is said to have "allocated storage duration" (which means that it exists until your code frees it).

Both code lines in the question makes p point to an object that has "allocated storage duration".

My guess is that you have misunderstood your teacher, i.e. misunderstood what was meant by "dynamic". Perhaps your teacher talked about the size of the allocated object, i.e.:

p = (int*)malloc(5 * sizeof(int));   // Here the size is static - always 5 ints  p = (int*)malloc(n * sizeof(int));   // Here the size is dynamic (aka depends on n) 

Note: The cast, i.e. (int*), is not needed in C.

 
 
   
   
4
 
vote

O bien está malinterpretando el punto que su instructor estaba tratando de hacer, o su instructor estaba haciendo su punto muy, muy mal (que, francamente, no es infrecuente, especialmente cuando se trata de enseñar c).

Los dos llamamientos malloc en su pregunta son la asignación de memoria dinámica. La única diferencia es que la primera forma asigna una cantidad conocida y fija de memoria cada vez que se ejecuta, mientras que el segundo puede asignar una cantidad diferente cada vez que se ejecute. Eso no hace la primera forma, no la asignación dinámica.

La memoria en ambos casos puede ser redimensionada con una llamada a realloc .

y como una nota estilística, no tiene que fundir el resultado de malloc en C 1 . Es mucho menos apático para escribir

  p = malloc( 5 * sizeof *p );    

o

  p = malloc( n * sizeof *p );   

sizeof *p es el mismo que sizeof (int) (Suponiendo p = (int*)malloc(5 * sizeof(int)); // Here the size is static - always 5 ints p = (int*)malloc(n * sizeof(int)); // Here the size is dynamic (aka depends on n) 0 Se declaró como p = (int*)malloc(5 * sizeof(int)); // Here the size is static - always 5 ints p = (int*)malloc(n * sizeof(int)); // Here the size is dynamic (aka depends on n) 1111 ). Esto facilita el mantenimiento, ya que no tiene que repetir información de tipo varias veces.


  1. Eso no es el caso en C ++, pero si está escribiendo C ++, no debería estar usando p = (int*)malloc(5 * sizeof(int)); // Here the size is static - always 5 ints p = (int*)malloc(n * sizeof(int)); // Here the size is dynamic (aka depends on n) 2 de todos modos.
 

Either youxe2x80x99re misunderstanding the point your instructor was trying to make, or your instructor was making his point very, very badly (which, frankly, is not uncommon, especially when it comes to teaching C).

Both of the malloc calls in your question are dynamic memory allocation. The only difference is that the first form allocates a known, fixed amount of memory every time it is executed, whereas the second can allocate a different amount each time itxe2x80x99s executed. That doesnxe2x80x99t make the first form not dynamic allocation.

The memory in both cases can be resized with a call to realloc.

And as a stylistic note, you donxe2x80x99t have to cast the result of malloc in C1. Itxe2x80x99s much less eye-stabby to write

p = malloc( 5 * sizeof *p );  

or

p = malloc( n * sizeof *p ); 

sizeof *p is the same as sizeof (int) (assuming p was declared as int *p). This makes maintenance easier, since you donxe2x80x99t have to repeat type information multiple times.


  1. Thatxe2x80x99s not the case in C++, but if youxe2x80x99re writing C++ you shouldnxe2x80x99t be using malloc anyway.
 
 
3
 
vote

Me dijeron un instructor que p = (int*)malloc(5 * sizeof(int)); // Here the size is static - always 5 ints p = (int*)malloc(n * sizeof(int)); // Here the size is dynamic (aka depends on n) 3 es no la asignación de memoria dinámica y que p = (int*)malloc(5 * sizeof(int)); // Here the size is static - always 5 ints p = (int*)malloc(n * sizeof(int)); // Here the size is dynamic (aka depends on n) 4 es la asignación de memoria dinámica

Este es un tema basado en opinión en el sentido de que no hay obligación de referirse a él como uno u otro, esto se basa en gran medida en la convención. Dicho esto, no estoy de acuerdo en absoluto con la opinión de que existe cierta corrección a la declaración, incluso asumiendo que la referencia puede ser del tamaño del bloque de memoria que esté dependiendo de un valor constante.

Ambas expresiones solo deben calificarse como asignaciones de memoria dinámica, ya sea si utiliza un valor constante o variable. Declarando lo contrario solo se puede calificar como incorrecto, en mi opinión.

Todas las asignaciones de bloques de memoria aún se pueden cambiar más adelante, en un entorno de tiempo de ejecución, por lo tanto, son dinámicos, mientras que en una declaración de matriz, es decir, 99887776615 La memoria asignada es fija, no se puede cambiar, por lo tanto, No es dinámico.

Hay, sin embargo, las diferencias en el uso de una constante o una variable, para el obvio, pudiendo tener un valor a la variable que determinará el tamaño del bloque de memoria en tiempo de ejecución. Y como @ Cmaster-ReinstaTatemonica señalada con mucha precisión , el uso de una constante como un determinante de tamaño para el bloque de memoria permite la optimización del compilador de p = (int*)malloc(5 * sizeof(int)); // Here the size is static - always 5 ints p = (int*)malloc(n * sizeof(int)); // Here the size is dynamic (aka depends on n) 6 en ciertas circunstancias, que es significativa, dado que puede ser una función costosa.

Aparte de eso, las afirmaciones son en gran medida similares. En ambos casos, puede cambiar el tamaño de los bloques de memoria en tiempo de ejecución después de la asignación.

Algunas buenas consideraciones con respecto al uso correcto de p = (int*)malloc(5 * sizeof(int)); // Here the size is static - always 5 ints p = (int*)malloc(n * sizeof(int)); // Here the size is dynamic (aka depends on n) 7 están hechas por @johnbode , i Recomiéndole encarecidamente que los siga, de hecho, toda la respuesta es muy buena y debe llamarse a la atención de su instructor si se siente cómodo con él, podrá aclarar el problema.

 

I was told by an instructor that p = (int*)malloc(5 * sizeof(int)); is NOT dynamic memory allocation and that p = (int*)malloc(n * sizeof(int)); is dynamic memory allocation

This is a somewhat opinion based issue in the sense that there is no obligation to refer to it as one or the other, this is largely based on convention. That said, I don't agree at all with the opinion that there is some correctness to the statement, even assuming the reference may be to the size of the memory block being deppendant on a constant value.

Both expressions should only be qualified as dynamic memory allocations either if you use a constant or a variable value. Stating otherwise can only be qualified as wrong, in my opinion.

Both memory block assignments can still be changed later on, in a runtime environment, they are therefore dynamic, whereas in an array declaration i.e.int arr[100] the assigned memory is fixed, it cannot be changed, thus it's not dynamic.

There are, however, differences in using a constant or a variable, for the obvious one, being able to assing a value to the variable that will determine the size of the memory block at runtime. And as @cmaster-reinstatemonica very accurately pointed out, using a constant as a size determinant for the memory block allows for compiler optimization of malloc in certain circumstances, which is meaningful given the fact that it can be an expensive function.

Other than that, the statements are largely similar. In both cases you can resize the memory blocks at runtime after the allocation.

Some good considerations regarding the correct usage of malloc are made by @JohnBode, I strongly recommend you follow them, in fact the entire answer is very good and should be called to the attention of your instructor if you feel comfortable with it, you'll be able to clarify the issue.

 
 
         
         

Relacionados problema

0  BOOLEAN ALBOOCO_ITEMS (ARTÍCULO DE ARTÍCULO * ARTÍCULOS, TAMAÑO_T HOWMANY) Función para asignar una matriz del elemento de estructura  ( Boolean allocate itemsstruct item items size t howmany function for allocat ) 
Recientemente, estoy aprendiendo C. Encontré una pregunta en Internet. La pregunta es: ¿Cuál es el problema con esta función en términos de asignación de m...

0  Error con el alcance de las variables  ( Error with scope of variables ) 
Actualmente estoy escribiendo un programa en C ++, que toma información de un archivo .txt y le asigna dinámicamente para ser referido más adelante. La inform...

6  No debería este código de código  ( Shouldnt this code crash ) 
~/.bundler/...6 Debido a quedarse sin espacio de memoria, no debería este código de código. He intentado imprimir el valor de P, que es la dirección de la...

1  C ++: ¡Eliminar objetos o eliminar miembros?  ( C delete object or delete members ) 
Me gustaría preguntar sobre la diferencia funcional; Tal vez solicite un escenario de ejemplo, donde debería elegir una de las opciones en el método principal...

1  ¿Cómo sabe C / C ++ cuánto tiempo es una matriz asignada dinámica?  ( How does c c know how long a dynamic allocated array is ) 
Esta pregunta me ha estado molestando por un tiempo. Si lo hago int* a = new int[n] , por ejemplo, sólo tengo un puntero que apunta al comienzo de la matri...

1  Error de asignación de memoria dinámica en FORTRAN2003 usando Lapack  ( Dynamic memory allocation error in fortran2003 using lapack ) 
Estoy luchando con el subroutine polynomial_fit(x_array, y_array, D) integer, intent(in) :: D real, intent(in), dimension(:) :: x_array, y_array ...

0  Función libre () no desatifique la memoria de un vector [duplicado]  ( Function free doesnt de allocate memory from a vector ) 
Esta pregunta ya tiene respuestas aquí : usando puntero después de libre () ...

0  Memoria asignada dinámicamente en la estructura en C  ( Dynamically allocated memory in structure in c ) 
Estoy tratando de crear dos listas, profesionales y contras y luego imprimirlos. Pero no puedo averiguar qué estoy haciendo mal. Intenté depurar el programa...

1  La función no puede encontrar la asignación de memoria fallida  ( Function cannot find failed memory allocation ) 
Función int load(const char *filename, int ***ptr, enum save_format_t format) debe cargar datos de un archivo de texto binario o (que se guarda el nombre ...

0  Lista asignada dinámicamente en C ++  ( Dynamically allocated list in c ) 
Hice un lindo genérico (i.e. plantilla) List clase para manejar listas en C ++. La razón de eso es que encontré el std::list Clase terriblemente feo para ...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos