Fundamental Data Types

Question 1

What does the data type tell the compiler?

Answer 1

How much memory to set aside for a variable and how to interpret the bits/bytes at a memory address

Question 2

What is the syntax for explicit vs. implicit assignment

Answer 2

Explicit:
type varName = value;

Implicit:
type varName(value);

Question 3

Is the following syntax correct or incorrect:

int nValue 1, int nValue2;

Answer 3

Incorrect; this will not compile b/c only one type can be specified per line.

Question 4

T/F: In the following expression the value of ‘nValue 1’ is 5:

int nValue1, nValue2 = 5;

Answer 4

F; nValue 2 contains the value 5, whereas nValue1 is uninitialized

Question 5

What is a keyword in C++?

Answer 5

An identifier reserved by the language that cannot be reused

Question 6

What is an identifier?

Answer 6

The name of a function, variable, class, or any entity in C++

Question 7

What are the rules for creating an identifier?

Answer 7

It cannot be a keyword, must be composed only of letters, numbers, and the underscore character, must begin with a letter or underscore (not a number), is case sensitive, and describes the thing that it identifies.

Question 8

What is Hungarian notation?

Answer 8

prefixing a variable with an indication of its type:
int nValue;
bool bValue;
char chValue;
double dValue;
float fValue;

Question 9

How is memory assigned to a variable with a size larger than 1 byte?

Answer 9

Consecutive memory addresses are used

Question 10

What is the ‘sizeof()’ operator?

Answer 10

It is a unary operator which returns the size of a type or variable in bytes.

Question 11

T/F: The size of data types is not consistent across systems

Answer 11

T; The size of any data type is not guaranteed to be a specific value on any given system, although it will likely be close.

Question 12

What are the four types of integers and their approximate sizes?

Answer 12

char (1 byte)
short (2 bytes)
int (2 or 4 bytes)
long (4 bytes)

Question 13

T/F: ‘short’ and ‘long’ are shorthand

Answer 13

T; they stand for ‘short int’ and ‘long int’, respectively

Question 14

How does the signed/unsigned qualification affect the range of an integer?

Answer 14

Unsigned integers cannot store negative values, but can store positive numbers that are twice as large as those stored by a signed integer

Question 15

What is the definition of an integer?

Answer 15

A data type which holds whole numbers/characters

Question 16

Are all integers signed or unsigned by default?

Answer 16

signed, but the compiler is smart enough to know to use signed or unsigned if it sees a negative number (the ‘-‘ unary operator)

Question 17

What is overflow and what happens when it occurs?

Answer 17

Overflow occurs when a value outside of a data type’s range is attempted to be placed in a variable of that data type. In overflow bits are lost, and the value ‘wraps around’ back to the opposite end of its range.

Question 18

What will 65536 and 65537 overflow to for an int type (max 4 bytes)?

Answer 18

0 and 1, respectively, the two bit patterns are 1 0000 0000 0000 0000 and 1 0000 0000 0000 0001. In both cases the bits greater than the 4 bytes available are lost, meaning that the two values become 0000 0000 0000 0000 and 0000 0000 0000 0001. This is why the values ‘wrap around’. Note that the same thing happens in reverse if the lower limit of the values is exceeded.

Question 19

Why is overflow such a bad thing?

Answer 19

It results in information being lost

Question 20

What are the three floating point types and their approximate sizes?

Answer 20

float (4 bytes)
double (8 bytes)
long double (>8 bytes)

Question 21

What does the float in “floating point” refer to?

Answer 21

The ‘float’ in floating point refers to the fact that a floating point number can have a variable number of decimal places.

Question 22

How are floats represented in memory?

Answer 22

Floats are represented in memory in a manner not unlike scientific notation, with the significand and its exponent.

Question 23

What is the precision of a floating point number?

Answer 23

How many digits it can represent without information loss.

Question 24

What can be done to change the default precision of functions like ‘cout’?

Answer 24

Use the function setprecision(int)

Question 25

What are floating points extremely succeptible to?

Answer 25

rounding errors

Question 26

What is the convention for methods that return a boolean?

Answer 26

name the method starting with ‘Is’; IsEqual, IsTrue, etc.

Question 27

T/F: any integer <= 0 will evaluate to false when cast as a bool

Answer 27

F; 0 is the only value that becomes false when cast as a bool; all other values evaluate to true.

Question 28

T/F: The following statements are equivalent:
char chValue = ‘a’;
char chValue2 = 97;

Answer 28

T; 97 is the ASCII code for ‘a’

Question 29

T/F: The compiler will not know what to do with the following statement and will produce an error:
char chChar = 97;

Answer 29

F; The compiler merely assignes the ASCII character code 97 to ‘chChar’, and when out put by a function like ‘cout’ it will yield ‘a’

Question 30

What happens when a string or array of chars is placed into a char variable?

Answer 30

Overflow; only the first char is assigned, the other chars are lost.

Question 31

What is a literal constant, and what are some examples?

Answer 31

Literal constants are literal numbers inserted into the code. They are constants because you can’t change their values. Examples are integer and float values.

Question 32

T/F: Floating point literal constants are of type double by default

Answer 32

T, add an ‘l’ or ‘L’ to the end to make it a long double, or an ‘f’ to make it a float.

Question 33

What are the two major problems with symbolic constants made with #define?

Answer 33

They do not show up in the debugger, and they have global scope.

Question 34

What is the best way to declare symbolic constants?

Answer 34

With the ‘const’ keyword before the type

Question 35

What are two pros of Hungarian notation?

Answer 35

It removes type ambiguity and can shorten variable names

Question 36

What is the typical syntax for Hungarian notation?

Answer 36

_varName

int* pnValue;
int nValue;
const int g_nGlobalValue;