What's the difference between long long and long
Going by the standard, all that's guaranteed is:
int
must be at least 16 bitslong
must be at least 32 bitslong long
must be at least 64 bits
On major 32-bit platforms:
int
is 32 bitslong
is 32 bits as welllong long
is 64 bits
On major 64-bit platforms:
int
is 32 bitslong
is either 32 or 64 bitslong long
is 64 bits as well
If you need a specific integer size for a particular application, rather than trusting the compiler to pick the size you want, #include <stdint.h>
(or <cstdint>
) so you can use these types:
int8_t
anduint8_t
int16_t
anduint16_t
int32_t
anduint32_t
int64_t
anduint64_t
You may also be interested in #include <stddef.h>
(or <cstddef>
):
size_t
ptrdiff_t
What is the difference between long , long long , long int , and long long int in C++?
long
and long int
are identical. So are long long
and long long int
. In both cases, the int
is optional.
As to the difference between the two sets, the C++ standard mandates minimum ranges for each, and that long long
is at least as wide as long
.
The controlling parts of the standard (C++11, but this has been around for a long time) are, for one, 3.9.1 Fundamental types
, section 2 (a later section gives similar rules for the unsigned integral types):
There are five standard signed integer types : signed char, short int, int, long int, and long long int. In this list, each type provides at least as much storage as those preceding it in the list.
There's also a table 9 in 7.1.6.2 Simple type specifiers
, which shows the "mappings" of the specifiers to actual types (showing that the int
is optional), a section of which is shown below:
Specifier(s) Type
------------- -------------
long long int long long int
long long long long int
long int long int
long long int
Note the distinction there between the specifier and the type. The specifier is how you tell the compiler what the type is but you can use different specifiers to end up at the same type.
Hence long
on its own is neither a type nor a modifier as your question posits, it's simply a specifier for the long int
type. Ditto for long long
being a specifier for the long long int
type.
Although the C++ standard itself doesn't specify the minimum ranges of integral types, it does cite C99, in 1.2 Normative references
, as applying. Hence the minimal ranges as set out in C99 5.2.4.2.1 Sizes of integer types <limits.h>
are applicable.
In terms of long double
, that's actually a floating point value rather than an integer. Similarly to the integral types, it's required to have at least as much precision as a double
and to provide a superset of values over that type (meaning at least those values, not necessarily more values).
When to use Long vs long in java?
I don't think there's a single correct answer. A few suggestions:
The biggest difference I see between
long
andLong
in this context is thatLong
may benull
. If there's a possibility you might have missing values, theLong
object will be helpful asnull
can indicate missing values. If you're using primitives, you'll have to use some special value to indicate missing, which is probably going to be a mess. Speed or size is not likely to be an issue unless you're planning on making an array of a million of these things and then serializing.My preference for validation logic is to throw some sort of custom
ValidationException
at the point at which the thing could fail. If you're just creating these things with a constructor, the simplest thing would be just to validate there, e.g.public ClientInput(Long userid, Long clientid, Map<String, String> parameterMap, Long timeout_ms, boolean debug) throws ValidationException {
if (userid == null) throw new ValidationException("UserId is required");
...etc, etc...
}
Ultimately, the ValidationException
is only useful if you can catch it at a point where you can do something useful with it - echo it back to a user or whatever.
What is the difference between long long and long int
There are several shorthands for built-in types.
short
is (signed
)short int
long
is (signed
)long int
long long
is (signed
)long long int
.
On many systems, short
is 16-bit, long
is 32-bit and long long
is 64-bit. However, keep in mind that the standard only requires
sizeof(char) == 1
sizeof(char) <= sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long)
And a consequence of this is that on an exotic system, sizeof(long long) == 1
is possible.
Difference between long and long long
C types are intended to be flexible, so they can be adapted to different situations in different C implementations. Because of this, in some C implementations, long
and long long
are the same width (number of bits used for the value) and size (total number of bytes, including padding). (Some other types can be the same size. For example, short
and int
can be the same.)
In a C implementation where long
and long long
are the same width and size, there is no arithmetic difference between them. There are technical differences. In particular, a pointer to a long
is a different type from a pointer to a long long
, and you should not use one where the other is expected.
Difference between Short, long and Long long int in C programming?
C was originally written for 16-bit machines, where the fastest and most-convenient size of integer to work with were 16 bits. This was the original int
type. Sometimes, programmers needed 32-bit numbers, so those were the long int
type.
In due course, people ported C to 32-bit machines where the most convenient word size was 32 bits. They wanted to keep using int
to mean the native word size, because for example about every C program in the real world has int i;
in it somewhere, but sometimes, they also needed to use 16-bit numbers to save space. So those became the short int
type.
Time passed, and C needed to be ported to 64-bit machines. By then, there were a lot of programs in existence that assumed long
was exactly 32 bits wide, and unfortunately, a lot of programs that also assumed that a long
was the same size as a pointer, an IPv4 address, a file offset, a timestamp, etc. Good code uses types such as size_t
, uintptr_t
, and off_t
instead, but old versions of the system libraries defined their library functions to use long
, so a lot of legacy code had to as well. Since C99 came out, there have also been types such as int32_t
in the standard library to specify exact widths, and Unix and Windows have had them under different names for a while.
As a consequence of the types being used to mean contradictory things, compilers today give programmers the choice between long
being 32 and 64 bits wide, and 64-bit compilers let int
be either 32 or 64 bits wide, too. At least one real compiler defined int
as 64 bits (the native word length) but long
as 32 bits (so the system libraries and code would still work). The standards committee prohibited that in C11: long long int
is now guaranteed to be at least as wide as long int
, and long int
at least as wide as int
.
Because a lot of programs couldn't redefine long
as 64 bits without breaking, C needed a new type that meant (at least) 64-bit. By then, the standards committee was reluctant to introduce new keywords outside a header file, so they reused an existing one instead and named it long long int
.
In brief, you shouldn’t make assumptions about what int
and long
mean beyond that int
is at least 16 bits wide and fast, long
is at least 32 bits wide, and on a C11 compiler long
is at least as wide as int
but no wider than long long
. For general purposes, use int
. If you need an array index, use size_t
or ptrdiff_t
. If you want to be sure you can hold a number over 32,767, and seriously expect you might need to run on some 16-bit machine someday, use long
or the fast type from <inttypes.h>
. If you’re making a system call, use the same type as its arguments. If you’re storing a pointer in an integer type, use uintptr_t
. If you need a number at least 64 bits wide, use long long
, and if you know exactly the width you need, use the exact-width type.
Long Double vs Long Long
long long
is integer (possibly with more range than long
)long double
is floating point (possibly with more range/precision than double
)long float
does not exist.
The integer types sorted by range are
_Bool
char
orsigned char
orunsigned char
short
(orshort int
) orshort unsigned
int
orunsigned
long
(orlong int
) orlong unsigned
long long
(orlong long int
) orlong long unsigned
The floating-point types sorted by range/precision are
float
double
long double
What is the difference between long and Long in android code?
Long is a class. long is a primitive. That means Long can be null, where long can't. Long can go anywhere that takes an Object, long can't (since it isn't a class it doesn't derive from Object).
Java will usually translate a Long into a long automatically (and vice versa), but won't for nulls (since a long can't be a null), and you need to use the Long version when you need to pass a class (such as in a generic declaration).
Related Topics
Good Debugger Tutorial for Beginners
Do You (Really) Write Exception Safe Code
How to Use a Third-Party Dll File in Visual Studio C++
When Do I Really Need to Use Atomic<Bool> Instead of Bool
Boost Asio Ssl Async_Shutdown Always Finishes with an Error
Is F(Void) Deprecated in Modern C and C++
What Is Dynamic Initialization of Object in C++
Fast Color Quantization in Opencv
C++ Template Friend Operator Overloading
Logical And, Or: Is Left-To-Right Evaluation Guaranteed
C++:Creating an Array with a Size Entered by the User
What Happens When a Computer Program Runs
C/C++ Function Definitions Without Assembly
How Can Currying Be Done in C++
Replacing Ld with Gold - Any Experience
C++11 Equivalent to Boost Shared_Mutex