Unit 2: Pointers, Reference Variables, Arrays and String Concepts - Practice Quiz

1 What must usually be done before dereferencing a void* pointer in C++?

2 If p is an int*, what does p + 1 point to?

3 Which declaration creates a pointer to a pointer to an integer?

4 When does a pointer commonly become a dangling pointer?

5 What is a wild pointer?

6 Which statement is the preferred modern C++ way to assign a null value to an integer pointer?

7 Which class member function is commonly used to release dynamic memory owned by an object?

8 Which operator is normally used to access a member through a pointer to an object?

9 Inside a non-static member function, what does the this pointer refer to?

10 Which statement declares an array containing five Student objects?

11 Which statement correctly defines a C++ string object containing Hello?

12 Which std::string member function returns the number of characters in a string?

13 Which std::string member function adds characters to the end of an existing string?

14 Which statement correctly describes a basic difference between pointers and references?

15 Which statement declares a two-dimensional integer array with 3 rows and 4 columns?

16 For int matrix[2][3];, which expression accesses the element in the second row and third column?

17 Assuming Student has a public integer member named marks, which statement declares a pointer to that data member?

18 What kind of address can a void* generally store?

19 Which std::string member function removes all characters from a string?

20 If objPtr is a pointer to a Book object, which expression calls its display() member function?

21 What does the following C++ code print?

int value = 25;
void* vp = &value;
int* ip = static_cast<int*>(vp);
std::cout << *ip;

22 What is the output of the following code?

int a[] = {10, 20, 30, 40};
int* p = a;
p += 2;
std::cout << *(p - 1);

23 What does the following program fragment display?

int x = 4;
int* p = &x;
int** pp = &p;
**pp += 3;
std::cout << x;

24 Consider the following code:

std::vector<int> values = {1, 2};
int* p = &values[0];
values.push_back(3);

25 Which change correctly prevents p from being a wild pointer before it is dereferenced?

int* p;
*p = 10;

26 Given the overloaded functions below, which function is selected by the call?

void select(int);
void select(int*);

select(nullptr);

27 What is printed before the program ends?

class Box {
public:
    int* value;
    Box(int v) : value(new int(v)) {}
};

int main() {
    Box a(5);
    Box b = a;
    *b.value = 9;
    std::cout << *a.value;
}

28 What is the output of the following code?

class Account {
    int balance;
public:
    Account() : balance(10) {}
    void add(int x) { balance += x; }
    int get() const { return balance; }
};

Account a;
Account* p = &a;
p->add(5);
std::cout << p->get();

29 What does the following code display?

class Number {
    int value;
public:
    Number(int value) { this->value = value; }
    Number& add(int value) {
        this->value += value;
        return *this;
    }
    int get() const { return value; }
};

Number n(2);
std::cout << n.add(3).add(4).get();

30 What is printed by the following program fragment?

class Item {
    int value;
public:
    Item(int v) : value(v) {}
    int get() const { return value; }
};

Item items[3] = {Item(1), Item(3), Item(5)};
std::cout << items[0].get() + items[2].get();

31 What is the output of this code?

std::string a(4, 'x');
std::string b = a;
b[1] = 'A';
std::cout << a << " " << b;

32 What value is assigned to pos?

std::string text = "cat scatter cat";
std::size_t pos = text.find("cat", 1);

33 What is the final value of s?

std::string s = "abcdef";
s.erase(2, 2);
s.insert(2, "XY");

34 What does the following code print?

int a = 3, b = 7;
int* p = &a;
int& r = a;
p = &b;
r = b;
std::cout << a << " " << b << " " << *p << " " << r;

35 What is the output of the following code?

int a[2][3] = {{1, 2, 3}, {4, 5, 6}};
int (*p)[3] = a;
std::cout << *(*(p + 1) + 2);

36 What does g.sumColumn(1) return?

class Grid {
    int a[2][3];
public:
    Grid() {
        int value = 1;
        for (int r = 0; r < 2; ++r)
            for (int c = 0; c < 3; ++c)
                a[r][c] = value++;
    }

