The return type, as the name suggests, is the type of the value that will be returned from the function to the calling code:

int addAToB(int a, int b)
{
    int answer = a + b; 
    return answer; 
} 

In our slightly dull, but useful, addAtoB example previously, the return type in the signature is int. The function addAToB sends back, or returns, to the code that called it, a value that will fit in an int variable. The return type can be any C++ type we have seen so far, or one of the ones we haven't seen yet.

A function does not have to return a value at all however. In this case the signature must use the void keyword as the return type. When the void keyword is used, the function body must not attempt to return a value as this will cause an error. It can, however, use the return keyword without a value. Here are some combinations of return type and the use of the return keyword that are valid:

void doWhatever()
{ 
  
    // our code 
    // I'm done going back to calling code here 
    // no return is necessary 
  
} 

Another possibility is as follows:

void doSomethigCool()
{ 
  
   // our code 
  
   // I can do this as long as I don't try and add a value 
   return; 
} 

The following code gives us yet more examples of possible functions. Be sure to read the comments as well as the code:

void doYetAnotherThing()
{ 
   // some code 
  
   if(someCondition)
   { 
  
      // if someCondition is true returning to calling code 
      // before the end of the function body 
      return; 
   } 
  
   // More code that might or might not get executed 
  
   return; 
  
   // As I'm at the bottom of the function body 
   // and the return type is void, I'm 
   // really not necessary but I suppose I make it 
   // clear that the function is over. 
 } 

bool detectCollision(Ship a, Ship b)
{ 
  
   // Detect if collision has occurred 
   if(collision) 
   { 
      // Bam!!! 
      return true; 
   } 
   else 
   { 
      // Missed 
      return false; 
   } 
  
} 

The last function example above, detectCollision is a glimpse into the near future of our C++ code, and demonstrates that we can also pass in  user-defined types, called objects, into functions to perform calculations on them.

We could call each of the functions above, in turn, like this:

// OK time to call some functions 
doWhatever(); 
doSomethingCool(); 
doYetAnotherThing(); 
  
if (detectCollision(milleniumFalcon, lukesXWing)) 
{ 
   // The jedi are doomed! 
   // But there is always Leia. 
   // Unless she was on the Falcon? 
} 
else 
{ 
   // Live to fight another day 
} 
  
//continue with code from here 

Don't worry about the odd-looking syntax regarding the detectCollision function, we will see real code like this, quite soon. Simply, we are using the return value (true or false) as the expression, directly in an if statement.

The function name, when we design our own function, can be almost anything at all. But it is best to use words, usually verbs, to clearly explain what the function will do. For example, look at this function:

void functionaroonieboonie(int blibbityblob, float floppyfloatything) 
{ 
   //code here 
} 

The above is perfectly legal, and will work, but these next function names are much clearer:

void doSomeVerySpecificTask() 
{ 
   //code here 
} 

void getMySpaceShipHealth() 
{ 
   //code here 
} 

void startNewGame() 
{ 
   //code here 
} 

Next, let's take a closer look at how we share some values with a function.

We know that a function can return a result to the calling code. What if we need to share some data values from the calling code with the function? Parameters allow us to share values with the function. We have actually already seen examples of parameters while looking at return types. We will look at the same example but a little more closely:

int addAToB(int a, int b) 
{ 
  
   int answer = a + b; 
   return answer; 
  
} 

Above, the parameters are int a and int b. Notice that, in the first line of the function body, we use a + b as if they are already declared and initialized variables. Well, that's because they are. The parameters in the function signature are their declaration and the code that calls the function initializes them.

Also, as we have partly seen in previous examples, we don't have to just use int in our parameters. We can use any C++ type. We can also use as many parameters as necessary to solve our problem, but it is good practice to keep the parameter list as short and therefore manageable as possible.

As we will see in future chapters, we have left a few of the cooler uses of functions out of this introductory tutorial, so that we can learn about related C++ concepts before we take the topic of functions further.

The body is the part we have been kind of avoiding with comments such as:

// code here 
// some code 

But actually, we know exactly what to do here already! Any C++ code we have learned about so far will work in the body of a function.

We have seen how to code a function and we have seen how to call one as well. There is one more thing we need to do, however, to make them work. All functions must have a prototype. A prototype is what makes the compiler aware of our function; without a prototype, the entire game will fail to compile. Fortunately, prototypes are straightforward.

We can simply repeat the function's signature, followed by a semicolon. The caveat is that the prototype must appear before any attempt to call or define the function. So the absolutely simplest example of a fully usable function in action is as follows. Look carefully at the comments and where in the code the different parts of the function appear:

// The prototype 
// Notice the semicolon 
int addAToB(int a, int b); 

int main() 
{ 
  
   // Call the function 
   // Store the result in answer 
   int answer = addAToB(2,2); 
  
   // Called before the definition 
   // but that's OK because of the prototype 
  
   // Exit main 
   return 0; 
  
}// End of main 

// The function definition 
int addAToB(int a, int b) 
{ 
    return a + b; 
} 

What the previous code demonstrates is the following:

Let's see how we can keep our functions organized.

It's well worth pointing out that, if we have multiple functions, especially if they are fairly long, our .cpp file will quickly become unwieldy. This defeats part of the objective that functions are intended for. The solution that we will see in the next project, is that we can add all of our function prototypes to our very own header file (.hpp or .h). Then we can code all of our functions in another  .cpp file, and then simply add another #include... directive in our main .cpp file. In this way we can use any number of functions without adding any of their code (prototype or definition) to our main code file.

Another point that we should discuss about functions is scope. If we declare a variable in a function, either directly or as one of the parameters, then that variable is not usable/visible outside the function. Furthermore, any variables declared outside the function cannot be seen/used inside the function.

The way we should share values between function code and calling code is through the parameters/arguments and the return value.

When a variable is not available, because it is from another function, it is said to be out of scope. When it is available and usable, it is said to be in scope.

There is a lot more we could learn about functions but we know enough about them already to implement the next part of our game. And don't worry if all the technical terms such as parameters, signatures and definitions, and so on have not completely sunk in. The concepts will become clearer when we start to use them.

It has probably not escaped your attention that we have been calling functions, especially SFML functions, by appending the name of an object, a period before the function name, as in the following example:

spriteBee.setPosition... 
window.draw... 
// etc 

And yet, our entire discussion of functions saw us calling functions without any objects. We can write functions as part of a class or simply as a standalone function. When we write a function as part of a class, we need an object of that class to call the function, and when we have a standalone function we don't.

We will write a standalone function in a minute and we will write classes with functions starting in Chapter 6: Object-Oriented Programming, Classes, and SFML Views. Everything we know so far about functions is relevant in both cases.