C++ Primer - Chapter 2 (Variables & Basic Types) Flashcards
True or false? When we define a const with the same name in multiple files, it is as if we had written definitions for separate variables in each file.
True.
What is a “reference”?
A compound type that “refers to” another type.
A reference defines an alternative name for an object.
Name the primitive data types in C++.
The arithmetic types (i.e. boolean value, characters, integers, and floating-point numbers) and the special type, void.
What is wrong with the following code?
int i=0;
int *p=i;
int i=0; int *p=i; // Error; an integral value cannot be assigned to a pointer.
Is this code legal? If not, why not? const double pi = 3.14; double *ptr = pi; const double *cptr = π *cptr = 42;
The code is not legal.
const double pi = 3.14; double *ptr = pi; // Error, as ptr is a plain pointer. const double *cptr = π // Okay, as cptr can point to a double that is const. *cptr = 42; // Error, as we cannot assign to *cptr.
Are arithmetic expressions involving a signed and unsigned integer typically cast to a signed or unsigned integer?
Further, what is the result of i+u in the following?
int i=-42;
unsigned u=10;
Unsigned.
The sum i+u yields (2^32)-32. Note, that i is converted to an unsigned before the expression is evaluated.
A ________ is a name that is a synonym for another type.
A type alias is a name that is a synonym for another type.
Explain each of the following definitions. Indicate whether any are illegal and, if so, why. int i = 0; (a) double* dp = &i; (b) int *ip = i; (c) int *p = &i;
int i = 0; (a) double* dp = &i; // Invalid, the types do not match. (b) int *ip = i; // Invalid, cannot assign an integral value to a pointer.. (c) int *p = &i; // Valid, the types match.
What form does the declarator of a reference take?
We define a reference type by writing a declarator of the form &d, where d is the name being declared.
Which of the following initializations are legal? Explain why. int i=0; (a) const int *p1 = &i; (b) const int &const r2; (c) const int i2 = i, &r = i;
int i=0; (a) const int *p1 = &i; // Legal, but p1 can't be used to change the value of i. (b) const int &const r2; // Illegal; a reference is not an object, so it can't be const, and it must be initialised. (c) const int i2 = i, &r = i; // Legal if i is an int or const int.
Can you define a reference to a reference?
No, references are not objects so you cannot create a reference to a reference.
What is the result of:
int *ip1, *ip2;
double dp, *dp2;
Note that the * must be repeated for each pointer variable:
int *ip1, *ip2;
Both ip1 and ip2 are pointers to int.
double dp, *dp2;
Here, dp2 is a pointer to double and dp is a double.
Which, if any, of the following assignments are invalid? If they are valid, explain what they do. int i = 0, &r1 = i; double d = 0, &r2 = d; (a) r2 = 3.14159; (b) r2 = r1; (c) i = r2; (d) r1 = d;
int i = 0, &r1 = i; double d = 0, &r2 = d; (a) r2 = 3.14159; // Valid, and also changes the value of d as r2 is bound to d. (b) r2 = r1; // Valid, the value of r2 and d are changed to 0. (c) i = r2; // Valid. (d) r1 = d; // Valid, i and r1 will have value 0.
What is a nonprintable character? Give an example.
A character with no visible representation, such as a control character, a backspace, newline, and so on.
What can constexpr references or pointers be initialised with?
A constexpr pointer can be initialised with the nullptr literal or literal 0.
A constexpr pointer or reference can also point to, or bind to, an object that remains at a fixed address.
True or false? (a) and (b) below are equivalent.
typedef char *pstring;
(a) const pstring cstr = 0;
(b) const char *cstr = 0;
False.
typedef char *pstring; (a) const pstring cstr = 0; (b) const char *cstr = 0; // In (a), because of the typedef, when pstring is used in a declaration, the base type is a pointer to char. // In (b) the base type is a char and * is part of the declarator.
What is a “compound type”? Give two examples of a compound type.
A type that is defined in terms of another type. Examples include references and pointers.
How can the type of a integer literal be specified? Is this prefixed or suffixed?
u or U (unsigned)
l or L (long)
ll or LL (long long)
The specification is applied as a suffix.
N.B.: Use capital letters for best practice, e.g. ‘l’ can be mistaken for a ‘1’.
What is a type alias?
A synonym for another type.
Is the following program legal? If so, what values are printed?
int i = 100, sum = 0;
for (int i = 0; i != 10; ++i)
{
sum += i;
}
std::cout «_space;i «_space;” “ «_space;sum «_space;std::endl;
The program:
int i = 100, sum = 0;
for (int i = 0; i != 10; ++i)
{
sum += i;
}
std::cout << i << " " << sum << std::endl;
is legal, and the output is: 100 45.
Name the problems, if any, of the following code: double dval; double *pd = &dval; double *pd2 = pd; int *pi = pd; pi = &dval;
Note that the types of the pointer and the object to which it points must match:
double dval; double *pd = &dval; // This is okay as the initializer is the address of a double. double *pd2 = pd; // This is okay as the initializer is a pointer to double. int *pi = pd; // This is an error as the types of pi and pd differ. pi = &dval; // This is an error; cannot assign the address of a double to a pointer to int.
What do uninitialised pointers typically use (under most compilers) as an address?
Under most compilers, the bits in memory where the pointer resides are used as an address.
When is decltype((variable)) a reference type?
decltype((variable)) is always a reference type.
What is wrong with the following code?
const int a;
const variables must have explicit initialisers.
What is the difference between the following?
extern int i;
int j;
extern int i; // declares but does not define i int j; // declares and defines j
What is a “literal”? What is the general syntax for a literal character and a literal string?
A value such as a number, a character, or a string of characters; a literal’s value is self-evident.
Literal characters are enclosed in single quotes and literal strings in double quotes.
Name the two subcategories of arithmetic types.
Integral types and floating-point types.
How many bits does a char, wchar, char16_t and char32_t take up?
char = 8-bit
wchar (wide) = 16-bit
char16_t (fixed width) = 16-bit
char32_t (fixed width) = 32-bit
What is an “object” defined as in C++ Primer?
Something that occupies a region of memory and has a type.
What happens when an out-of-range value is assigned to a signed type?
Further, what is the value of “ofr_char” in the following expression?
signed char ofr_char=256;
The result is undefined behaviour (UB); the program may work, crash, or produce garbage values.
What does a definition do?
It makes a name or identifier known to the program and allocates storage for the variable. It may also assign an initial value (initialisation).
What is the minimum size of a float, double and long double in bits?
float = 32-bit
double = 64-bit
long double = 64-bit (but can be 96- or 128-bit)
Describe the following code: int i = 42; int *p; int *&r = p; r = &i; *r = 0;
int i = 42; int *p; // The variable p is a pointer to int. int *&r = p; // Here, r is a reference to the pointer p. r = &i; // The reference r refers to a pointer; assigning &i to r makes p point to i. *r = 0; // Dereferencing r yields i (the object to which p points) and changes i to 0.
True or false? Pointers and references to const are top-level consts.
False, they’re low-level consts.
Can the type of a reference and the object to which it refers differ?
In general, no.
However, there are two particular cases where they can:
(1) When the const specifier is applied, and;
(2) When the object is of a derived class type.
How many octal digits can be used in an escape sequence?
Up to 3.
What can a plain reference not be bound to?
A reference cannot be bound to a literal or the result of a general expression.
What is a “declarator”?
The part of a declaration that includes the name being defined and an optional type modifier.
How can a variable be declared but not defined?
By adding the extern keyword.
Given the variable definitions: int i, *p1; const int ic=1; const int *const p3=&ic; Which of the following assignments are legal? Explain why. (a) i = ic; (b) p1 = p3; (c) p1 = &ic;
Define the variables: int i, *p1; const int ic=1; const int *const p3=&ic;
(a) i = ic;
Legal, i is a plain int and copying doesn’t affect a const object.
(b) p1 = p3;
Illegal, otherwise p1 would be able to change the data pointed to by p3.
(c) p1 = ⁣
Illegal; p1 must be a pointer to const.
What is a “temporary” variable?
An unnamed object created by the compiler while evaluating an expression.
A temporary exists until the end of the largest expression that encloses the expression for which it was created.
What is the problem with the following code? int ci=1; auto &g = ci; auto &h = 42; const auto &j = 42;
const int ci=1; auto &g = ci; // This is fine; top-level consts in the initializer are not ignored. auto &h = 42; // This is an error; we can’t bind a plain reference to a literal. const auto &j = 42; // This is okay; we can bind a const reference to a literal.
Will the compiler complain about the following functions being the same? Why?
int func(int i) {...}
int func(const int i) {...}Yes, because top-level consts are ignored when copying objects (to initialise the function parameters).
Notice here that the values are not passed by reference.
Do pointers need to be initialised?
No.
What type of const is not ignored when copying?
Low-level const.
What is wrong with the following code?
int &refVal2;
A reference must be initialised.
What is the term given for the scope that is outside all other scopes?
Global scope.
Determine the type of each of the following literals. Explain the differences among the literals in each of the four examples:
(a) ’a’, L’a’, “a”, L”a”
(b) 10, 10u, 10L, 10uL, 012, 0xC
(c) 3.14, 3.14f, 3.14L
(d) 10, 10u, 10., 10e-2
(a) char, wchar, string (‘a’+’\0’) and a wide character array of size 2.
(b) int, unsigned, long int, unsigned long, int (=10), int (=12)
(c) double, float, long double
(d) int, unsigned, double, double.
What happens when an initialiser is provided to a variable defined as extern outside a function? What about when the variable is defined as extern inside a function?
When a variable defined as extern is initialised outside a function, the extern keyword is overridden. When the variable is defined as extern inside a function, it is an error to provide an initialiser.
What does it mean for an object to be top-level const?
That an object itself is const and cannot be altered.
What digit does 0xe or 0xE represent?
14.
What does the following code produce?
unsigned u = 10, u2 = 42;
std::cout «_space;u2 - u «_space;std::endl;
std::cout «_space;u - u2 «_space;std::endl;
u2-u = 32 u-u2 = 2^32 - 32
When can a const variable use the same operations as a nonconst variable?
When the operation does not alter the variable.
An __________ starts with the keyword using followed by the alias name and an =.
An alias declaration starts with the keyword using followed by the alias name and an =.
What is the term given for the initialisation of a variable when no explicit initializer is given?
Default initialisation.
Is it possible to have a const reference? Is it possible to have a const pointer?
References are not objects, so they cannot be made const. Pointers, on the other hand, are, so they can be made const.
How can we make the compiler deduce the type of a variable for us?
Using the “auto” keyword.
What type does a have in the following code?
int i = 0, &r = i;
auto a = r;
int i = 0, &r = i;
auto a = r;
Here, a is an int (r is an alias for i, which has type int).
What does the following code produce? unsigned u = 10; int i = 10, i2 = 42; std::cout << i2 - i << std::endl; std::cout << i - i2 << std::endl; std::cout << i - u << std::endl; std::cout << u - i << std::endl;
i2-i = 32
i-i2=-32
i-u=0
u-i=0
Given the variable definitions: const int ic=1, &r = ic; const int *const p3=&ic; int *p1, *const p2=&ic; Which of the following assignments are legal? Explain why. (a) p3 = &ic; (b) p2 = p1; (c) ic = *p3;
Define the variables: const int ic=1, ic2=1, &r = ic; const int *const p3=&ic; int *p1, *const p2=&ic;
(a) p3 = &ic2;
// Illegal, p3 is a const pointer and cannot be assigned to after initialisation.
(b) p2 = p1;
// Illegal, p2 is a const pointer and cannot be assigned to after initialisation.
(c) ic = *p3;
// Illegal, ic is a const variable and cannot be assigned to after initialisation.
Name up to four levels of scope.
Global — names defined outside any other scope.
Class — names defined inside a class.
Namespace — names defined inside a namespace.
Block — names defined inside a block.
What is a constant expression?
An expression whose value cannot change and one that can be evaluated at compile time.
What does a variable definition consist of?
A type specifier followed by one or more variable names separated by a comma and terminated with a semicolon.
Can a reference be defined without an initialiser?
No, there is no way to rebind a reference so it must be initialised.
What happens when we define a reference with an initialiser?
Instead of copying the initialiser’s value, we bind the reference to its initialiser.
What four states can a pointer be in?
- It can point to an object.
- It can point to the location just immediately past the end of an object.
- It can be a null pointer, indicating that it is not bound to any object.
- It can be invalid; values other than the preceding three are invalid.
For each of the following declarations indicate whether the object being declared has top-level or low-level const.
(a) const int v2 = 0;
(b) int v1 = v2;
(c) int *p1 = &v1, &r1 = v1;
(d) const int *p2 = &v2, *const p3 = &i, &r2 = v2;
(a) const int v2 = 0; Top-level const; v2 is a const object. (b) int v1 = v2; v1 is nonconst; top-level const is ignored when copying. (c) int *p1 = &v1, &r1 = v1; Both p1 and r1 are nonconst. (d) const int *p2 = &v2, *const p3 = &i, &r2 = v2; p2 is low-level const, p3 is both low-level and top-level const, and r2 is low-level const.
What is the value of j in the following program?
int i = 42;
int main()
{
int i = 100;
int j = i;
}100.
Does a constexpr impose a top-level or low-level const?
Top-level.
What is the difference between ‘a’ and “a”?
The compiler appends the null character ‘\0’ to a string literal (so “a” is corresponds to ‘a’ and ‘\0’).
How can the type of a floating-point literal be specified? Is this prefixed or suffixed?
f or F (float)
l or L (long)
The specification is applied as a suffix.
N.B.: Use capital letters for best practice, e.g. ‘l’ can be mistaken for a ‘1’.
Explain the following definitions. For those that are illegal, explain what is wrong and how to correct it.
(a) std::cin»_space; int input_value;
(b) int i = { 3.14 };
(c) double salary = wage = 9999.99;
(d) int i = 3.14;
(a) std::cin >> int input_value;
// The right-hand operand of the input operator must be an object. Correction:
int input_value;
std::cin >> input_value;
(b) int i = { 3.14 };
// Error; leads to a loss of information.
(c) double salary = wage = 9999.99;
// Wage has not been declared. Correction:
double wage;
double salary = wage = 9999.99;
(d) int i = 3.14;
// Okay, but will lead to a loss of information.True or false? A literal is a constant expression.
True.
How many times can be a variable be declared? How many times can be a variable be defined?
A variable can be declared many times but it can only be defined once.
What is a “word”?
The natural unit of integer computation on a given machine.
On a 32-bit machine a word is typically 4 bytes.
How can a variable be used in more than one file?
A variable can be used in more than one file by declarations that are separate from the variable definition. This involves the use of the extern keyword.
In the following code, what types do b, c, d, and e have? int i = 0; const int ci = i, &cr = ci; auto b = ci; auto c = cr; auto d = &i; auto e = &ci;
int i = 0; const int ci = i, &cr = ci; auto b = ci; // The variable b is an int (top-level const in ci is dropped). auto c = cr; // Here, c is an int (cr is an alias for ci whose const is top-level). auto d = &i; // The variable d is an int* (& of an int object is int*). auto e = &ci; // The variable e is const int* (& of a const object is low-level const).
What is the problem with the following code?
auto i = 0, *p = &i;
auto sz = 0, pi = 3.14;
auto i = 0, *p = &i; // This is okay; i is int and p is a pointer to int. auto sz = 0, pi = 3.14; // This is an error; sz and pi have inconsistent types.
What digit does 0xf or 0xF represent?
15.
Is the following code valid?
double dval = 3.14;
const int &ri = dval;
Yes. We can initialise a reference to const from any expression that can be converted to the type of the reference.
N.B. This would not be true with a plain reference.
What type of const is ignored when copying?
Top-level const.
Define “bind”.
Associating a name with a given entity so that uses of the name are uses of the underlying entity.
Describe the general form of a declaration.
Generally, a declaration is a base type followed by a list of declarators.
Each declarator names a variable and gives the variable a type that is related to the base type.
When is the following expression valid?
constexpr int sz = size();
When size() is a constexpr function.
Explain whether each of the following is a declaration or a definition:
(a) extern int ix = 1024;
(b) int iy;
(c) extern int iz;
(a) Definition if placed outside a function, error if inside a function.
(b) Declares and defines iy.
(c) Declares but does not define iz.
What is the difference between an uninitialised pointer and a null pointer?
A null pointer has value 0x0 but an uninitialised pointer may point to anywhere in memory.
Can a void pointer be used to operate on the object to which it points?
No, as the type must be known but a void pointer only stores the address of an object, not its type.
What is a “byte”?
The smallest chunk of addressable memory. On most machines a byte is 8 bits.
What is an “escape sequence”?
An escape sequence is a sequence used to print so-called “nonprintable” characters.
What does a variable declaration specify?
The type specifier and name (i.e. the identifier).
True or false? A reference to const can be used to alter a variable’s value.
False.
Determine the types and values of each of the following variables.
(a) int* ip, i, &r = i;
(b) int i, ip = 0;
(c) int ip, ip2;
(a) int* ip, i, &r = i; // ip is a pointer to an int, i is an int, and r is a reference that refers to the int i. // Note that declarator must be provided for each identifier. (b) int i, *ip = 0; // i is an int and ip is a pointer to an int that has been initialised to null. (c) int* ip, ip2; // ip is a pointer to an int and ip2 is an int.
Can constexpr pointers point to variables defined inside a function? Why?
No. Variables defined inside a function ordinarily are not stored at a fixed address.
What is the issue with the following code?
int i = 42, p = &i, &r = i;
decltype(r + 0) b;
decltype(p) c;
int i = 42, *p = &i, &r = i; decltype(r + 0) b; // This is okay; addition yields an int; b is an (uninitialised) int. decltype(*p) c; // This is an error; c is int& and must be initialised.
If an object is “initialised”, what does that mean?
It is assigned a value at the moment of its creation.
Why must the type of a pointer and the object to which it points match?
Because the type of the pointer is used to infer the type of the object that is being pointed to.
What is the name of the following syntax used to initialise a variable?
int a={0};
int a{0};
List initialisation.
Why is the initialisation of p legal but that of lp illegal in the following?
int i = 42;
void *p = &i;
long *lp = &i;
The object p is a void pointer so can hold the address of any variable.
The initialisation of lp is illegal because i and *lp do not have the same type; *lp is a long int but i is an int.
When a pointer can point to a const object, we refer to that const as a ___________.
When a pointer can point to a const object, we refer to that const as a low-level const.
Which of the following definitions, if any, are invalid? Why?
(a) int ival = 1.01;
(b) int &rval1 = 1.01;
(c) int &rval2 = ival;
(d) int &rval3;
(a) int ival = 1.01;
Valid, but will lead to a loss of information.
(b) int &rval1 = 1.01;
Invalid, a plain reference cannot bind to a temporary or an object of a different type.
(c) int &rval2 = ival;
Valid, as ival is an int.
(d) int &rval3;
Invalid, all references require initialisation.
How can we make a variable unchangeable?
We can make a variable unchangeable by defining the
variable’s type as const.
What is wrong with the following code? const int ci = 1024; const int &r1 = ci; r1 = 42; int &r2 = ci;
const int ci = 1024;
const int &r1 = ci;
r1 = 42;
This is an error as r1 is a reference to const.
int &r2 = ci;
This is not legal as a reference bound to a const variable must also be a reference to const.
What does a declaration do?
It makes a name or identifier known to the program.
What is a “variable”?
A named object or reference that a program can manipulate. In C++, variables must be declared before they are used.
What is a pointer? How are they similar to and different to a reference?
A compound type that “points to” another type.
Like references, pointers are used for indirect access to other objects.
Unlike a reference, a pointer is an object in its own right.
What does a compiler do to a const object when the object is initialised using a compile-time constant?
It replaces uses of the variable with its corresponding value during compilation.
True or false? Variables defined using the auto keyword do not need to be initialised.
False, the auto keyword infers the type from the initialiser.
True or false? Variables defined inside a function are always stored at fixed locations.
False. Variables defined inside a function ordinarily are not stored at a fixed address.
What is the default type of a floating-point literal?
Double.
What does the type of a variable determine?
- The size and layout of the variable’s memory;
- The range of values that can be stored within that memory, and;
- The set of operations that can be applied to the variable.
How can we avoid including a header multiple times?
By using a header guard.
What is a “base type”?
A type specifier, possibly qualified by const, that precedes the declarators in a declaration. The base type provides the common type on which the declarators in a declaration can build.
When can a pointer be dereferenced?
When the pointer is valid, i.e. it either points to an object, to the location just immediately past the end of an object, or when it is a null pointer.
Which, if any, of the following names are invalid?
(a) int double = 3.14;
(b) int _;
(c) int catch-22;
(d) int 1_or_2 = 1;
(e) double Double = 3.14;
(a) Valid.
(b) Valid, as identifiers can begin with an underscore. However, this should not be used in general.
(c) Invalid.
(d) Invalid, identifiers can only begin with letters or an underscore.
(e) Valid but confusing; avoid duplicating built-in type names.
What is the result of the following?
long double ld = 3.1415926536;
int a{ld}, b = {ld};
int c(ld), d = ld;
int a{ld}, b = {ld}; is an error because list initialisation does not allow the loss of information during initialisation.
int c(ld), d = ld; is ok, but the value will be truncated.
Can a pointer be used to access an object in either of the following cases:
- It points to the location just immediately past the end of an object.
- It is a null pointer.
No, these are specific cases when an object cannot be accessed through a pointer and will result in undefined behaviour.
How & and * are used in declarations and as operators?
In declarations, & and * are used to form compound types; a reference and pointer, respectively. In expressions, these same symbols are used to denote an operator; the address-of and dereference operator, respectively.
What is an “alias declaration”?
A declaration that starts with the “using” keyword followed by an =.
Is a char signed or unsigned?
It may be either; it depends on your compiler!
True or false? decltype ignores top-level const.
False.
Determine the types deduced in each of the following definitions. const int i = 42; auto j = i; const auto &k = i; auto *p = &i; const auto j2 = i, &k2 = i;
const int i = 42;
auto j = i;
The variable j is an int (top-level const is ignored).
const auto &k = i;
The variable k has type “const int&” (a reference to const int).
auto p = &i;
The variable p has type “const int” (i.e. a pointer to const; top-level const cannot be ignored here).
const auto j2 = i, &k2 = i;
The variable j2 has type const int and k2 is a reference to const.
Explain the following definitions. Identify any that are illegal.
(a) int i, *const cp;
(b) int *p1, *const p2;
(c) const int ic, &r = ic;
(d) const int *const p3;
(e) const int *p;
(a) int i, *const cp; // Illegal; cp is a const pointer, so must be initialised. (b) int *p1, *const p2; // Illegal; p2 is a const pointer, so must be initialised. (c) const int ic, &r = ic; // Illegal; ic is a const object so it must be initialised. (d) const int *const p3; // Illegal; p3 is a const pointer so needs to be initialised. (e) const int *p; // Legal; p is a pointer to const and does not need to be initialised.
When is decltype(variable) a reference type?
decltype(variable) is a reference type only if variable is a reference.
Fill in the blank:
A ________ makes a name known to the program
A declaration makes a name known to the program.
Are literals stored in the largest or smallest type that they can be stored?
Smallest.
‘\x4d’ and ‘\115’ correspond to ‘M’ so what does the following print?
std::cout «_space;“Hi \x4dO\115!\n”;
“Hi MOM!” followed by a newline.
What are the built-in arithmetic types?
Characters, integers, booleans and floating-point types.
Fill in the blanks:
A declaration is a ________ followed by a list of ________.
A declaration is a base type followed by a list of declarators.
What types are decimal literals placed in?
The smallest type of int, long int or long long int in which the value fits.
How can a const variable be shared between multiple files if the initialiser is not a constant expression?
By using the extern keyword.
Fill in the blank:
A ________ is a part of the program in which a name has a particular meaning
A scope is a part of the program in which a name has a particular meaning.
What is the type deduced when we apply decltype to an expression that is not a variable?
We get the type that that expression yields.
Is it legal or illegal to have a pointer to a pointer?
Legal. A pointer is an object in memory, so like any object it has an address. Therefore, we can store the address of a pointer in another pointer.
In the following code, determine the type of each variable and the value each variable has when the code finishes: int a = 3, b = 4; decltype(a) c = a; decltype((b)) d = a; \++c; \++d;
int a = 3, b = 4; decltype(a) c = a; // The variable c has type int. decltype((b)) d = a; // The variable d has type int& and is bound to a. \++c; // Increments c alone. \++d; // Increments d and a (as d is an alias for a).
Final values:
a=4; b=4; c=4; d=4;
In what two ways can we define a type alias?
With a “typedef” and with the “using” keyword.
What does the following program do?
int i = 42;
int *p1 = &i;
*p1 = *p1 * *p1;
The program:
int i = 42;
int *p1 = &i;
*p1 = *p1 * *p1;
initialises i to 42 then squares the value by dereferencing the pointer p1; nothing happens to p1 afterwards.
How is a variable of built-in type, which is defined outside a function, initialised when no initial value is provided? What about when it is defined inside a function?
Variables of a built-in type defined outside a function are default initialised to zero.
Variables of a built-in type defined inside a function are uninitialised.
Is it possible to have a pointer to a reference? Is it possible to have a reference to a pointer?
A reference is not an object, hence we may not have a pointer to a reference.
However, because a pointer is an object, we can define a reference to a pointer.
What operations can be performed with a void pointer?
What are the limitations of a void pointer?
We can compare a void pointer to another pointer, pass it to or return it from a function, and assign it to another void* pointer.
We cannot use a void pointer to operate on the object it addresses (as we don’t know that object’s type, and the type determines what operations we can perform on the object).
Will the compiler complain about the following functions being the same? Why?
int func(int& i) {...}
int func(const int& i) {...}No. The second function declaration has a reference to const parameter; low-level consts are not ignored when initialising the function parameters from its arguments.
What character is appended by the compiler to a string literal?
The null character, ‘\0’
What does it mean for an object to be low-level const?
That the base type of the compound type is const.
Define “const”.
Type qualifier used to define objects that may not be changed.
What floating-point types are there?
float, double, long double.
Which of the following are legal? For those that are illegal, explain why.
(a) const int buf;
(b) int cnt = 0;
(c) const int sz = cnt;
(d) ++cnt; ++sz;
(a) const int buf; A const variable must have an explicit initialiser. (b) int cnt = 0; Legal. (c) const int sz = cnt; Legal. (d) ++cnt; ++sz; cnt can be incremented but sz cannot as it is a const variable.
How can the type of a variable be deduced from an expression (and not its initialiser)?
Using the “decltype” type specifier.
How can the type of a character or character string literal be specified? Is this prefixed or suffixed?
u (Unicode, char16_t)
U (Unicode, char32_t)
L (wide character, 16-bit)
u8 (utf-8, char)
The specification is applied as a prefix.
How is a top-level const deduced when using the auto keyword?
By explicit use of the const keyword.
What keyword is used to indicate an expression is const?
constexpr.
True or false? A variable that is initialised from a const variable does not have to be a const variable.
True, as long as the variable being assigned to is not a reference.
What digit does 0xa or 0xA represent?
10.
True or false? A string literal is an array of constant chars.
True.
How many hexidecimal digits may be used in an escape sequence?
All the hex digits following \x are used.
What is the issue with the following code? const int ci = 0, &cj = ci; decltype(ci) x = 0; decltype(cj) y = x; decltype(cj) z;
const int ci = 0, &cj = ci; decltype(ci) x = 0; // This is okay, x has type const int. decltype(cj) y = x; // This is okay, y has type const int& and is bound to x. decltype(cj) z; // This is an error; z is a reference and must be initialised.
What digit does 0xc or 0xC represent?
12.
What types are octal or hexidecimal literals placed in?
The smallest type of int, unsigned int, long int, unsigned long, long long int or unsigned long long in which the value fits.
What signed integral types are there?
short int, int, long int, long long int.
What character types are there?
char, wchar (wide char), char16_t, char32_t.
How is the type of a variable deduced using the “auto” keyword?
Using the initialiser.
Where is the error in the following? int i = 42; const int &r1 = i; const int &r2 = 42; const int &r3 = r1 * 2; int &r4 = r * 2;
int i = 42; const int &r1 = i; // This is okay; we can bind a const int& to a plain int object. const int &r2 = 42; // This is okay; r1 is a reference to const. const int &r3 = r1 * 2; // This is okay; r3 is a reference to const. int &r4 = r * 2; // This is an error; can't bind an expression to a nonconst reference.
What digit does 0xb or 0xB represent?
11.
What does “default initialisation” mean?
The initialisation of an object when no explicit initialiser is given.
What is the result of two string literals separated by a space, tab or newline?
They will be concatenated into a single string literal.
What, if any, are the differences between the following definitions:
int a=9, b=7;
int a=09, b=07;
A 0 preceding a digit corresponds to an octal number, thus 09 does not yield valid syntax. In octal notation, a ‘9’ is represented by ‘011’.
What are the values of 20, 024 and 0x14? What notation is value given in?
- The notations are decimal, octal and hexadecimal, respectively.
How must a const object be defined?
const objects must be initialised, because there is no way to give them a value after they are defined.
What happens when an out-of-range value is assigned to an unsigned type?
Further, what is the value of “ofr_char” in the following expression?
unsigned char ofr_char=-1;
The result is the remainder of the value modulo the number of values the target type can hold.
An unsigned char can hold a maximum of 256 values so “ofr_char” has value 255.
What digit does 0xd or 0xD represent?
13.
True or false? A variable definition is a declaration.
True.
Can decimal literals be negative?
No; they are only non-negative. A minus sign is just an operator that acts on an unsigned literal.
What can a reference to const be bound to?
A nonconst object, a literal, or a more general expression.
What form does the declarator of a pointer take?
We define a pointer type by writing a declarator of the form *d, where d is the name being defined.
Where does the distinction between top-level and low-level const matter?
When we copy an object. Top-level consts are ignored; low-level consts are not.
When we ask for a reference to an auto-deduced type, are top-level consts in the initialiser ignored?
No.
True or false? auto ordinarily ignores top-level consts.
True.
What does the following code print?
int i, &ri = i;
i = 5; ri = 10;
std::cout «_space;i «_space;” “ «_space;ri «_space;std::endl;
The output of the program:
int i, &ri = i;
i = 5; ri = 10;
std::cout «_space;i «_space;” “ «_space;ri «_space;std::endl;
will be: 10 10.
Is the following code legal? int errNumb = 0; int *const curErr = &errNumb; const double pi = 3.14159; const double *const pip = pi;
The code is indeed legal.
int errNumb = 0; int *const curErr = &errNumb; // The const pointer curErr will always point to errNumb. const double pi = 3.14159; const double *const pip = pi; // The object pip is a const pointer to const which means it can point to a const object, the second const simply means that the pointer cannot be changed upon initialisation.
How is a pointer dereferenced?
Using the dereference operator, i.e. *.
How are generalised escape sequences written?
Using octal following a backslash, or hexadecimal digits following \x.
We use the term ___________ to indicate that the pointer itself is a const.
We use the term top-level const to indicate that the pointer itself is a const.
What is a void pointer?
The type void* is a special pointer type that can hold the address of any object.
A void* pointer holds an address, but the type of the object at that address is unknown.
Which of the following initializations are legal? Explain why.
(a) int i = -1, &r = 0;
(b) int *const p2 = &i;
(c) const int i2 = -1, &r = 0;
(d) const int *const p3 = &i2;
(a) int i = -1, &r = 0; // Illegal; r is a reference which cannot be initialised with a literal (without a const type specifier). (b) int *const p2 = &i; // Legal. (c) const int i2 = -1, &r = 0; // Legal; i2 is a const int and r is a reference to const, which can bind to a literal. (d) const int *const p3 = &i2; // Legal.
