W6: Intro to the Standard Library

Question 1

What component of the standard library is not declared in the std namespace?

Answer 1

The filesystem component

namespace filesystem

Question 2

The string library provides support for three types of strings:

Answer 2

the string classes

the string_view classes

null terminated C-style string functions

Question 3

String class specializations:

Answer 3

std: :string (>)
std: :wstring (>)
std: :u16string >)
std: :u32string >)

Question 4

String class public member functions:

operator=

operator[]

size()

substr()

operator+=

Answer 4

• assigns a string to the current string
• accesses a specified character in the string
• the number of characters in the string
• returns a substring of the string
• append a character or a string to the current string

Question 5

String class public member functions:

find(char c)
rfind(char c)
find_first_of(char c)
find_last_of(char c)
find_first_of(basic_string_view(const CharT* s))
find_last_of(basic_string_view(const CharT* s))

Answer 5

• find the first occurence of c in the string
• find the last occurence of c in the string
• find the first occurence of c in the string
• find the last occurence of c in the string
• find the first occurence of any character in the sequence s
• find the last occurence of any character in the sequence s

Question 6

a string type keeps track of the number of characters in the string through an instance variable without using the null byte as a terminator. A string object can include one or more null byte (‘\0’) characters.

What is the output:

 #include 
 #include 

 int main() {
     std::string str("Hello");
     str += '\0'; // adds a null byte
     str += " World"; // adds a string
     int i = 0;
     for (const auto& c : str)
         if (str[i++] == '\0')
             std::cout << "Null byte at str["
              << i-1 << "]\n"; 
     std::cout << str << std::endl;
 }

Answer 6

Null byte at str[5]

Hello World

Question 7

string_view library characteristics:

Answer 7

• avoids redundant copying of strings
• does not own the string, read only
• read only view into a contiguous sequence of characters

Question 8

string_view class specializations

Answer 8

std: :string_view (>)
std: :wstring_view (>)
std: :u16string_view >)
std: :u32string_view >)

Question 9

What operators does the string_view class omit from the string class?

Answer 9

operator +=

operator&raquo_space;

Question 10

A complete programming solution to the implementation of a data structure requires:

Answer 10

the definition of the data type of each element in the data structure

the choice of the optimal data structure to collect the elements

the function object for the algorithm to use on the data structure

syntax to access the facilities of the STL

Question 11

lvalue and rvalue Distinction

Answer 11

std: :ref() () - returns an lvalue reference to its argument
std: :move() () - returns an rvalue reference to its argument

Question 12

C++17 introduced new library facilities. They include:

Answer 12

std::string_view () - a read-only contiguous sequence of characters (see above)
std::variant() () - represents a type-safe union
std::optional () - may or may not contain a value (beyond scope)
std::any () - single values of any type (beyond scope)
std::uncaught_exceptions () - stack is in the process of unwinding
Uniform container access std::size std::empty std::data - number of elements, emptiness, direct access to underlying array
Special Mathematical Functions () -= (beyond scope)
Filesystem Library filesystem:: () - facilities for performing operations on file systems and their components including paths, regular files and directories (beyond scope)

Question 13

class template std::variant represents:

Answer 13

a type-safe union

Question 14

The value of a variant can be accessed by

Answer 14

using its type if it’s unique

using its index

Question 15

variant class template member functions include:

Answer 15

operator=(v) - assigns value of variant v to the left operand
index() - returns the index I of the variant stored in the current object

Question 16

variant class template helper functions include:

Answer 16

std: :get(v)- returns value of variant v given the type T
std: :get<i>(v) - returns value of variant v given the index I</i>

Question 17

variant class template helper classes include:

Answer 17

std::bad_variant_access - exception thrown on invalid access

Question 18

What will be the output?

Answer 18

#include 
 #include 

 int main() {
     std::variant a, b;
     a = 12l; // a contains a long
     b = std::get(a);
     std::cout << b << std::endl;

     try {
         double c = std::get(b);
         std::cout << c << std::endl;
     }
     catch(std::bad_variant_access& bva) {
         std::cout << "bad type access" << std::endl; 
     }
 }