C / C++

Question 1

What does the Indirection Operator do, and which symbol is it?

Answer 1

Dereferences a pointer, *

Question 2

What kind of variable is this: “int &bruhh = bruh;”

Answer 2

Reference Variable (for the “bruh” int variable)

Question 3

What kind of variable is this: “int *bruh;”

Answer 3

Pointer Variable (to any int variable)

Question 4

How do you get the value of what a Pointer Variable is pointing to

Answer 4

Use * again after initialized, like:
C: cout < < *bruh

Question 5

Which can be reassigned: pointers or references

Answer 5

Pointers

Question 6

How do you get the address for a variable?

Answer 6

Use the & operator, like:
C: cout < < &bruh;
T: 0x4a00

Question 7

What is the key word for the 0 address

Answer 7

nullptr

Question 8

What is “nullptr”?

Answer 8

The 0 address

Question 9

What is the * operator called to dereference a pointer

Answer 9

Indirection Operator

Question 10

How do you get the first value of an array without using []

Answer 10

Use the * operator, like:
C: int bruh[] = {10,20,30};
C: cout < < *bruh;
T: “10”

Question 11

How do you create an alias for an array?

Answer 11

Use a Pointer Variable

Question 12

How do you easily print a newline?

Answer 12

Use the endl keyword, like:
C: cout &laquo_space;“bruh” &laquo_space;endl

Question 13

Using the * operator for an array pointer, how do you reference an element that is not at index 0

Answer 13

Need to wrap with parenthesis after * and add to the pointer (or array), like:
C: int bruh[] = {10,20,30}, *p;
C: p = bruh;
C: cout < < *(p+1) < < endl < < *(bruh+2);
T: “20”
T: “30”

Question 14

How can you change a pointer without reassigning it, and why is this useful?

Answer 14

Since it represents an address, you can increment/decrement with the “++” and “–” operators, which is useful if it is pointing to an array, like:
C: int bruh[] = {10,20,30}, *p;
C: cout < < *p < < endl < < *(++p);
T: 10
T: 20

Question 15

How do you initialize a pointer for a variable efficiently

Answer 15

You can do it on the same line as the variable initialization, like:
C: int bruh, *b = &bruh;

Question 16

What is an important difference of pointer assignment between Arrays and non-aggregate variable types

Answer 16

Since using Arrays in the code is treated as its address, you can assign the Array to the pointer directly without extra operators, whereas non-aggregate variables you must refer to their address with the & operator, like:
C: int var, array[], *pointer;
C: pointer = &var; // valid
C: pointer = array; // valid

Question 17

Can you assign a pointer to any kind of variable?

Answer 17

No, you initialize pointers with the type

Question 18

How do you test if a pointer is invalid?

Answer 18

This question is slightly misleading, because invalid can either mean it is not assigned yet, or it is assigned the null pointer. If it is not assigned yet, you cannot test this in the code because you really cannot do any operations on uninitialized variables without throwing an error. If it is assigned to address 0 (nullptr) then you can simply use the variable with or without the “!” operator directly in an “if” condition because it is treating the condition as if it was an int variable, like:
C: int var = 0, p;
C: if (p) {}; // this will throw errors
C: p = &var;
C: if (p) {}; // this will execute
C: if (p) {}; // this will NOT execute, because the variable is 0
C: p = nullptr;
C: if (!p) {}; // this will execute

Question 19

What is the * operator called and what does it do

Answer 19

Indirection Operator, dereferences a pointer

Question 20

How do you change the value of a variable passed to and within a function?

Answer 20

Have a pointer parameter for the variable and use the & operator on the variable for that argument and reassign a value to it within the function by dereferencing it with the Indirection Operater *.

Question 21

What is important to know for const values when needing to reference them in a function

Answer 21

You have to specify that the pointer parameter is a const

Question 22

How do you make the pointer immutable, and what is an important thing to remember about doing this

Answer 22

Add const to the initialization, and you have to initialize it, like:
C: int * const constPointer; // This will throw an error
C: int var1 = 1, * const constPointer = &var1, var2 = 2;
C: cout < < *constPointer; // Prints “1”
C: constPointer = &var2; // This will throw an error

Question 23

How can you use a pointer like a variable? What is this topic called?

Answer 23

You can initialize the pointer and assign to a new address using the “new” keyword/operator, which regards Dynamic Memory Allocation, like:
C: int *p = new int;
C: *p = 2;
C: cout < < *p; // Prints “2”

Question 24

How do you clear out the memory at the address that a pointer has? What if the pointer is for an array? What if the pointer is assigned to nullptr?

Answer 24

Use the ‘delete’ keyword/operator, like:
C: delete p;
C: delete [] pArray;

The ‘delete’ operation does nothing if it is pointing to nothing (null, 0).

Question 25

You can return pointers from a function, but what must it point to?

Answer 25

It must be pointing to dynamically allocated memory (using the ‘new’ operator) or to an address given to the function as an argument (the only thing that makes sense for this would be a given Array, so you’re essentially returning a literal address instead of an index).

Essentially, it must NOT be a pointer for a variable local to the function.

Question 26

What are those # things at the top of the source code called?

Answer 26

Header files

Question 27

What are the 3 types of Smart Pointers, what are their keywords, what do they do, and what header file do you need, and what is the initialization syntax?

Answer 27

1. Unique (unique_ptr), ??
2. Shared (shared_ptr), ??
3. Weak (weak_ptr), ??
   #include <memory>
   Example:
   C: unique_ptr<int> p (new int); // Creates a Unique int pointer named 'p'</int></memory>