C++ Flashcards
Import dictionary
import <unordered_set></unordered_set>
Import dynamic array
include <vector></vector>
Insert element in a dynamic array
arrayName.push_back(element);
Sort dynamic array
include <algorithm></algorithm>
sort(array.begin(), array.end());
Loop through elements in an array
for(int element : array)
Declare a set
unordered_set<int> newSet;</int>
Add element to a set
newSet.insert(element);
Check element is in a set
if( newSet.find(potentialElement) != newSet.end() )
Array length
array.size()
Absolute value
include <cmath></cmath>
abs(value);
Get last element in an array
array.back();
Using auto types
include <any></any>
auto element;
int intVariable = any_cast<int>(element);</int>
Int min/max
include <climits></climits>
INT_MIN
INT_MAX
Short min/max
include <climits></climits>
SHRT_MIN
SHRT_MAX
Unsigned max
include <climits></climits>
UINT_MAX
Long min/max
include <climits></climits>
LONG_MIN
LONG_MAX
Array is empty
array.empty();
Array swap elements
include <vector></vector>
swap(array[i], array[i+1]);
String length
string myString;
myString.length()
Create dictionary
include <unordered_map></unordered_map>
unordered_map<char, int> myMap;
Max int
max(intOne, intTwo);
Min int
min(intOne, intTwo);
Set array element
include <vector></vector>
myArray.at(i) = x;
y = myArray.at(i);
Get first element in array
include <vector></vector>
myArray.first();
myArray[0];
Double ended queue
include <deque></deque>
deque<SomeClass *> myDeque;
myDeque.insert(mySomeClass);
first = myDeque.first();
last = myDeque.back();
size = myDeque.size();
Sort array with custom sort function
Default generated class methods
- a default constructor X(), that calls the default constructor of each class member and base class,
- a copy constructor X(X const& other), that calls a copy constructor on each member and base class,
- a copy assignment operator X& operator=(X const& other), that calls a copy assignment operator on each class member and base class,
- the destructor ~X(), that calls the destructor of each class member and base class. Note that this default-generated destructor is never virtual (unless it is for a class inheriting from one that has a virtual destructor).
- a move constructor X(X&& other), that calls a move constructor of each class member and base class,
- a move assignment operator X& operator=(X&& other), that calls a move assignment operator on each class member and base class.
What cases could warrant the creation of methods where defaults are created?
- when the class uses raw pointers or resources like database connections
- when owned resource life cycles need to be managed
When considering default class functions, what is the Rule of 3 and the Rule of 5?
If you need to write the code for one of the x resource management functions, it suggests that your class’s resource handling is not trivial and you certainly need to write the other x – 1. – Rule of x
Rule of 3 is for C++ 98 and Rule of 5 is for C++ 11
When does the compiler not generate normally generated default functions?
- when you define them
- if the compiler can’t generate an operator= like when the class contains a const or reference member
- if you write a direct constructor, a copy constructor, or a move constructor
- if you write a copy constructor, copy assignment constructor or delete, then the compiler won’t generate a move constructor
- if you write a move or move assignment constructor, then the compiler won’t generate any other default functions
What does = default do?
Forces the compiler to generate the default function.
What does = delete do?
Forces the compiler to explicitly remove the default function.
What is YAGNI
You Ain’t Gonna Need It
What is DRY
Don’t Repeat Yourself
static_cast syntax
int i = static_cast<int>(val);</int>
static_cast uses
- Compile-time cast that does implicit conversion between types.
- will throw compiler error if conversion is not valid
const_cast syntax
Type nonConstValue = const_cast<Type>(constValue);</Type>
const_cast uses
- change non-const member in a const function
- to pass const value to a function that does not accept const parameter
- It is undefined behavior to change a value that was initially declared as const
- can be used instead of simple type casting as it will fail if the provided value and the cast value are not the same type
- cast away a volatile flag
reinterpret_cast syntax
data_type *var_name = reinterpret_cast <data_type *>(pointer_variable);
reinterpret_cast uses
- used to convert a pointer from one type to another
- doesn’t check if the before and after types are the same
- reinterpret_cast is a very special and dangerous type of casting operator. And is suggested to use it using proper data type i.e., (pointer data type should be same as original data type).
- It can typecast any pointer to any other data type.
- It is used when we want to work with bits.
- If we use this type of cast then it becomes a non-portable product. So, it is suggested not to use this concept unless required.
- It is only used to typecast any pointer to its original type.
Boolean value will be converted into integer value i.e., 0 for false and 1 for true.
dynamic_cast syntax
DerivedType* derivedVal = dynamic_cast<DerivedType*>(baseValue);
dynamic_cast uses
- cast a base object as a derived type
- runtime check
- requires base to have at least one virtual function
- if cast fails and is casting to a pointer type, it returns NULL
- if cast fails and is casting to a reference type, it throws an error
