How is long long implemented in C++?

In C++, as far as I know, all data types are implemented as classes. ( Don't know if it is right, but I read it as a justification for statements such as int a(5); which calls the parametric constructor of int. )

If so, how are long and short implemented? I just found out that long long and short short are valid types but short long and long short are not (Checked the latter ones just because it sounds 开发者_StackOverflow社区funny!)

Similarly, how are signed and unsigned implemented?

PS. By implemented, what I mean is "Is written using C/C++ features or is it written at a lower level in the compiler itself".

So the equivalent parts of declaration of variable of a basic type and a userdefined object or variable is (read downwards)

auto|register|static|extern           <=>   auto|register|static|extern
const                                 <=>   const
(signed|unsigned)(long|short)datatype <=>   class name etc
variable name                         <=>   object/variable name

? Is that assusmption correct?

On the particular question, long long is implemented by the compiler in a compiler + platform specific way (usually more platform than compiler dependent).

As to the original misconception, no, not all types are classes in C++. The languages tries to provide a uniform syntax in as much as possible for all types, trying to have all types behave similarly in as much as possible, and be used in a similar way. As a matter of fact, it is actually quite the other way around: C++ tries in as much as possible to have classes behave like primitive types (value semantics).

The particular reason to be able to initialize an integer that way is actually quite related to classes, just in a different way. In a class constructor definition there are initializer lists that define how each one of the members is initialized before the constructor block is executed. The syntax for each initializer element in the list is basically (I would have to lookup the exact definition): member_name( initializer ), so for example you would get:

class my_int_vector {
   int * p;
   int size; 
public:
   my_int_vector() : p(0), size(0) {}
//...
}

Both pointers and integers are fundamental types, but they can be initialized in a way similar to that of classes. If that type of initialization was not allowed for fundamental types, and only the type name = value; syntax was allowed, the initializer list syntax would have to be extended, and you would not be able to seamlessly change those types at a later time (say, change the int to a atomic_int).

Built-in data types are not implemented as classes. They just have some syntactic similarities.

short, long, int and every other built-in type name are keywords which get treated specially by the compiler. So, in a nutshell, they're implemented as magic. They're not classes, they're just themselves.

So no, these types cannot be implemented in terms of other language features, the way std::string or other standard library components can. The built-in types are a fundamental part of the core language.

Not all data types are classes in C++. The primitive C data types are not (they're called scalars). They're not "implemented" at all, but rather they form a core feature of the language that has a direct translation to machine code. The syntax int i(5); is equivalent to C's int i = 5; and initializes the variable at declaration time.

You're laboring under a number of misconceptions:

• Not all data types are implemented as classes in C++. In fact, only class types are implemented as classes. Enums, pointers and arrays, in addition to the fundamental types, are not implemented as classes.

• short short is not a valid type. The signed integral types in C++03 are signed char, short, int, and long. Period. C++11 adds long long, and allows the implementation to add others.

• I'm not sure what you mean by "implemented" here. On almost all modern machine, all of the integral types (signed or unsigned) are directly supported in hardware; the C++ compiler just generates the appropriate hardware instructions. (On older machines, long, and sometimes even int or short, often required function calls for the basic operations, and on some rare and exotic machines, unsigned arithmetic requires added instructions.)

• How you write a definition is a question of syntax, not of implementation. Both T v(i); and T v = i; are legal if the type supports copy; for all but class types, they are perfectly identical. (With a modern compiler; I've used some compilers in the past that had bugs in this regard. But that's a fairly distant past.)