The meaning of Encapsulation, is to make sure that “sensitive” data is hidden from users. To achieve this, you must declare class variables/attributes as private (cannot be accessed from outside the class). If you want others to read or modify the value of a private member, you can provide public get and set methods.
By now, you are quite familiar with the public keyword that appears in all of our class examples:
class MyClass { // The class
public: // Access specifier
// class members goes here
};
The public keyword is an access specifier. Access specifiers define how the members (attributes and methods) of a class can be accessed. In the example above, the members are public – which means that they can be accessed and modified from outside the code. Continue reading C++ Access Specifiers
A constructor in C++ is a special method that is automatically called when an object of a class is created.
To create a constructor, use the same name as the class, followed by parentheses () : Continue reading C++ Constructors
Methods are functions that belongs to the class.
There are two ways to define functions that belongs to a class:
In the following example, we define a function inside the class, and we name it “myMethod“.
Note: You access methods just like you access attributes; by creating an object of the class and using the dot syntax (.): Continue reading C++ Class Methods
C++ is an object-oriented programming language.
Everything in C++ is associated with classes and objects, along with its attributes and methods. For example: in real life, a car is an object. The car has attributes, such as weight and color, and methods, such as drive and brake.
Attributes and methods are basically variables and functions that belongs to the class. These are often referred to as “class members”.
A class is a user-defined data type that we can use in our program, and it works as an object constructor, or a “blueprint” for creating objects.
OOP stands for Object-Oriented Programming.
Procedural programming is about writing procedures or functions that perform operations on the data, while object-oriented programming is about creating objects that contain both data and functions.
Object-oriented programming has several advantages over procedural programming:
Tip: The “Don’t Repeat Yourself” (DRY) principle is about reducing the repetition of code. You should extract out the codes that are common for the application, and place them at a single place and reuse them instead of repeating it.
Recursion is the technique of making a function call itself. This technique provides a way to break complicated problems down into simple problems which are easier to solve.
Recursion may be a bit difficult to understand. The best way to figure out how it works is to experiment with it.
Now that you understand how functions work, it is important to learn how variables act inside and outside of functions.
In C++, variables are only accessible inside the region they are created. This is called scope.
With function overloading, multiple functions can have the same name with different parameters:
int myFunction(int x) float myFunction(float x) double myFunction(double x, double y)
Consider the following example, which have two functions that add numbers of different type : Continue reading C++ Function Overloading
To demonstrate a practical example of using functions, let’s create a program that converts a value from fahrenheit to celsius :
// Function to convert Fahrenheit to Celsius
float toCelsius(float fahrenheit) {
return (5.0 / 9.0) * (fahrenheit - 32.0);
}
int main() {
// Set a fahrenheit value
float f_value = 98.8;
// Call the function with the fahrenheit value
float result = toCelsius(f_value);
// Print the fahrenheit value
cout << "Fahrenheit: " << f_value << "\n";
// Print the result
cout << "Convert Fahrenheit to Celsius: " << result << "\n";
return 0;
}