Printable View
Hello, I have come across a problem. I don't understand why someone would use float nowadays. Float is only accurate up to about 6 numbers, but uses less memory. Wouldn't someone rather use double, it has twice the accuracy, but uses more memory. Would this be a problem if you were holding alot of large nmbers, or will todays processors hold up? ;)
You said it. Memory usage is key, so save the bits.
Kuphryn
Well, perhaps you don't need the same precision (or don't have very precise data), but you need a very sizable number... then memory becomes an issue.
Not really an issue for most applications, though.
OK. Thanks.
You should always use double unless you specifically need the memory savings and don't need the precision - double is the default floating point type in C++. It is the same reason you should use int instead of short. float would be better named short double.
Would default int be considered long? In other words would I have to do long int for it to be long , or is int automatically long?
In terms of size, you have the following guarantee:
short <= int <= long
On most common (new) systems, with most compilers I have run across (nowhere near exhaustive), int and long are the same size.
An int is the same as a short. If you want a long, you have to specify long.
[EDIT]-------------------------
But like Zach says, a long and short can be the same size.
Ok.Cooool.
>> An int is the same as a short. If you want a long, you have to specify long.
This is not correct. There are three sizes of integers, short int (i.e. short), int, and long int (i.e. long). Zach L.'s size display is correct.
I thought that the size of an int was implementation specific.
two sizes, short and long. int could be either one of them
Code:#include <iostream>
int main(int argc, char *argv[])
{
std::cout << sizeof(short) << std::endl;
std::cout << sizeof(int) << std::endl;
std::cout << sizeof(long) << std::endl;
return 0;
}
/*My output
* 2
* 4
*/4
There are three potential sizes, and they are implementation specific. They could all three be the same, or all three be different, or two the same and one different. On a 64 bit machine you might have 2, 4, 8. On another machine you might have 2, 2, 2. The rule is short <= int <= long.
I've never really liked the C types, I see why they don't use the 'standard' names as those are usually architecturally specific.
If your compiling for IA-32 you can almost be guaranteed an int is a (IA-32) double word, a long is a double word, a short is a word, and a char is a byte and a long long or long int is a quad word. I like microsofts __int8 __int16 __int32 and __int64 types because they are more meaningful to me.
Double is more used but float is a lot better for something like a game to save memory.
because they're architecturally specific.Quote:
Originally Posted by valis
Standard C/C++ is designed for use on as many platforms as possible. that's why you can port a standard C program back and forth from linux to windows without a problem. The standards leave all the architecture-specific things to the compiler, and sets guidelines for the compiler to follow. that's why the sizes are defined in relation to eachother.
Using float uses less memory. It can also, with simple operations like addition and multiplication, be faster. In rough terms needing to manipulate a smaller variable takes less instructions, and can often run faster. There are exceptions to this statement (eg on some machines, the hardware natively supports double precision, and float (single precision) operations are emulated using double precision and then truncated. With problems where it matters (eg large-scale numerical codes that run for weeks or months rather than a few seconds) the difference is speed can amount to several days of run time. The advantages of speed and memory of float vs doubles are usually reduced by C (as many operations on floats, including passing it by value to a function, involve an implicit conversion to double). C++ has similar issues to C, although not to the same extent (in part because of function overloading, in part because of the type system). Bottom line is that you will never see major numerical codes written in C, you will see some in C++, but you will see most in a language designed for numerical work (eg Fortran).