如何处理 float *array

Question

I have array declared in something like this

first way

int size=256*10;
float *array=(float*)malloc(size * sizeof(float));
for(int i=0;i<2398;i++)
     data[i]=data[i]*900;

When I used this why in declaration my code run with out errors but

when I use the array as constant values like this :

2nd way

float array[]={120.0, 160.0, 255.0, 216.0, 255.0, 224.0, 0.0, 16.0, 
74.0, 70.0, 73.0, 70.0, 0.0, 1.0, 1.0};

I didn't get what was required from the code even if I took the array output in the first way and defined it as in 2nd way?!! I thought defining an array in the 2nd way is correct and equivalent to the first definition?! What is the correct way to declare an array that equivalent to the first way?

Answer 1

Both ways create valid arrays, and you can use them pretty much exchangeably if you pay attention to object life time. The differences are:

• malloc dynamically allocates memory which exists until the program explicitly calls free() on the address returned by malloc. One of the typical use cases is to allocate and initialize some storage in a function and let the function return the address. That's fine: The life time of objects in dynamically allocated memory (new, malloc) is independent of scope (eg, a function).

  By contrast, an array defined the second way exists until the variable goes out of scope. If it is a global variable it will exist until the program ends. If it is defined in a function it will only exist until the program returns from the function, or ends. That may be your problem here. Returning the address of a function-local object and using it outside that function is a not uncommon error. Newer compilers with sufficiently high warning levels should warn when they see such a mistake.

• The second array is an object with the number of elements indicated by the initializers, exactly. You can call sizeof(array) and get a large number, for example 60. The first "array", by contrast, is not an array at all: It is a pointer to the first element of an array. Calling sizeof() on that pointer returns the size of that pointer, typically 4 or 8, no matter how much memory is allocated at the location the pointer points to. There is no built-in way to keep track of the size of the allocated memory — the programmer must store it somewhere. Typically, larger programs have a constant or a define somewhere in a header shared by "translation units" (source files) so that parts of the program that use the allocated memory don't overshoot its limits, and the part allocating it knows how much is needed.

Remarks:

1. You don't use the entire allocated memory which is a bit strange: You allocate 2560 floats but initialize only 2398.
2. The assignment data[i]=data[i]*900; reads from the uninitialized element data[i] before assigning to it. Reading uninitialized memory is verboten and kaput ("undefined behavior"), and the program is faulty. In practice you'll probably simply have funny float values, but still. Don't do it.

If you have an array you want to initialize with a few dozen values known at compile time I'd strongly prefer a true array. If it needs to live longer than the function you can make it static and let the function return a pointer to it.

Only if you need a lot of memory (2500 floats qualifies) or must create a number of arrays that is unknown at compile time consider creating them dynamically.

As others have remarked in comments, real-world code would use a vector or a smart pointer and/or std::array . Explicit dynamic allocation has pretty much become a domain of beginner homework (I'm not condescending: It has its place there) or projects stuck with old compilers (don't ask).