cmsc 202 exam 2

Pointers, Vectors, Dynamic Memory, Overloaded Operators, Linked Lists, Object Relationships

Parts of a variable

scope, memory address, variable name (identifier), and the value of the variable

Pointer

a type of variable that holds a memory address. Allocates 8 bytes

Initializing pointer

\*ptrVar = &var2; uninitialized pointers may cause issues in code if used. Types must match

Address-of operator

Gets the address of the variable

Deferencing pointers

Use the asterisk again on the variable to get the value of the variable

Pass by value parameters

The inserted argument in the parameter is passed by value, a local copy is created in the function and only changed there.

Pass by reference paramaters

void fxn(int &var); Gives function access to the original variable and changes it permanently. To protect var, use const keyword.

Function overloading

There is more than one function signature with same name but different parameter lists. Allows same tasks to be performed but with different data

Abstraction

Separates code use from implementation. Ex: user can use vectorName.push_back() but does not know how push_back was implemented

Encapsulation

A form of abstraction and information hiding. The data and functions that are located inside a class is considered encapsulation

Structure

collection of values of different types; has member variables and/or functions;

Initialization list

Used to initializing the data members of a class

Vectors

vector name; OR

vector name (size, n)

Disadvantages of vectors

inserting and deleting elements in the middle, sorting, and requires contigous block of memory

Copy constructor of vector

vector name (otherVector), creates a copy of another existing vector when declaring a new oen

Accessing vectors

vector\[index\] = num;

vector.at(index) = num;

At()

does bound checking and will throw an exception when out of bounds. Will cause program to terminate. Is slower than \[\]

Vectors as function parameters

Vectors are passed by value. Can pass by reference by using & in the function prototype

Resize()

Changes the size of the vector

void resize(n, val);

n is the new size, val is optional and used to initialize new elements

Push_Back

void push_back(val);

val is the new element being added to the vector. Must be the same type as the vector.

size()

Returns the number of elements in a vector;

returns an unsigned integer, may need to typecast it

Compile Time/Static Allocation

the memory allocated by the compiler for named variables;

use memory from the stack;

exact size and type of storage must be known at the compile time

Stack

where local variables and pass by value parameters are stored

Dynamic memory allocation

memory is allocated on the fly during runtime; the dynamic memory is placed in the heap;

pointers are necessary for dynamic allocation

Heap

where dynamically allocated memory is stored

Initializing a variable dynamically

\* ptrName = new varName;

\* ptrName = new varName(params);

Deallocating memory

when memory is being allocated dynamically, must delete it. use delete keyword

delete ptrName;

ptrName = nullptr;

For arrays: delete\[\]

Nullptr

indicates the pointer is not pointing to something

Destructor

For every class that dynamically allocates memory, a destructor is necessary. Destructors destroy the object and deallocates memory. Is called when delete keyword is used

\~ClassDestructor();

Memory leaks

occurs when dynamic memory is not allocated. If left unchecked, leak will accumulate (continually using computer resources) and crash program

Valgrind

Is used to check for memory leaks;

valgrind ./executablefile

Linked list

dynamic data structure that uses nodes and allows for easy insertion and deletion

Pros of linked list

changes size easily and constantly, easy insertion and deletion, only one node needs to be contigously stored

Cons of linked list

can’t randomly access data w/o sequential iteration, requires memory management, pointer to next node takes up more memory

Parts of a linked list

Must have a m_head but m_tail is optional. Last node must point to nullptr.

Node

an element of a linked list. Consists of two main parts: the data and the pointer pointing to the next node. Can be a class or struct

Deleting nodes

Can loop through linked list to individually delete each node. Set head, tail, and other node pointers (like temp) to nullptr.

Special cases for linked list

empty linked list, only one element in linked list, and multiple nodes in the linked list.

Linked list class implementation

Constructor, destructor, insert(), remove(), display/printList(), isEmpty()

Traversing through linked list

create node pointer Node\* temp = mhead;

create loop while (temp != mhead)

output data cout << temp→mdata/GetData() << “→”;

move temp temp = temp→mnext

Removing node at X position

check powerpoint lol…

Arrow operator

Deferences a pointer (\* asterisk operator)) and accesses member functions/variables (dot operator). Can be used when inserting nodes

Enumeration

Type of variable that holds a collection of named or unnamed constant integers.

Benefits of enums

allows user to restrict assignments to only valid values;

unnamed types can manage large list of constants but does not prevent invalid values

Enumeration variables

If the integer variable is not assigned a number, it will assign it the number of the previous variable + 1. Ex:

enum Random = {A = 1, B, C = 4, D}

B = 2 and D = 5. If A had no number, A = 0

Overloaded operators

Allows us to use operators that would not regularly work for user-defined items. Create overloaded operators as member functions in a class.

Operators that cannot be overloaded

scope ::, ternary ?:, dot ., asterisk \*

Friend

Friend keyword gives outside operators access to the private members in a class

Code Reuse

important for successful coding, efficient, and error free (code has been tested throughly)

Inheritance (is-a relationship)

When a specialized class (child, derived, subclass) inherits the members from a general class (parent, base, superclass)

How Child class can inherit Parent members

Members of the parent class must be in protected access modifier or use getters and setters if in private

Makefile for parent and child classes

Every child class should have a ParentClass.o so that it checks if the parent class was built first.

Composition (has-a relationship)

When two or more classes are dependent on each other. Ex: Car class has a Chassis object (Chassis is a class) in it. If car object is destroyed, so is chassis object

Aggregation (has-a relationship)

A class has some kind of link to another class through the use of a pointer. Ex: Car class is linked to a Driver object (Driver is a class) by using a pointer

Child’s use, extend, and replace

Use - use parent class behaviors (functions)

Extend - child creates new behaviors (specific for its class)

Replace - child classcan override the parent’s version of the same function

Replacing/Overriding

Uses the same function signature but different implementation. Only possible through inheritance. The child class can call either its version or parent’s version by using scope resolution operator. Ex:

Parent → Vehicle::Drive() Child → Car::Drive()

Overriding vs Overloading

Overriding takes precedence over overloading, so be careful if you want to overload functions within parent and child classes

Initialization lists

Populates variables without creating multiple objects at once. Ex:

Oboe(string name, int numReeds, string type) : Woodwind(name, numReeds) {}

Oboe is child class and Woodwind is parent

Polymorphism

The ability to manipulate objects in a type-independet way. Use a pointer to point at a parent class that will point to an object of a child class. Ex:

Vehicle \*vehiclePtr =&myCar

Limitation of polymorphism

Parent classes do not inherit the child class’ members so the pointer cannot access the child’s members. Use a virtual function

Virtual functions

Virtual functions allow the child class’ function to be called instead of the parent class’ in polymorphism. Use virtual keyword in the parent class’ prototype (in header file).

virtual void Drive();

Late binding

How virtual functions are implemented in C++. Late binding is determined at run time. The program will run but will not use the parent version’s of the class but instead the child class’ version.

Virtual functions and polymorphism

The program will run but will not implement the parent class’ version of a function but instead the child’s version

Purely virtual functions

virtual void Drive() = 0;

Any class that has a purely virtual function becomes an abstract class,

No implementation of the function in parent class but must implement the function in child class

Abstract class

A class that has a purely virtual function. Cannot create any objects of the class.

Virtual function tables

Compiler uses these tables whenever polymorphism is used. These tables are created for classes with virtual functions and their child classes

Virtual destructor

Must be declared for any class that has virtual functions. If not declared, non-virtual destructors only invoke the base class’ destructor.

Virtual constructor

No need for them. Constructors require complete information at the time of being called but virtual functions do not have the complete information at the time.