Cheatsheets / C++ for Programmers

Object-Oriented Programming in C++

Class Members

A class is comprised of class members: class City {

Attributes, also known as member data, consist of
information about an instance of the class.
Methods, also known as member functions, are functions // Attribute
that can be used with an instance of the class. int population;

public:
// Method
void add_resident() {
population++;
}

};
Constructor

For a C++ class, a constructor is a special kind of method that #include "city.hpp"
enables control regarding how the objects of a class should be
created. Di erent class constructors can be speci ed for the same
class, but each constructor signature must be unique. class City {

std::string name;
int population;

public:
City(std::string new_name, int new_pop);

};

Objects

In C++, an object is an instance of a class that encapsulates data City nyc;

and functionality pertaining to that data.
Class

A C++ class is a user-de ned data type that encapsulates class Person {
information and behavior about an object. It serves as a blueprint
for future inherited classes.
};

Access Control Operators

C++ classes have access control operators that designate the scope class City {
of class members:
public
private int population;
public members are accessible everywhere; private
members can only be accessed from within the same instance of public:
the class or from friends classes.
void add_resident() {
population++;
}

private:
bool is_capital;

};
Constructors

For a C++ class, a constructor is a special kind of method that #include <iostream>
enables control regarding how the objects of a class should be
created. Di erent class constructors can be speci ed for the same
class, but each constructor signature must be unique. using namespace std;
A constructor can have multiple parameters as well as default
parameter values.
class House {
In order to initialize const or reference type attributes, use
member initializer lists instead of normal constructors. private:
std::string location;
int rooms;

public:
// Constructor with default parameters
House(std::string loc = "New York", int num = 5) {
location = loc;
rooms = num;
}

// Destructor
~House() {
std::cout << "Moved away from " << location <<
"\n";
}
};

int main()
{
House default_house; // Calls House("New York",
5)
House texas_house("Texas"); // Calls
House("Texas", 5)
House big_florida_house("Florida", 10); //
Calls House("Florida", 10)

return 0;
}
Inheritance

In C++, a class can inherit attributes and methods from another #include <iostream>
class. In an inheritance relationship, there are two categories of
classes:
Base class: The class being inherited from. class Base {
Derived class: The class that inherits from the base class. public:
It’s possible to have multi-level inheritance where classes are
constructed in order from the “most base” class to the “most
int base_id;
derived” class.
Base(int new_base) : base_id(new_base) {}
};

class Derived: public Base {

public:
int derived_id;

Derived(int new_base, int new_derived)

: Base(new_base), derived_id(new_derived) {}

void show() {
std::cout << base_id << " " << derived_id;
}
};
int main() {
Derived temp(1, 2);

temp.show(); // Outputs: 1 2

return 0;
}
Access Speci ers

Access speci ers are C++ keywords that determine the scope of #include <iostream>
class components:
public : Class members are accessible from anywhere in
the program. class Computer {
private : Class members are only accessible from inside private:
the class.
int password;
Encapsulation is achieved by declaring class attributes as
private :
Accessor functions: return the value of private public:
member variables. int getPassword() {
Mutator functions: change the value of private
return password;
member variables.
}

void setPassword(int new_password) {

password = new_password;
}
};

int main()
{
Computer dell;

dell.setPassword(12345);
 std::cout << dell.getPassword();

return 0;
}
Classes and Objects

A C++ class is a user-de ned data type that encapsulates #include <iostream>
information and behavior about an object.
A class can have two types of class members:
Attributes, also known as member data, consist of class Dog {
information about an instance of the class. public:
Methods, also known as member functions, are functions
int age;
that can be used with an instance of the class.
An object is an instance of a class and can be created by specifying
the class name. void sound() {
std::cout << "woof\n";
}
};

int main() {
Dog buddy;

buddy.age = 5;

buddy.sound(); // Outputs: woof

}
Polymorphism

In C++, polymorphism occurs when a derived class overrides a #include <iostream>

method inherited from its base class with the same function
signature.
Polymorphism gives a method many “forms”. Which form is class Employee {
executed depends on the type of the caller object. public:
void salary() {
std::cout << "Normal salary.\n";
}
};

class Manager: public Employee {

public:
void salary() {
std::cout << "Normal salary and bonus.\n";
}
};

int main() {
Employee newbie;
Manager boss;

newbie.salary(); // Outputs: Normal salary.

 boss.salary(); // Outputs: Normal salary and
bonus.

return 0;
}

Print Share