How is the sizeof(float) 4 bytes?

you have come to an incorrect conclusion. in objective C, datatypes use different amounts of memory. a float takes up 4 bytes of space regardless of how many numbers are in it. 0.1 takes up 4 bytes as does 0.222222.

here are some common sizes of primitive types:

Primitive sizes:
The size of a char is: 1.                
The size of short is: 2.                 
The size of int is: 4.                   
The size of long is: 4.                  
The size of long long is: 8.             
The size of a unsigned char is: 1.       
The size of unsigned short is: 2.        
The size of unsigned int is: 4.          
The size of unsigned long is: 4.         
The size of unsigned long long is: 8.    
The size of a float is: 4.               
The size of a double is 8.    

now since a float can only fit into 4 bytes of memory, there is a limit to the size of the numbers you can use. this is true of all data types as well. the limit is usually very high, so you normally dont have to worry about using too much memory.

since your array of numbers is an array of floats, you just multiple the size of the data type it stores (in this case float) by the length of the array. if you have 3 floats in your array you would multiple 4 * 3 to get 12. the size of your array is 12.

Here's a little extra information for the more curious:

The way memory works is 0's and 1's. And the way computers count is by using a bunch of 0's and 1's all in a row (binary). The reason it's 0's and 1's has to do with storing electrical charge.

If you want any more than two lonely numbers—0 and 1—you have to start setting them next to one another.

A byte is 8 of these 0's and 1's set next to one another. Here's an example of a byte: 00101100. A byte has 256 possible combinations (2 to the power of 8). This is part of why you'll see RGB colors valued up to 256.

If you have four bytes, you have over 4 billion possible combinations. Computers actually do something cool and tricky with floats in C (or in Objective-C, all the same), but ignoring that, someone back in the history of computing decided it would make sense for a float to be 4 bytes (or 32-bits).

All "sizeof" is asking for in C is the number of bytes for that primitive float type. It doesn't matter what number you assign to that float, it's going to be 4 bytes regardless.

So now if you have some array of floats, and you ask it what it's "sizeof" is, the C language is only going to understand you as asking what the size of a general float is. It doesn't actually understand that you have an array; it thinks you're just asking about a float. So if you want to keep track of how large your array is (for example, if you ever do anything in OpenGL), you'll need to save an integer that refers to the size of the float array. For instance, it might look like this:

float myarray[] = malloc( sizeof(float) * 300 ); // suppose I have 300 elements in my array.

int myarray_size = sizeof(float) * 300; // or you could use size_t instead of int.

[Deleted]

I don't want anyone to stumble upon my wrong conclusion and think it's correct by chance.