Computer Science

A nibble is a term given to one half of one byte. Since a byte is eight bits, a nibble would be four bits.

The number 0010 1011 1100 1011 contains four nibbles.

It depends on the language. Java provides the Objectsuperclass (defined in java.lang) from which all other classes must be derived. This allows us to treat any Java object as being "of the same type". This is not necessarily a good thing -- separate types should be kept separate -- however garbage collection would be difficult to implement without a common base class to refer to every type of object.

C++, on the other hand, is not a "pure" object-oriented language; it is a multi-paradigm (procedural, object-oriented and generic). Programmers are free to decide for themselves how to classify user-defined objects, but the built-in types (such as int and double) are not derived from classes, so there can be no superclass. If there were, it would not be possible to write (let alone support) low-level C-style code where there can be no classes of any type. In addition, the standard library types (such as vector and string) have no superclass. In particular, a vector and a vector cannot be regarded as being "of the same type" even if U derives from T. If we really require this functionality, we can easily cater for it in code, but it isn't provided by default (via a superclass) because the language itself does not require it.

In C programming, the signed and unsignedmodifiers only apply to integer data types: char, short int, int, long int and long long int. Using these modifiers affects the range of values that each of these types can physically represent, however those ranges are implementation-defined.

Although we typically regard a byte as being 8 bits in length, this is not the case at all. In programming, a byte is simply the smallest unit of addressable storage on the system, but the length of a byte is actually determined by the machine architecture of that system.

In C programming, all data types are measured in chars, thus sizeof (char) is always 1 (byte). However, to determine the number of bits per char we need to examine the CHAR_BITS macro defined in . In most cases this macro is defined with a value of 8 (bits), however we can never assume that is always the case; some systems use a 9-bit byte, others use a 16-bit byte. The only thing the standard guarantees is that CHAR_BITS will be no less than 8. Although 7-bit and 6-bit systems do exist, they are non-standard and therefore require non-standard language implementations.

Generally, we don't really need to know the bit-length of an individual char, we simply need to know what range of values the integer types can physically represent (with respect to the current implementation). Again, we look to the macros defined in the implementation's header:

SCHAR_MIN : Minimum value signed char

SCHAR_MAX : Maximum value signed char

UCHAR_MAX : Maximum value unsigned char

CHAR_MIN : Minimum value char

CHAR_MAX : Maximum value char

SHRT_MIN : Minimum value short int

SHRT_MAX : Maximum value short int

USHRT_MAX : Maximum value unsigned short int

INT_MIN : Minimum value int

INT_MAX : Maximum value int

UINT_MAX : Maximum value unsigned int

LONG_MIN : Minimum value long int

LONG_MAX : Maximum value long int

ULONG_MAX : Maximum value unsigned long int

LLONG_MIN : Minimum value long long int

LLONG_MAX : Maximum value long long int

ULLONG_MAX : Maximum value unsigned long long int

Note that there are no macros defining the minimum value of unsigned data types because the minimum value for any unsigned data type is always 0. Also, a "plain" int is always signed, hence there is no SINT_MIN or SINT_MAX macro.

The char, signed char and unsigned char are three distinct types. The standard does not specify whether a "plain" char should be signed or unsigned, but its range must match that of either the signed char or unsigned char data types. To determine whether a plain char is signed or not, we can use the following:

bool signed_char = ((int) CHAR_MAX == (int) SCHAR_MAX) ? true : false;

If signed_char is true, a char is equivalent to a signed char, otherwise it is equivalent to an unsigned char.

Negative integer values are either represented using ones-complement or twos-complement notation. Again, this is implementation-defined although most modern systems use twos-complement. To determine which notation is in use, we simply look to the minimum value of a signed char. Assuming an 8-bit char, a ones-complement system defines SCHAR_MIN as being -127 while a twos-complement system uses -128.

In ones-complement notation, to flip the sign we simply invert all the bits, thus 01010101 becomes 10101010 (the ones-complement of 01010101). The high-order bit denotes the sign (0 for positive, 1 for negative). However, this then means that we have two distinct representations for the value zero: 00000000 (+0) and 11111111 (-0) but zero is neither positive nor negative. To eliminate this inconsistency, twos-complement adds one to the ones-complement, thus 11111111 + 1 = 00000000 (the overflowing bit is simply ignored). By eliminating the redundant representation for -0, the negative range of values increases by 1.

One of the implications of using signed and unsigned data types is that we must be careful when performing mixed-mode arithmetic as this can result in "narrowing" or loss of information. For instance:

void f (signed char s, unsigned char u) {

u = (unsigned) s; // ouch!

}

Here we used an explicit cast, however if s is negative we will lose information because an unsigned type cannot represent a negative value. Conversely, if s is positive, we don't lose information because the upper range of u exceeds that of s. So before converting between signed and unsigned representations, it is worth ensuring the value is within the range of valid values. When converting from unsigned to signed, it's usually a good idea to use a larger signed data type.

The following full form is pedmas:

p = parenthesese = exponentsm = multiplicationd = divisiona = additions = subtraction