Scribd
Upload
8 views9 pages

Cheatsheet

This C++ midterm revision cheatsheet covers essential concepts such as functions, pointers, arrays, memory allocation, classes, objects, access specifiers, constructors, destructors, and operator overloading. It also includes tips on dynamic object creation, shallow vs deep copy, and function overriding. Key programming principles like encapsulation, abstraction, and inheritance are highlighted with syntax examples.

Uploaded by

malikadeel14235
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
8 views9 pages

Cheatsheet

This C++ midterm revision cheatsheet covers essential concepts such as functions, pointers, arrays, memory allocation, classes, objects, access specifiers, constructors, destructors, and operator overloading. It also includes tips on dynamic object creation, shallow vs deep copy, and function overriding. Key programming principles like encapsulation, abstraction, and inheritance are highlighted with syntax examples.

Uploaded by

malikadeel14235
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 9

� C++ Midterm Revision Cheatsheet

1. Functions

 Reusable block of code.


 Syntax:

return_type function_name(parameters) {
// body
}

 Example:

int add(int a, int b) { return a + b; }

2. Pointers

 Stores the address of a variable.


 Syntax:

int a = 10;
int* ptr = &a;
cout << *ptr; // prints 10

3. Arrays

 Collection of elements of the same type.


 Syntax:

int arr[3] = {1, 2, 3};

4. Concept of Memory Allocation

 Static: Memory is allocated at compile time.


 Dynamic: Memory allocated at runtime using new/delete.
5. New Operator

 Allocates memory dynamically.


 Syntax:

int* ptr = new int;


*ptr = 5;
delete ptr;

6. Classes

 Blueprint for objects.


 Syntax:

class ClassName {
// members
};

7. Objects

 Instance of a class.

ClassName obj;

8. Access Specifiers

 public: accessible anywhere.


 private: accessible only inside the class.
 protected: accessible in derived classes.

9. Member Functions

 Functions defined inside a class to access or modify data members.


10. Constructor

 Special function that runs when an object is created.

class A {
public:
A() { cout << "Constructor"; }
};

11. Parameterized Constructor

 Constructor with parameters.

A(int x) { value = x; }

12. Constructor Overloading

 Multiple constructors with different parameters.

A() {}
A(int x) {}
A(int x, int y) {}

13. Destructor

 Cleans up memory.

~A() { cout << "Destructor"; }

14. Abstraction

 Hiding internal details and showing only essential info.


 Achieved using classes & access specifiers.

15. Encapsulation
 Wrapping data and methods into a single unit (class).
 Achieved using private data and public methods.

16. Static Variables

 Shared among all objects.


 Initialized once.

static int count;

17. Constant Data Member

 Value cannot change once assigned.

const int max = 100;

18. Constant Member Function

 Does not modify class members.

void show() const;

19. Constant Static Variable

 Must be initialized outside the class.

static const int max;


const int ClassName::max = 100;

20. Friend Function

 Can access private/protected members.


friend void display(ClassName obj);

21. Operator Overloading

 Redefine operators.

ClassName operator+(ClassName obj);

22. Inheritance

 One class inherits another.

class A {};
class B : public A {};

✅ Tips:

 Always match constructor names with class names.


 Use this-> to refer to the current object inside class.
 Constructors can’t return values.
 Destructors have ~ and no parameters.

✅ Pointer to Object

 You can create a pointer that points to an object.

class A {
public:
void show() { cout << "Hello"; }
};

int main() {
A obj;
A* ptr = &obj;
ptr->show(); // Use -> for member access through pointer
}

✅ Dynamic Object Creation


 Create object dynamically using new

A* ptr = new A();


ptr->show();
delete ptr; // Always free memory

✅ Array of Objects with Pointers

A* arr = new A[3]; // Create array of 3 objects


delete[] arr; // Use delete[] to free object arrays

✅ this Pointer

 Refers to the current object inside class

class A {
int x;
public:
void set(int x) {
this->x = x; // disambiguates local and member variable
}
};

✅ Shallow Copy vs Deep Copy

 Shallow Copy: Just copies address


 Deep Copy: Duplicates data in new memory

class A {
int* ptr;
public:
A(int val) { ptr = new int(val); }

// Deep copy constructor


A(const A& other) {
ptr = new int(*other.ptr);
}

~A() { delete ptr; }


};
✅ Passing Object to Function

 By value (creates a copy):

void show(A obj) { ... }

 By reference (no copy):

void show(A& obj) { ... }

 By pointer:

void show(A* obj) { obj->display(); }

✅ Returning Object from Function

A createObj() {
A temp;
return temp;
}

✅ Operator Overloading (Example: +)

class A {
int val;
public:
A(int x) { val = x; }
A operator+(A obj) {
return A(val + obj.val);
}
};

✅ Static Functions
 Can only access static members.

class A {
public:
static int count;
static void showCount() {
cout << count;
}
};

✅ Constant Object

 Can only call const functions.

class A {
public:
void show() const { cout << "safe"; }
};
const A obj;
obj.show(); // OK

✅ Inheritance Syntax + Access

class Base {
protected:
int x;
};

class Derived : public Base {


public:
void print() { cout << x; } // OK due to protected
};

✅ Function Overriding

 Same function in base and derived classes.


 Use virtual for polymorphism (coming in future chapters).

class Base {
public:
void show() { cout << "Base"; }
};
class Derived : public Base {
public:
void show() { cout << "Derived"; }
};

✅ Constructor and Destructor in Inheritance

 Base constructor runs before derived.


 Destructor runs in reverse order.

class A {
public:
A() { cout << "A "; }
~A() { cout << "~A "; }
};

class B : public A {
public:
B() { cout << "B "; }
~B() { cout << "~B "; }
};

You might also like