cpp vector<int> v(22); bool b = (v[6]); printf("%d", !b);1.
False
2.
0
3.
1
4.
This code has an error.
Q 1 / 72
cpp Using namespace std;1.
The compiled code is always bigger because of all of the imported symbols.
2.
If the code uses a function defined in two different libraries with the same prototype but possibly with different implementations, there will be a compilation error due to ambiguity.
3.
It automatically includes all header files in the standard library (cstdint, cstdlib, cstdio, iostream, etc).
4.
It causes the compiler to enforce the exclusive inclusion of header files belonging to the standard library, generating compilation error when a different header file is included.
Q 2 / 72
cpp typedef struct{ unsigned int age : 4; unsigned char gender : 1; unsigned int size : 2; }child_t;1.
7 bits.
2.
25 bytes.
3.
1 bit.
4.
1 byte.
Q 3 / 72
cpp std::vector<int> v1{1,2,3},v2; v2=v1; v1.push_back(4); v2.push_back(5);1.
Error
2.
v1:{1,2,3,4}; v2:{5};
3.
v1:{1,2,3,4,5}; v2:{1,2,3,4,5};
4.
v1:{1,2,3,4}; v2:{1,2,3,5};
Q 4 / 72
1.
While pointers are variable that hold memory address, iterators are generic functions used to traverse containers. These function allows the programmer to implement read and write code as the container is traversed.
2.
Incrementing an iterator always means access the next element in the container(if any), no matter the container. Incrementing the pointer means pointing to the next element in memory, not always the next element.
3.
Pointers are variables that hold memory address where as iterator are unsigned integers that refers to offsets in arrays.
4.
All iterator are implemented with pointers so all iterators are pointers but not all pointers are iterators.
Q 5 / 72
cpp int median(const my_array& a);1.
The argument is passed as a reference, so the function receives a copy that can be modified without affecting the original value.
2.
The argument is passed as a reference, so if the passed my_array object is large, the program will require less time and memory.
3.
Actually objects can't be passed as regular variables because they require a constructor call. Therefore a const reference is the only way to pass class instances to functions.
4.
There are no benefits because a reference and an object are treated as the same thing.
Q 6 / 72
cpp union { unit16_t a; unit32_t b; int8_t c; } u1;1.
4 bytes
2.
7 bytes
3.
8 bytes
4.
2 bytes
Q 7 / 72
1.
`?:`
2.
`new`
3.
`::`
4.
`.`
Q 8 / 72
cpp std:: vector<int> *v1 = new std::vector<int>({1,2,3}); std:: vector<int> *v2; v2=v1; v1->push_back(4); v2->push_back(5); v1 and v2 point to the same vector.1.
`*v1:{1,2,3,4}; *v2:{5};`
2.
`*v1:{1,2,3,4,5}; *v2:{1,2,3,4,5};`
3.
Error
4.
`*v1:{1,2,3,4}; *v2:{1,2,3,5};`
Q 9 / 72
1.
Because structs are part of the C programming language, there are some complexity between C and C++ structs. This is not the case with classes.
2.
Classes may have member functions; structs are private.
3.
The default access specifier for members of struct is public, whereas for member of class, it is private.
4.
Template type parameters can be declared with classes, but not with the struct keyword.
Q 10 / 72
cpp typedef struct { int sunday:1; int monday:1; // more days int friday:1; int saturday:1; } weekdays; cpp typedef char[7]: weekdays; cpp typedef struct { bit sunday:1; bit monday:1; // more days bit friday:1; bit saturday:1; } weekdays; cpp typedef struct { bit sunday; bit monday; // more days bit friday; bit saturday; } weekdays; _NOTE_: Correct syntax is that each variable size is 1 bit. `bit` is not a type in C++. [Reference](https://en.cppreference.com/w/cpp/language/bit_field)1.
A
2.
B
3.
C
4.
D
Q 11 / 72
1.
It's a constant expression, meaning an expression composed of constants and operations.
2.
It's an expression that represents an object with an address.
3.
It's an expression suitable for the left-hand side operand in a binary operation.
4.
It's a location value, meaning a memory address suitable for assigning to a pointer or reference.
Q 12 / 72
cpp auto x = 4000.22;1.
It specifies that the type of x will be deduced from the initializer - in this case, double.
2.
It specifies that the type of x is automatic meaning that if can be assigned different types of data throughout the program.
3.
It specifies that x is a variable with automatic storage duration.
4.
It specifies that more memory will be allocated for x in case it needs more space, avoiding loss of data due to overflow.
Q 13 / 72
1.
class written with the generic programming paradigm, specifying behavior in terms of type parameter rather than specific type.
2.
blank superclass intended for inheritance and polymorphism.
3.
lass that only consists of member variable, with no constructor, destructor nor member functions.
4.
skeleton source code for a class where the programmer has to fill in specific parts to define the data types and algorithms used.
Q 14 / 72
cpp if(x) y=a; else y=b;1.
`y=a?b:x;`
2.
`y=if(x?a:b);`
3.
`y=(x&a)?a:(x&b)?b:0;`
4.
`y=x?a:b;`
Q 15 / 72
cpp #include <iostream> int main(){ int x=10, y=20; std::cout << "x = " << x++ << " and y = " << --y << std::endl; std::cout << "x = " << x-- << " and y = " << ++y << std::endl; return(0); } `x = 11 and y = 19` `x = 10 and y = 20` `x = 11 and y = 20` `x = 10 and y = 19`1.
`x = 10 and y = 20`
2.
`x = 11 and y = 19`
3.
`x = 10 and y = 19`
4.
`x = 11 and y = 20`
Q 16 / 72
1.
The first is a variable declaration that will hold an element in a sequence. The second is the sequence to traverse.
2.
The first is an iterator, and the second is the increment value to be added to the iterator.
3.
The first is the iterating variable. The second is an `std::pair` that specifies the range (start and end) in which the variable will iterate.
4.
The first is a container object. The second is an `std::pair` that specifies the range (start and end) in which the elements will be accessed within the loop.
Q 17 / 72
cpp int8_t a=200; uint8_t b=100; if(a>b) std::cout<<"greater"; else std::cout<<"less";1.
There is no output because there is an exception when comparing an int8_t with a uint8_t.
2.
greater
3.
less
4.
There is no output because there is a compiler error.
Q 18 / 72
cpp int x=5, y=2; if(x & y) { /*_part A_*/ } else { /*_part B_*/ }1.
Part A executes because x==5 (true) and y==2 (true), thus the AND operation evaluates as true.
2.
Part B executes because (x & y) results in 0, or false.
3.
Part A executes because (x & y) results in a nonzero value, or true.
4.
Part B executes because the statement (x & y) is invalid, thus false.
Q 19 / 72
cpp int get_length(char *str) { int count=0; while(str[count++]); return count-1; } cpp int get_length(char *str) { int count=0; while(str!=NULL){ count++; str++; } return count; } cpp int get_length(char *str) { int count=0; while((*str)++) count++; return count; } cpp int get_length(char *str) { int count=0; while(str++) count++; return count; }1.
A
2.
B
3.
C
4.
D
Q 20 / 72
1.
`std::list`
2.
`std::vector`
3.
`std::priority_queue`
4.
`std::map`
Q 21 / 72
1.
The first is the iterating variable name, the second is the number of times to iterate, and the third is the desired increment or decrement (specified with a signed integer).
2.
The first is the initialization block, the second is the condition to iterate, and the third is the increment block.
3.
The first is the iterating variable, the second is the container in which it should operate, and the third is an exit condition to abort at any time.
4.
The first is the iterating variable name, the second is the starting value for the iterating variable, and the third is the stop value (the last value plus one).
Q 22 / 72
cpp int i = 0; printf("%d", i++); printf("%d", i--); printf("%d", ++i); printf("%d", --i);1.
0,1,1,0
2.
0,1,0,1
3.
0,0,1,0
4.
1,0,1,0
Q 23 / 72
cpp void *ptr;1.
It is a pointer initialized at NULL.
2.
It is a pointer to a void function.
3.
That declaration causes a compiler error, as pointers must specify a type.
4.
It is a pointer to a value with no specific type, so it may be cast to point to any type.
Q 24 / 72
cpp int c=3; char d='A'; std::printf("c is %d and d is %c",c,d);1.
c is d and d is c
2.
c is A and d is 3
3.
c is 3 and d is A
4.
c is c and d is d
Q 25 / 72
cpp printf("1/2 = %f",(float)(1/2));1.
1/2 = 0.499999
2.
1/2 = 0
3.
1/2 = 0.000000
4.
1/2 = 0.5
Q 26 / 72
1.
Public members are the same as global variables, so every part of the code has access to them. Private members are the same as automatic variables, so only their class has access to them.
2.
Public members are made accessible to any running application. Private members are made accessible only to the application where the object is instantiated.
3.
Public members will be compiled as shared variables in a multithreaded environment. Private members will be compiled as Thread-local variables.
4.
Public members can be accessed by any function. Private members can be accessed only by the same class's member functions and the friends of the class.
Q 27 / 72
cpp int x=10, a=-3; x=+a;1.
3
2.
7
3.
-3
4.
13
Q 28 / 72
1.
Only classes can have member variables and methods.
2.
C++ supports multiple inheritance.
3.
C++ supports only single inheritance.
4.
Only structs can inherit.
Q 29 / 72
cpp float g; void *ptr=&g;1.
`float f=*(float)ptr;`
2.
`float f=(float *)ptr;`
3.
`float f=(float)*ptr;`
4.
`float f=*(float *)ptr;`
Q 30 / 72
1.
It is the same as the class member access operator, or arrow operator `(->)`, which allows you to access a member of an object through a pointer to the object.
2.
It is the pointer to member operator, and it allows you to access a member of an object through a pointer to that specific class member.
3.
It is the member access with address of operator, which returns the address of a class or struct member.
4.
It is a combination of the member access operator `(.)` and the dereference operator `(*)`, so it allows you to access the object that a member pointer points to.
Q 31 / 72
cpp char buff[50] = "strings as arrays of characters are fun!" char *str = buff+11; char c; cpp c = buff[16]; c = str[5]; c = *(buff+16); c = *(str+5); cpp c = *(buff[15]); c = *(str[4]); c = buff+15; c = str+4; cpp c = buff[15]; c = str[4]; c = *(buff+15); c = *(str+4); cpp c = *(buff[16]); c = *(str[5]); c = buff+16; c = str+5;1.
A
2.
B
3.
C
4.
D
Q 32 / 72
cpp class Animal{ //.... } cpp class Dog :: public Animal { //.... }; cpp class Dog : public Animal { //.... }; cpp public class Animal :: Dog { //.... }; cpp public class Dog extends Animal { //.... };1.
A
2.
B
3.
C
4.
D
Q 33 / 72
cpp #include <cstdio> using namespace std; int main(){ char c = 255; if(c>10) printf("c = %i, which is greater than 10", c); else printf("c = %i, which is less than 10", c); return 0; }1.
c = -1, which is less than 10
2.
c = 255, which is greater than 10
3.
c = -1, which is greater than 10
4.
c = 255, which is less than 10
Q 34 / 72
1.
by simply calling the C code
2.
there is no way for C++ to call a C function
3.
by using extern "C"
4.
by importing the source C code
Q 35 / 72
coord center; center.x = 5; center.y = 3; cpp typedef struct coord { int x; int y; }; cpp typedef struct coord { int x; int y; } coord; cpp typedef struct { int x; int y; } coord; cpp struct coord { int x; int y; }; typedef struct coord coord;1.
A
2.
B
3.
C
4.
D
Q 36 / 72
cpp for (i=1;i<10;i++){ cout<<i<<endl; } cpp i=1; while(i<10){ cout<<++i<<endl; } cpp for (int i:{1,2,3,4,5,6,7,8,9}) { cout<<i<<endl; } cpp i = 1; do { cout<<i++<<endl; } while(i<10); cpp i = 1; loop: cout<<i++<<endl; if(i<10) goto loop;1.
A
2.
B
3.
C
4.
D
Q 37 / 72
cpp #include "library.h"1.
It causes the toolchain to compile all the contents of library.h so that its executable code is available when needed by the final application.
2.
It cherry picks library.h for the declarations and definitions of all data and functions used in the remainder of the source file main.cpp, finally replacing the `#include` directive by those declarations and definitions.
3.
It informs the linker that some functions or data used in the source file main.cpp are contained in library.h, so that they can be called in run time. This is also known as dynamic linking.
4.
It causes the replacement of the `#include` directive by the entire contents of the source file library.h. This is similar to a Copy-Paste operation of library.h into main.cpp.
Q 38 / 72
cpp bool is_even(int); cpp bool is_even(float f); bool is_even(char *str); cpp bool is_even(float f); bool is_even(char str); cpp bool is_even_float(float f); bool is_even_str(char *str); cpp float is_even(float f); char *is_even(char *str);1.
A
2.
B
3.
C
4.
D
Q 39 / 72
cpp #ifdef MY_LIBRARY_H #define MY_LIBRARY_H // my_library.h content #endif /* MY_LIBRARY_H */ cpp #ifndef MY_LIBRARY_H #define MY_LIBRARY_H // my_library.h content #endif /* MY_LIBRARY_H */ cpp #ifdef MY_LIBRARY_H #undef MY_LIBRARY_H // my_library.h content #endif /* MY_LIBRARY_H */ cpp #define MY_LIBRARY_H #include MY_LIBRARY_H // my_library.h content #undef MY_LIBRARY_H1.
A
2.
B
3.
C
4.
D
Q 40 / 72
cpp std::vector<std::vector<int>> thematrix;1.
There's nothing wrong with it.
2.
An `std::vector` cannot contain more `std::vector` containers as its elements.
3.
The correct syntax should be: `std::vector[std::vector[int]
4.
`>>` is parsed as the shift-right operator, and thus results in a compile error.
Q 41 / 72
cpp sprite->x1.
`sprite.x`
2.
`sprite.*x`
3.
`(*sprite).x`
4.
`*sprite.x`
Q 42 / 72
cpp complexNumber(float real, float im) : real_part(real), im_part(im){} cpp complexNumber(float real, float im) { this->real = real_part; this->im = im_part; } cpp complexNumber(float real, float im) { this->real_part(real); this->im_part(im); } cpp complexNumber(float real, float im) { this->real_part = real; this->im_part = im; } cpp complexNumber(float real, float im) { this->real_part = ℜ this->im_part = &im; }1.
A
2.
B
3.
C
4.
D
Q 43 / 72
cpp bool x=true, y=false; if(~x || y){ /*part A*/ } else{ /*part B*/ }1.
Part A executes because the expression `(~x || y)` always results in true if `y==false`.
2.
Part B executes because the statement `(~x || y)` is invalid, thus false.
3.
Part A executes because `~x` is not zero, meaning true.
4.
Part B executes because `~x` is false and `y` is false, thus the `OR` operation evaluates as false.
Q 44 / 72
cpp int32_t nums[3]={2,4,3}; std::cout << ( nums[0] << nums[1] << nums[2] );1.
The output is the addresses of `nums[0]`, `nums[1]`, and `nums[2]`, in that order, with no spaces.
2.
`256`
3.
`0`
4.
`243`
Q 45 / 72
cpp float values[5]={0.54f, 2.71828f, 3.14159f, 5.499999f, 10.0f}; for(auto f:values) printf("%i ",(int)(f+0.5f));1.
`0.54 2.71828 3.14159 5.499999 10.0`
2.
`1 3 4 6 11`
3.
`0 2 3 5 10`
4.
`1 3 3 5 10`
Q 46 / 72
1.
`std::priority_queue`
2.
`std::list`
3.
`std::vector`
4.
`std::map`
Q 47 / 72
cpp #include <iostream> #include <fstream> using namespace std; int main(){ ifstream file1("text1.txt", ios::binary); ofstream file2("text2.txt", ios::binary); file2 << file1.rdbuf(); }1.
It renames text1.txt to text2.txt.
2.
It makes a directory called text2.txt and moves text1.txt there.
3.
It copies the contents of text1.txt into text2.txt - i.e., it makes a copy of text1.txt, named text2.txt.
4.
It appends the contents of text1.txt into text2.txt - i.e., replaces the contents of text2.txt by the concatenation of text2.txt and text1.txt.
Q 48 / 72
cpp class my_class { public: static int count; }1.
The variable cannot be modified by any part of the code in the same application or thread. However, other threads may modify it.
2.
The variable exists even when no objects of the class have been defined so it can be modified at any point in the source code.
3.
The variable is allocated only once, regardless of how many objects are instantiated because it is bound to the class itself, not its instances.
4.
All objects that try to access their count member variable actually refer to the only class-bound static count variable.
Q 49 / 72
1.
double
2.
long float
3.
long double
4.
float
Q 50 / 72
cpp int8_t a=200; uint8_t b=100; std::cout<<"a="<<(int)a; std::cout<<", b="<<(int)b;1.
a=-56, b=100
2.
a=-55, b=100
3.
a=200, b=-156
4.
a=200, b=100
Q 51 / 72
cpp my_class *my_object = new my_class();1.
`delete(my_object);`
2.
`free(my_object);`
3.
The garbage collector will destroy the object eventually.
4.
Exiting the scope will destroy the object.
Q 52 / 72
cpp class my_array{ public: int count(); }; // ... more members above int main(){ my_array *grades = new my_array(); }; // ... more code above1.
`grades.count();`
2.
`my_array->count();`
3.
`grades->count();`
4.
`my_array.count();`
Q 53 / 72
cpp int i0=4, i1=6, i2=8; int& nums[3]={i2,i0,i1}; std::cout<<nums[0]<<nums[1]<<nums[2];1.
There is no output. The code causes a compiler error because `nums` is an array of references, which is illegal.
2.
846
3.
The output is the addresses of `i2`, `i0`, and `i1`, in that order, with no spaces.
4.
468
Q 54 / 72
cpp typedef struct{ unsigned int age : 4; unsigned char gender : 1; char : 0; unsigned int size : 2; }child_t;1.
Yes, it causes a compiler error because the colon character is not allowed in struct definitions.
2.
and `child_t` is a type defined as a structure with bit fields. It has 4 bits for age and 1 bit for gender in the first byte, and 2 bits for size in the second byte.
3.
Yes, it causes a compiler error because there is an unnamed field.
4.
Yes, it causes a compiler error because one field is defined as having a size of 0.
Q 55 / 72
cpp A->B->C->D1.
`A.B.C.D`
2.
`*A.*B.*C.*D`
3.
`&A.&B.&C.&D`
4.
`*(*((*A).B).C).D`
Q 56 / 72
cpp auto buff = new char[50]; std::memset(buff,20,50);1.
It declares a memory buffer named buff that starts at address 20 and ends at address 70.
2.
It sets all bits in the array named buffer from its element at index 20 to its element at index 50.
3.
It writes the value 20 in every memory address from buff to buff+49.
4.
It declares a memory buffer named buff that starts at address 20 and ends at address 50.
Q 57 / 72
1.
`CustomData& operator++();`
2.
`void operator++(CustomData);`
3.
`CustomData operator++(CustomData);`
4.
`CustomData operator++(int);`
Q 58 / 72
cpp std::array<uint32_t, 50> my_array; cpp std::sort(my_array.begin(), my_array.end(), [](uint32_t a, uint32_t b) { return a < b; }) cpp lambda(uint32_t a, uint32_t b){ return a < b; } std::sort(my_array.begin(), my_array.end(), lambda); cpp std::sort(my_array.begin(), my_array.end(), lambda(uint32_t a, uint32_t b){ return a < b; }) cpp lambda(uint32_t a, uint32_t b){ return a < b; } std::sort(my_array.begin(), my_array.end(), &lambda);1.
A
2.
B
3.
C
4.
D
Q 59 / 72
cpp void std::mutex::lock(){ while(!this->try_lock()); } cpp void std::mutex::lock(){ return (this->try_lock()); } cpp void std::mutex::lock(){ while(1) this->try_lock(); } cpp void std::mutex::lock(){ while(this->try_lock()); }1.
A
2.
B
3.
C
4.
D
Q 60 / 72
1.
It allows the programmer to write the necessary code to free the resources acquired by the object prior to deleting the object itself.
2.
It deletes an object. One example of a destructor is the `delete()` function.
3.
It terminates a program. This may be achieved as a regular function call or as an exception.
4.
There are no destructors in C++.
Q 61 / 72
1.
`std::priority_queue`
2.
`std::map`
3.
`std::vector`
4.
`std::list`
Q 62 / 72
cpp std::mutex::lock() std::mutex::try_lock()1.
`lock()` has a higher privilege over `try_lock()`. This means that you have a better chance of acquiring a mutex `with lock()`.
2.
Both attempt to acquire a lock, but `lock()` blocks if the mutex is not available, whereas `try_lock()` returns whether the mutex is available or not.
3.
`lock()` enforces preemption, whereas `try_lock()` suggests preemption.
4.
If the mutex is not available, `try_lock()` returns with a corresponding code, whereas `lock()` snatches the mutex from the thread that currently has it.
Q 63 / 72
cpp int median(const my_array& a) Note: This one is similar to Q6, but focuses on the `const` keyword.1.
Actually, objects cannot be passed as regular variables, because they require a constructor call. Therefore, a `const` reference is the only way to pass class instances to functions.
2.
There are no benefits because a reference and an object are treated as the same thing.
3.
The `const` qualifier Forbids the code to modify the argument, so the programmer can rest assured that the source object will remain unchanged.
4.
The argument is passed as a reference, so the Function receives a copy that can be modified without affecting the original variable.
Q 64 / 72
1.
a preprocessor directive that prevents inconsistent behaviors in lines that contain the #ifdef, #ifndef, or #elif directives
2.
a compiler option that prevents the user code from including additional libraries
3.
a preprocessor statement that prevents a source file from being included more than once in a project
4.
a library that adds safety features such as mutexes, watchdog timers, and assertions to the project
Q 65 / 72
cpp public: Sprite(); cpp private: void Sprite(); cpp public: void Sprite(); cpp private: Sprite();1.
cpp
public:
Sprite();
2.
cpp
private:
void Sprite();
3.
cpp
public:
void Sprite();
4.
cpp
private:
Sprite();
Q 66 / 72
cpp #pragma once1.
to restrict the use of its contents to only one source file
2.
to tell the compiler that only one variable can be instantiated from the classes or types contained in this header file
3.
to help the compiler finish faster by assuring that only one compiler pass is neccessary for the code included in this header file
4.
to make the compiler parse that header file only once, even if it is included multiple times in the source
Q 67 / 72
1.
a 2-tuple
2.
an integer number
3.
a floating point number
4.
a string with more than 255 characters
Q 68 / 72
cpp bool is_even(int);1.
bool is_even(float f); bool is_even(char *str);
2.
bool is_even(float f); bool is_even(char str);
3.
bool is_even_float(float f); bool is_even_str(char *str);
4.
float is_even(float f); char *is_even(char *str);
Q 69 / 72
1.
shifting characters to the left in a string.
2.
inserting characters into an output stream like std::cout.
3.
comparing floating point numbers as less-than.
4.
assigning a variable to a reference.
Q 70 / 72
cpp typedef struct{ unsigned int age : 4; unsigned char gender : 1; char : 0; unsigned int size : 2; }child_t;1.
Yes, it causes a compiler error because the colon character is not allowed in struct definitions.
2.
and `child_t` is a type defined as a structure with bit fields. It has 4 bits for age and 1 bit for gender in the first byte, and 2 bits for size in the second byte.
3.
Yes, it causes a compiler error because there is an unnamed field.
4.
Yes, it causes a compiler error because one field is defined as having a size of 0.
Q 71 / 72
### Q73. What is wrong with this piece of code? cpp #include <iostream> char str[20]' int main(){ std::cout << "What's your name? "; str << std::cin std::cout << "Hello, " << str; return 0; }1.
The compiler needs the dara type to make sure that the pointer is not going to be used on illegal non-pointable types such as functions, labels, pointers, and reference.
2.
`void *` does not work for any type. The language does not allow assigning anything other than `void` to a pointer to `void *`.
3.
The compiler needs the data type to know how much memory to allocate for the pointer, because different data types require different pointer lengths.
4.
Yes, it causes a compiler error because one field is defined as having a size of 0.
5.
The main function is supposed to have a void return type.
6.
`std::cin` and `std::cout` are invalid. The correct names for the character input and output streams are `cin` and `cout`.
7.
The address of `str` is supposed to be used. That is `&str` instead of `str`.
8.
The input operator flow is inverted. it should start from `std::cin` and then flow (>>) into `str`.
Q 72 / 72