# Methods

This lesson will show you how to make use of functions inside a structure creating so-called methods.

## Motivation​

In programming, objects from real life are often mirrored, for example when creating a racing game 🏎 we will want to have vehicles that are defined by their

• traits, such as:
• brand
• model 🚘
• max. speed 🚀
• behaviour, e.g:
• acceleration 💨
• braking 🛑

This way of describing objects, separating features and behaviors, is very common. In the lesson on structures we learned how to contain different information about objects within a single type that we created ourselves. By doing so, we described its traits. Now we're going to move on to methods that will allow us to "teach" the object to perform a specific task - that is, to define its behaviour.

## Introduction​

For the purposes of this lesson, let's create a structure that contains the following features of a car:

``struct Car{    // car information    std::string brand;    std::string model;    int         yearOfProduction;    // movement    float       topSpeed = 200;     // (km/h)    float       acceleration = 50;  // (km/h per second)    float       speed = 0;          // current one (km/h)};``

Inside the `main` function, let's create an object of this structure:

``// prism-push-types:Carint main(){    Car car;    car.brand = "Ford";    car.model = "Focus";    car.yearOfProduction = 2010;}``

Now we will move on to how to make it (`car`) work.

## Creating and using methods​

Inside the `Car` structure, at its end, let's put a function, named `accelerate`, which will increase the `speed` by the acceleration value of the `acceleration`:

``struct Car{    // ...    float acceleration = 50;    float speed = 0;    // ...    // increases the speed    void accelerate()    {        speed += acceleration;    }};``
Definition

Methods are functions that are members of a structure (or a class - more on that later in the course). They operate on other structure members and/or provide some functionality for instances of it.

Now we can call `accelerate` on an object, like this:

🔹 Calling the accelerate()
``// prism-push-types:Car// ...int main(){    Car car;    // initial values...    // calling for the first time    car.accelerate();    std::cout << "Current speed: " << car.speed << " km/h\n";    // calling for the second time    car.accelerate();    std::cout << "Current speed: " << car.speed << " km/h\n";}``
Result
``Current speed: 50 km/hCurrent speed: 100 km/h``

We use the dot operator (`car.accelerate`) to access the method we want to call and then inside the parentheses`()` we pass any required arguments as necessary.

🔸 Calling a method
``object.methodName(arguments);``
🔹 Calling a function
``functionName(arguments);``

### Differences between functions and methods​

Most methods could be rewritten as regular free functions (outside of any structure). The `accelerate` method we created above could be rewritten as a function:

``// prism-push-types:Carvoid accelerate(Car& car){    car.speed += car.acceleration;}``

and called like this:

``// prism-push-types:CarCar car;// initial values...// calling for the first timeaccelerate(car);std::cout << "Current speed: " << car.speed << " km/h\n";// calling for the second timeaccelerate(car);std::cout << "Current speed: " << car.speed << " km/h\n";``
See full code
``// prism-push-types:Car#include <iostream>struct Car{    // car information    std::string brand;    std::string model;    int         yearOfProduction;    // movement    float       topSpeed = 200;     // (km/h)    float       acceleration = 50;  // (km/h per second)    float       speed = 0;          // current one (km/h)};void accelerate(Car& car){    car.speed += car.acceleration;}int main(){    Car car;    car.brand = "Ford";    car.model = "Mustang";    car.yearOfProduction = 1969;    car.topSpeed = 250;    car.acceleration = 60;    // initial values...    // calling for the first time    accelerate(car);    std::cout << "Current speed: " << car.speed << " km/h\n";        // calling for the second time    accelerate(car);    std::cout << "Current speed: " << car.speed << " km/h\n";}``

As you can see, the main difference is that we need to pass the object as an argument when calling a function, but we do not need to do this for a method.

### Definition order​

Inside a structure, methods need not be defined before declaring a variable or another method, which also belongs to this structure:

Note the order in which the methods are defined: `limitSpeed` was used in `accelerate`, even though its definition is below. Similarly, the `speed` and `acceleration` fields have been used before their declaration, because it is in the code under this usage. This is allowed within the structure.

``struct Car{    // function that increases the speed    void accelerate()    {        speed += acceleration;        limitSpeed();    }    void limitSpeed() {        if (speed > topSpeed)            speed = topSpeed;    }    // class data members    float topSpeed = 200;    float acceleration = 50;    float speed = 0;    // the rest...};``

### Declaration and definition​

As with functions, we can separate the method declaration and definition. This way we are able to move their definitions outside of the structure body:

``struct Car{    // class data members    float topSpeed = 200;    float acceleration = 50;    float speed = 0;    // the rest...    // Methods declarations:    void limitSpeed();    void accelerate();};void Car::limitSpeed(){    if (speed > topSpeed)        speed = topSpeed;}void Car::accelerate(){    speed += acceleration;    limitSpeed();}``

Note that in this case, we precede the method name with the structure name `Car`, and a double colon `::`, the so-called scope resolution operator.

🔹 Definition outside the structure body scheme
``// prism-push-types:typetype StructureName::methodName(parameters){    // ...}``

One of the advantages of this notation is the ability to separate the interface of the structure from its implementation. This way, once you've implemented methods, each time you look at the structure, you will only see the set of variable and method names that you will use, without getting distracted by the implementation details.

This notation is also crucial when splitting the code into multiple files - we'll tell about it further on in the course.

## Examples​

info

This section requires improvement. You can help by editing this doc page.

## Potential errors​

info

This section requires improvement. You can help by editing this doc page.

# Methods

This lesson will show you how to make use of functions inside a structure creating so-called methods.

## Motivation​

In programming, objects from real life are often mirrored, for example when creating a racing game 🏎 we will want to have vehicles that are defined by their

• traits, such as:
• brand
• model 🚘
• max. speed 🚀
• behaviour, e.g:
• acceleration 💨
• braking 🛑

This way of describing objects, separating features and behaviors, is very common. In the lesson on structures we learned how to contain different information about objects within a single type that we created ourselves. By doing so, we described its traits. Now we're going to move on to methods that will allow us to "teach" the object to perform a specific task - that is, to define its behaviour.

## Introduction​

For the purposes of this lesson, let's create a structure that contains the following features of a car:

``struct Car{    // car information    std::string brand;    std::string model;    int         yearOfProduction;    // movement    float       topSpeed = 200;     // (km/h)    float       acceleration = 50;  // (km/h per second)    float       speed = 0;          // current one (km/h)};``

Inside the `main` function, let's create an object of this structure:

``// prism-push-types:Carint main(){    Car car;    car.brand = "Ford";    car.model = "Focus";    car.yearOfProduction = 2010;}``

Now we will move on to how to make it (`car`) work.

## Creating and using methods​

Inside the `Car` structure, at its end, let's put a function, named `accelerate`, which will increase the `speed` by the acceleration value of the `acceleration`:

``struct Car{    // ...    float acceleration = 50;    float speed = 0;    // ...    // increases the speed    void accelerate()    {        speed += acceleration;    }};``
Definition

Methods are functions that are members of a structure (or a class - more on that later in the course). They operate on other structure members and/or provide some functionality for instances of it.

Now we can call `accelerate` on an object, like this:

🔹 Calling the accelerate()
``// prism-push-types:Car// ...int main(){    Car car;    // initial values...    // calling for the first time    car.accelerate();    std::cout << "Current speed: " << car.speed << " km/h\n";    // calling for the second time    car.accelerate();    std::cout << "Current speed: " << car.speed << " km/h\n";}``
Result
``Current speed: 50 km/hCurrent speed: 100 km/h``

We use the dot operator (`car.accelerate`) to access the method we want to call and then inside the parentheses`()` we pass any required arguments as necessary.

🔸 Calling a method
``object.methodName(arguments);``
🔹 Calling a function
``functionName(arguments);``

### Differences between functions and methods​

Most methods could be rewritten as regular free functions (outside of any structure). The `accelerate` method we created above could be rewritten as a function:

``// prism-push-types:Carvoid accelerate(Car& car){    car.speed += car.acceleration;}``

and called like this:

``// prism-push-types:CarCar car;// initial values...// calling for the first timeaccelerate(car);std::cout << "Current speed: " << car.speed << " km/h\n";// calling for the second timeaccelerate(car);std::cout << "Current speed: " << car.speed << " km/h\n";``
See full code
``// prism-push-types:Car#include <iostream>struct Car{    // car information    std::string brand;    std::string model;    int         yearOfProduction;    // movement    float       topSpeed = 200;     // (km/h)    float       acceleration = 50;  // (km/h per second)    float       speed = 0;          // current one (km/h)};void accelerate(Car& car){    car.speed += car.acceleration;}int main(){    Car car;    car.brand = "Ford";    car.model = "Mustang";    car.yearOfProduction = 1969;    car.topSpeed = 250;    car.acceleration = 60;    // initial values...    // calling for the first time    accelerate(car);    std::cout << "Current speed: " << car.speed << " km/h\n";        // calling for the second time    accelerate(car);    std::cout << "Current speed: " << car.speed << " km/h\n";}``

As you can see, the main difference is that we need to pass the object as an argument when calling a function, but we do not need to do this for a method.

### Definition order​

Inside a structure, methods need not be defined before declaring a variable or another method, which also belongs to this structure:

Note the order in which the methods are defined: `limitSpeed` was used in `accelerate`, even though its definition is below. Similarly, the `speed` and `acceleration` fields have been used before their declaration, because it is in the code under this usage. This is allowed within the structure.

``struct Car{    // function that increases the speed    void accelerate()    {        speed += acceleration;        limitSpeed();    }    void limitSpeed() {        if (speed > topSpeed)            speed = topSpeed;    }    // class data members    float topSpeed = 200;    float acceleration = 50;    float speed = 0;    // the rest...};``

### Declaration and definition​

As with functions, we can separate the method declaration and definition. This way we are able to move their definitions outside of the structure body:

``struct Car{    // class data members    float topSpeed = 200;    float acceleration = 50;    float speed = 0;    // the rest...    // Methods declarations:    void limitSpeed();    void accelerate();};void Car::limitSpeed(){    if (speed > topSpeed)        speed = topSpeed;}void Car::accelerate(){    speed += acceleration;    limitSpeed();}``

Note that in this case, we precede the method name with the structure name `Car`, and a double colon `::`, the so-called scope resolution operator.

🔹 Definition outside the structure body scheme
``// prism-push-types:typetype StructureName::methodName(parameters){    // ...}``

One of the advantages of this notation is the ability to separate the interface of the structure from its implementation. This way, once you've implemented methods, each time you look at the structure, you will only see the set of variable and method names that you will use, without getting distracted by the implementation details.

This notation is also crucial when splitting the code into multiple files - we'll tell about it further on in the course.

## Examples​

info

This section requires improvement. You can help by editing this doc page.

## Potential errors​

info

This section requires improvement. You can help by editing this doc page.