Class Methods

Methods are functions that belongs to the class.

There are two ways to define functions that belongs to a class:

 Inside class definition

 Outside class definition

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 by using the dot syntax ( .):

Inside Example
class MyClass { // The class
public: // Access specifier
void myMethod() { // Method/function defined inside the class
cout << "Hello World!";
}
};

int main() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return 0;
}

To define a function outside the class definition, you have to declare it inside the
class and then define it outside of the class. This is done by specifiying the
name of the class, followed the scope resolution :: operator, followed by the
name of the function:

Outside Example
class MyClass { // The class
public: // Access specifier
void myMethod(); // Method/function declaration
};

// Method/function definition outside the class

void MyClass::myMethod() {
 cout << "Hello World!";
}

int main() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return 0;
}

Parameters
You can also add parameters:

Example
#include <iostream>
using namespace std;

class Car {
public:
int speed(int maxSpeed);
s};

int Car::speed(int maxSpeed) {

return maxSpeed;
}

int main() {
Car myObj; // Create an object of Car
cout << myObj.speed(200); // Call the method with an argument
return 0;
}

Constructors
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 ():

Example
class MyClass { // The class
public: // Access specifier
MyClass() { // Constructor
cout << "Hello World!";
}
};

int main() {
MyClass myObj; // Create an object of MyClass (this will call
the constructor)
return 0;
}

Note: The constructor has the same name as the class, it is always public, and
it does not have any return value.

Constructor Parameters
Constructors can also take parameters (just like regular functions), which can be
useful for setting initial values for attributes.

The following class have brand, model and year attributes, and a constructor with
different parameters. Inside the constructor we set the attributes equal to the
constructor parameters (brand=x, etc). When we call the constructor (by creating
an object of the class), we pass parameters to the constructor, which will set the
value of the corresponding attributes to the same:

Example
class Car { // The class
public: // Access specifier
string brand; // Attribute
string model; // Attribute
int year; // Attribute
Car(string x, string y, int z) { // Constructor with parameters
brand = x;
model = y;
year = z;
}
};
int main() {
// Create Car objects and call the constructor with different
values
Car carObj1("BMW", "X5", 1999);
Car carObj2("Ford", "Mustang", 1969);

// Print values
cout << carObj1.brand << " " << carObj1.model << " " <<
carObj1.year << "\n";
cout << carObj2.brand << " " << carObj2.model << " " <<
carObj2.year << "\n";
return 0;
}

Just like functions, constructors can also be defined outside the class. First,
declare the constructor inside the class, and then define it outside of the class
by specifying the name of the class, followed by the scope
resolution :: operator, followed by the name of the constructor (which is the
same as the class):

Example
class Car { // The class
public: // Access specifier
string brand; // Attribute
string model; // Attribute
int year; // Attribute
Car(string x, string y, int z); // Constructor declaration
};

// Constructor definition outside the class

Car::Car(string x, string y, int z) {
brand = x;
model = y;
year = z;
}

int main() {
// Create Car objects and call the constructor with different
values
Car carObj1("BMW", "X5", 1999);
 Car carObj2("Ford", "Mustang", 1969);

// Print values
cout << carObj1.brand << " " << carObj1.model << " " <<
carObj1.year << "\n";
cout << carObj2.brand << " " << carObj2.model << " " <<
carObj2.year << "\n";
return 0;
}

A “setting” function returns nothing, but takes in an argument - it is purely

operational. Its operation is to set a variable in the class to the argument
that is passed in.

Pseudocode:
1. class Horse{
2. int age;
3. boolean gender;
4. float speed;
5.
6. func setAge(int newAge){
7. age = newAge;
8. }
9. func setGender(boolean newGender){
10. gender = newGender;
11. }
12. func setSpeed(float newSpeed){
13. speed = newSpeed;
14. }
15. }
A “getting” function returns an object, but takes in no arguments - it doesn’t
operate on anything. Its purpose is to get a private variable to be read by an
outside class.

Pseudocode:
1. class Horse{
2. int age;
3. boolean gender;
4. float speed;
5.
6. func getAge(){
7. return age;
8. }
9. func getGender(){
10. return gender;
11. }
12. func getSpeed(){
13. return speed;
14. }
15. }