What are the various data types in C plus plus?

Answer 1

Data types specify how data is interpreted. All data in a binary computer is stored as a sequence of bits (binary digits), thus all data is represented by numeric values. The data type associated with that data determines how many bits the data occupies and how that data should be interpreted. For instance, an unsigned char data type occupies 8 bits (1 byte) which translate to a numeric value in the range 0 to 255. These values map to ASCII character codes in the current code page, thus if you were to output a char data type it would print the character associated with the character code rather than the numeric value of the code. Unicode character codes use 16 bits (2 bytes) to represent each character and are therefore unsigned short types, also known as wchar_t types.

The primitive data types include int, short and char, which are all integral data types used to store integers (whole numbers). Each may be further qualified with the signed or unsigned keywords, thus a signed char will represent values in the range -128 to +127.

Strings of characters are represented as an array of char types, typically terminated by a null character which has the value 0. Arrays are simply sequence containers containing one or more data elements of the same type. Since the length of each element is the same, it is trivial to locate any element within the array given the element's index where the first element can be found at index 0. Thus an array of n elements will have indices in the range 0 to n-1. Knowing the size of each element (as determined by its type) means that element x can be found at the memory address x*sizeof(element) bytes from the start of the array, using nothing more than simple pointer arithmetic. However, when you declare an array, the subscript operator can be used to specify the index of the element you wish to examine, while C++ does the pointer arithmetic in the background.

More complex data types can be declared using class or struct keywords. The declaration of these types determines how they are mapped in memory and ultimately how they are interpreted. Primitive data types act as the building blocks for these complex data types, but more complex data types can be composed from any combination of primitive and pre-existing complex data types to produce ever more highly complex data types.

Instances of a type are known as variables or constants, depending on whether the value of the instance can be changed or not. If the type is a complex data type, such as a class or struct, the instance is known as an object, which can also be variable or constant. Many new users regard classes and objects as being the same thing, however a class is the definition of a type while an object is an instance of the type, in the same way that a char is a type while a char variable is an instance of the type.

Answer 2

The following are all the standard C++ data types:

• int
• unsigned int
• short int
• unsigned short int
• long int
• unsigned long int
• char
• wchar_t
• bool
• float
• double
• long double

Answer 3

It is impossible to say. There are at least as many user-defined types as there are programmers to create them, and while there will inevitably be some duplicates that have come into common use, there are still an infinite number of ways to define the same user-defined type. You might as well ask how many unique objects there are in the universe and how many different ways each of them could be defined.

However, if we only limit our scope to just the common features of any UDT, then we can say that there are only 3 types: primitives, classes and unions. The following examples demonstrate each of these:

typedef unsigned long long uint64;

class foo {

private:

uint64 m_data;

};

union bar {

uint64 as_uint64;

int as_int;

char as_char;

};

Answer 4

The primitive data types available in C++ are the same as those available in C and are provided by the C standard library. Thus we have the integrals, char and int, and floating point types, float and double. Combined with the four type modifiers, long, short, signed and unsigned, we have type definitions for a wide variety of built-in data types including size_t and wchar_t.

C++ also includes classes and other complex structures within the standard template library. Most of these are container types such as vector, list, queue, stack and so on, but also includes more specific sequence containers such as string and wstring, which act as wrapper classes for vectors of type char and wchar_t respectively.

Answer 5

C++ includes the primitives inherited from C, including the integrals char and int, floating point types float and double, as well as the four standard type modifiers long, short, signed and unsigned. C++ also supports pointers (variables that store memory addresses).

In addition, C++ includes a wealth of built-in types which can be found in the standard template library (STL), including std::string, std::vector and std::list.

Note that although C references and pointers are the same thing (pointers), a C++ reference is not the same as a C++ pointer. A reference is neither a variable nor a constant (and therefore requires no storage), it is simply an alias for an existing variable or constant (and therefore cannot be NULL). Aside from that, a reference behaves like a constant pointer insofar as once assigned, a reference cannot be re-assigned. References are generally much easier to work with and should be utilised whenever possible. Pointers should only be used when there's a need to point at more than one variable (or NULL).

Answer 6

char (1 byte or 8 bits), short (2 bytes, 16 bits), long (4 bytes, 32 bits) and long long (8 bytes, 64 bits). These sizes are general, not strict. Use the sizeof() operator to determine actual lengths.

All other data types, including user-defined data types, are merely variations of these four primary types, whether signed or unsigned. Pointer variables are 4 bytes on a 32-bit system, 8 bytes on a 64-bit system. Strings are simply arrays of unsigned char (UNICODE uses array of unsigned short). Structures are combinations of one or more other data types, including other structures. Their size is determined by the total size of each member plus any padding used for alignment. Classes are no different to structures, but extra memory is required for the v-table if the classes have virtual methods. Again, use sizeof() to determine actual sizes.