    int sumColumn(int c) const {
        int sum = 0;
        for (int r = 0; r < 2; ++r)
            sum += a[r][c];
        return sum;
    }
};

Grid g;

37 What is printed by the following code?

struct Sample {
    int x;
};

Sample s{8};
int Sample::*pm = &Sample::x;
s.*pm = 11;
std::cout << s.x;

38 Which function declaration can directly receive a built-in array declared as int table[3][4]?

39 Which expression correctly accesses value through both an object pointer and a pointer to data member?

struct Node { int value; };
Node n{20};
Node* p = &n;
int Node::*pm = &Node::value;

40 What is printed by the following code?

int a[6] = {};
int* p = &a[1];
int* q = &a[5];
std::cout << q - p;

41 Under standard C++17 rules, which operation on vp is well-formed?

int x = 42;
void* vp = &x;

42 What does the following program fragment print?

int a[3][4];
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 4; ++j)
a[i][j] = 10 * i + j;
int (*p)[4] = a;
std::cout << *(*(p + 2) + 1);

43 Given int** pp, which implicit initialization is valid in standard C++?

44 After which statement is p guaranteed to be dangling?

std::vector<int> v{1, 2};
int* p = &v[0];
std::size_t oldCapacity = v.capacity();

45 Consider the following declarations:

struct Holder {
int* p;
Holder() {}
};

static Holder a;
Holder b;
Holder c{};

Which statement is correct immediately after construction?

46 Given the overloads below, which call is unambiguous and invokes f(int*)?

void f(int*);
void f(long);

47 A class owns a dynamically allocated array through a raw pointer and deletes it in its destructor. Which copy-policy pair provides independent ownership while preserving copyability?

48 What change is required to make deletion through p well-defined and ensure both destructors run?

struct Base { ~Base() {} };
struct Derived : Base { ~Derived() {} };
Base* p = new Derived;
delete p;

49 Assuming C++17, what does the following code print?

struct S {
int x = 1;
auto make() {
return [*this]() mutable { return ++x; };
}
};
S s;
auto g = s.make();
std::cout << g() << g() << s.x;

50 What is the status of the final statement?

struct Base { virtual int id() const { return 1; } };
struct Derived : Base { int extra = 0; int id() const override { return 2; } };
Derived objects[2];
Base* p = objects;
std::cout << p[1].id();

51 What are the values of a.size(), b.size(), and a.size() after the final assignment?

std::string a = "ab\0cd";
std::string b("ab\0cd", 5);
std::size_t first = a.size();
std::size_t second = b.size();
a.assign(b.data() + 1, 3);

52 What pair is printed by this code?

std::string s = "bananana";
std::cout << s.find("ana", 2) << ','
<< s.rfind("ana", 4);

53 What is the value of s after the operation below?

std::string s = "abcdef";
s.replace(1, 3, s, 2, 3);

54 What does the following code print?

int a = 1, b = 2;
int& r = a;
int* p = &a;
r = b;
p = &b;
*p = 5;
std::cout << a << ',' << b << ',' << r;

55 Which function template can accept int matrix[2][3] without a cast while retaining both array extents at compile time?

56 A class has the member int data[2][3];. Which member-function declaration returns a pointer to the entire selected row, preserving its three-element array type?

57 What does this code print?

struct B { int x = 1; };
struct D : B { int y = 2; };
int B::* pb = &B::x;
int D::* pd = pb;
D d;
d.*pd = 7;
std::cout << d.x << d.y;

58 What does the following code print?

int a[] = {10, 20, 30, 40, 50};
int* p = a + 5;
std::ptrdiff_t n = p - a;
--p;
std::cout << n << ':' << *p;

59 For the owning class below, which move operations correctly transfer ownership without leaking or double-deleting the allocation?

class Owner {
int* p;
public:
explicit Owner(int v) : p(new int(v)) {}
~Owner() { delete p; }
Owner(const Owner&) = delete;
Owner& operator=(const Owner&) = delete;
};

60 What does this code print?

std::string s = "abcdef";
auto it = s.erase(s.begin() + 1, s.begin() + 4);
std::cout << *it << s;